rustc: collapse Layout::{Raw,StructWrapped}NullablePointer into one variant.

Author: eddyb

src/librustc/ty/layout.rs

@@ -1133,24 +1133,14 @@ pub enum Layout {
     },
 
     /// Two cases distinguished by a nullable pointer: the case with discriminant
-    /// `nndiscr` must have single field which is known to be nonnull due to its type.
-    /// The other case is known to be zero sized. Hence we represent the enum
-    /// as simply a nullable pointer: if not null it indicates the `nndiscr` variant,
-    /// otherwise it indicates the other case.
+    /// `nndiscr` is represented by the struct `nonnull`, where the field at the
+    /// `discr_offset` offset is known to be nonnull due to its type; if that field is null, then
+    /// it represents the other case, which is known to be zero sized.
     ///
     /// For example, `std::option::Option` instantiated at a safe pointer type
     /// is represented such that `None` is a null pointer and `Some` is the
     /// identity function.
-    RawNullablePointer {
-        nndiscr: u64,
-        discr: Primitive
-    },
-
-    /// Two cases distinguished by a nullable pointer: the case with discriminant
-    /// `nndiscr` is represented by the struct `nonnull`, where the field at the
-    /// `discr_offset` offset is known to be nonnull due to its type; if that field is null, then
-    /// it represents the other case, which is known to be zero sized.
-    StructWrappedNullablePointer {
+    NullablePointer {
         nndiscr: u64,
         nonnull: Struct,
         discr: Primitive,
@@ -1259,18 +1249,16 @@ impl<'a, 'tcx> Layout {
                     FieldPlacement::union(def.struct_variant().fields.len())
                 }
 
-                General { .. } |
-                RawNullablePointer { .. } => FieldPlacement::union(1),
+                General { .. } => FieldPlacement::union(1),
 
-                StructWrappedNullablePointer { ref discr_offset, .. } => {
+                NullablePointer { ref discr_offset, .. } => {
                     FieldPlacement::Arbitrary {
                         offsets: ref_slice(discr_offset)
                     }
                 }
             };
             let abi = match *layout {
-                Scalar { value, .. } |
-                RawNullablePointer { discr: value, .. } => Abi::Scalar(value),
+                Scalar { value, .. } => Abi::Scalar(value),
                 CEnum { discr, .. } => Abi::Scalar(Int(discr)),
 
                 Vector { .. } => Abi::Vector,
@@ -1279,8 +1267,15 @@ impl<'a, 'tcx> Layout {
                 FatPointer { .. } |
                 Univariant(_) |
                 UntaggedUnion(_) |
-                General { .. } |
-                StructWrappedNullablePointer { .. } => Abi::Aggregate
+                General { .. } => Abi::Aggregate,
+
+                NullablePointer { discr, discr_offset, .. } => {
+                    if discr_offset.bytes() == 0 && discr.size(cx) == layout.size(cx) {
+                        Abi::Scalar(discr)
+                    } else {
+                        Abi::Aggregate
+                    }
+                }
             };
             Ok(CachedLayout {
                 layout,
@@ -1562,15 +1557,6 @@ impl<'a, 'tcx> Layout {
                         // out of arrays with just the indexing operator.
                         let mut st = if discr == 0 { st0 } else { st1 };
 
-                        // FIXME(eddyb) should take advantage of a newtype.
-                        if offset.bytes() == 0 && primitive.size(dl) == st.stride() &&
-                           variants[discr].len() == 1 {
-                            return success(RawNullablePointer {
-                                nndiscr: discr as u64,
-                                discr: primitive,
-                            });
-                        }
-
                         let mut discr_align = primitive.align(dl);
                         if offset.abi_align(discr_align) != offset {
                             st.packed = true;
@@ -1579,7 +1565,7 @@ impl<'a, 'tcx> Layout {
                         st.align = st.align.max(discr_align);
                         st.primitive_align = st.primitive_align.max(discr_align);
 
-                        return success(StructWrappedNullablePointer {
+                        return success(NullablePointer {
                             nndiscr: discr as u64,
                             nonnull: st,
                             discr: primitive,
@@ -1715,8 +1701,7 @@ impl<'a, 'tcx> Layout {
         match *self {
             Scalar {..} | Vector {..} | FatPointer {..} |
             CEnum {..} | UntaggedUnion {..} | General {..} |
-            RawNullablePointer {..} |
-            StructWrappedNullablePointer {..} => false,
+            NullablePointer {..} => false,
 
             Array { sized, .. } |
             Univariant(Struct { sized, .. }) => !sized
@@ -1727,7 +1712,7 @@ impl<'a, 'tcx> Layout {
         let dl = cx.data_layout();
 
         match *self {
-            Scalar { value, .. } | RawNullablePointer { discr: value, .. } => {
+            Scalar { value, .. } => {
                 value.size(dl)
             }
 
@@ -1760,7 +1745,7 @@ impl<'a, 'tcx> Layout {
             UntaggedUnion(ref un) => un.stride(),
 
             Univariant(ref variant) |
-            StructWrappedNullablePointer { nonnull: ref variant, .. } => {
+            NullablePointer { nonnull: ref variant, .. } => {
                 variant.stride()
             }
         }
@@ -1770,7 +1755,7 @@ impl<'a, 'tcx> Layout {
         let dl = cx.data_layout();
 
         match *self {
-            Scalar { value, .. } | RawNullablePointer { discr: value, .. } => {
+            Scalar { value, .. } => {
                 value.align(dl)
             }
 
@@ -1794,7 +1779,7 @@ impl<'a, 'tcx> Layout {
             UntaggedUnion(ref un) => un.align,
 
             Univariant(ref variant) |
-            StructWrappedNullablePointer { nonnull: ref variant, .. } => {
+            NullablePointer { nonnull: ref variant, .. } => {
                 variant.align
             }
         }
@@ -1809,7 +1794,7 @@ impl<'a, 'tcx> Layout {
         match *self {
             Array { primitive_align, .. } | General { primitive_align, .. } => primitive_align,
             Univariant(ref variant) |
-            StructWrappedNullablePointer { nonnull: ref variant, .. } => {
+            NullablePointer { nonnull: ref variant, .. } => {
                 variant.primitive_align
             },
 
@@ -1924,11 +1909,11 @@ impl<'a, 'tcx> Layout {
         };
 
         match *layout {
-            Layout::StructWrappedNullablePointer { nonnull: ref variant_layout,
-                                                   nndiscr,
-                                                   discr: _,
-                                                   discr_offset: _ } => {
-                debug!("print-type-size t: `{:?}` adt struct-wrapped nullable nndiscr {} is {:?}",
+            Layout::NullablePointer { nonnull: ref variant_layout,
+                                      nndiscr,
+                                      discr: _,
+                                      discr_offset: _ } => {
+                debug!("print-type-size t: `{:?}` adt nullable nndiscr {} is {:?}",
                        ty, nndiscr, variant_layout);
                 let variant_def = &adt_def.variants[nndiscr as usize];
                 let fields: Vec<_> =
@@ -1941,13 +1926,6 @@ impl<'a, 'tcx> Layout {
                                                &fields,
                                                variant_layout)]);
             }
-            Layout::RawNullablePointer { nndiscr, discr } => {
-                debug!("print-type-size t: `{:?}` adt raw nullable nndiscr {} is {:?}",
-                       ty, nndiscr, discr);
-                let variant_def = &adt_def.variants[nndiscr as usize];
-                record(adt_kind.into(), None,
-                       vec![build_primitive_info(variant_def.name, &discr)]);
-            }
             Layout::Univariant(ref variant_layout) => {
                 let variant_names = || {
                     adt_def.variants.iter().map(|v|format!("{}", v.name)).collect::<Vec<_>>()
@@ -2314,7 +2292,7 @@ impl<'a, 'tcx> FullLayout<'tcx> {
                 }
             }
 
-            StructWrappedNullablePointer { nndiscr, ref nonnull, .. }
+            NullablePointer { nndiscr, ref nonnull, .. }
                     if nndiscr as usize == variant_index => {
                 FieldPlacement::Arbitrary {
                     offsets: &nonnull.offsets
@@ -2402,8 +2380,7 @@ impl<'a, 'tcx> FullLayout<'tcx> {
                             General { discr, .. } => {
                                 return [discr.to_ty(tcx, false)][i];
                             }
-                            RawNullablePointer { discr, .. } |
-                            StructWrappedNullablePointer { discr, .. } => {
+                            NullablePointer { discr, .. } => {
                                 return [discr.to_ty(tcx)][i];
                             }
                             _ if def.variants.len() > 1 => return [][i],
@@ -2483,11 +2460,7 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for Layout
                 align.hash_stable(hcx, hasher);
                 primitive_align.hash_stable(hcx, hasher);
             }
-            RawNullablePointer { nndiscr, ref discr } => {
-                nndiscr.hash_stable(hcx, hasher);
-                discr.hash_stable(hcx, hasher);
-            }
-            StructWrappedNullablePointer {
+            NullablePointer {
                 nndiscr,
                 ref nonnull,
                 ref discr,

src/librustc_trans/adt.rs

@@ -69,10 +69,11 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     let l = cx.layout_of(t);
     debug!("finish_type_of: {} with layout {:#?}", t, l);
     match *l {
-        layout::CEnum { .. } | layout::General { .. }
-        | layout::UntaggedUnion { .. } | layout::RawNullablePointer { .. } => { }
-        layout::Univariant { ..}
-        | layout::StructWrappedNullablePointer { .. } => {
+        layout::CEnum { .. } | layout::General { .. } | layout::UntaggedUnion { .. } => { }
+        layout::Univariant { ..} | layout::NullablePointer { .. } => {
+            if let layout::Abi::Scalar(_) = l.abi {
+                return;
+            }
             let (variant_layout, variant) = match *l {
                 layout::Univariant(ref variant) => {
                     let is_enum = if let ty::TyAdt(def, _) = t.sty {
@@ -86,7 +87,7 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                         (l, variant)
                     }
                 }
-                layout::StructWrappedNullablePointer { nndiscr, ref nonnull, .. } =>
+                layout::NullablePointer { nndiscr, ref nonnull, .. } =>
                     (l.for_variant(nndiscr as usize), nonnull),
                 _ => unreachable!()
             };
@@ -103,15 +104,10 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     debug!("adt::generic_type_of t: {:?} name: {:?}", t, name);
     match *l {
         layout::CEnum { discr, .. } => Type::from_integer(cx, discr),
-        layout::RawNullablePointer { nndiscr, .. } => {
-            let nnfield = l.for_variant(nndiscr as usize).field(cx, 0);
-            if let layout::Scalar { value: layout::Pointer, .. } = *nnfield {
-                Type::i8p(cx)
-            } else {
-                cx.llvm_type_of(nnfield.ty)
+        layout::NullablePointer { nndiscr, ref nonnull, .. } => {
+            if let layout::Abi::Scalar(_) = l.abi {
+                return cx.llvm_type_of(l.field(cx, 0).ty);
             }
-        }
-        layout::StructWrappedNullablePointer { nndiscr, ref nonnull, .. } => {
             match name {
                 None => {
                     Type::struct_(cx, &struct_llfields(cx, l.for_variant(nndiscr as usize),

src/librustc_trans/cabi_x86_64.rs

@@ -92,7 +92,7 @@ fn classify_arg<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &ArgType<'tcx>)
                 // by putting variants in fields, or be more clever.
                 match *layout {
                     Layout::General { .. } |
-                    Layout::StructWrappedNullablePointer { .. } => return Err(Memory),
+                    Layout::NullablePointer { .. } => return Err(Memory),
                     _ => {}
                 }
                 for i in 0..layout.fields.count() {

src/librustc_trans/debuginfo/metadata.rs

@@ -1142,7 +1142,6 @@ struct EnumMemberDescriptionFactory<'tcx> {
     type_rep: FullLayout<'tcx>,
     discriminant_type_metadata: Option<DIType>,
     containing_scope: DIScope,
-    file_metadata: DIFile,
     span: Span,
 }
 
@@ -1218,76 +1217,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> {
                     ]
                 }
             }
-            layout::RawNullablePointer { nndiscr, .. } => {
-                // As far as debuginfo is concerned, the pointer this enum
-                // represents is still wrapped in a struct. This is to make the
-                // DWARF representation of enums uniform.
-
-                // First create a description of the artificial wrapper struct:
-                let non_null_variant = &adt.variants[nndiscr as usize];
-                let non_null_variant_name = non_null_variant.name.as_str();
-
-                // The llvm type and metadata of the pointer
-                let nnfield = self.type_rep.for_variant(nndiscr as usize).field(cx, 0);
-                let (size, align) = nnfield.size_and_align(cx);
-                let non_null_type_metadata = type_metadata(cx, nnfield.ty, self.span);
-
-                // For the metadata of the wrapper struct, we need to create a
-                // MemberDescription of the struct's single field.
-                let sole_struct_member_description = MemberDescription {
-                    name: match non_null_variant.ctor_kind {
-                        CtorKind::Fn => "__0".to_string(),
-                        CtorKind::Fictive => {
-                            non_null_variant.fields[0].name.to_string()
-                        }
-                        CtorKind::Const => bug!()
-                    },
-                    type_metadata: non_null_type_metadata,
-                    offset: Size::from_bytes(0),
-                    size,
-                    align,
-                    flags: DIFlags::FlagZero
-                };
-
-                let unique_type_id = debug_context(cx).type_map
-                                                      .borrow_mut()
-                                                      .get_unique_type_id_of_enum_variant(
-                                                          cx,
-                                                          self.enum_type,
-                                                          &non_null_variant_name);
-
-                // Now we can create the metadata of the artificial struct
-                let artificial_struct_metadata =
-                    composite_type_metadata(cx,
-                                            nnfield.ty,
-                                            &non_null_variant_name,
-                                            unique_type_id,
-                                            &[sole_struct_member_description],
-                                            self.containing_scope,
-                                            self.file_metadata,
-                                            syntax_pos::DUMMY_SP);
-
-                // Encode the information about the null variant in the union
-                // member's name.
-                let null_variant_name = adt.variants[(1 - nndiscr) as usize].name;
-                let union_member_name = format!("RUST$ENCODED$ENUM${}${}",
-                                                0,
-                                                null_variant_name);
-
-                // Finally create the (singleton) list of descriptions of union
-                // members.
-                vec![
-                    MemberDescription {
-                        name: union_member_name,
-                        type_metadata: artificial_struct_metadata,
-                        offset: Size::from_bytes(0),
-                        size,
-                        align,
-                        flags: DIFlags::FlagZero
-                    }
-                ]
-            },
-            layout::StructWrappedNullablePointer {
+            layout::NullablePointer {
                 nonnull: ref struct_def,
                 nndiscr,
                 discr,
@@ -1566,9 +1496,7 @@ fn prepare_enum_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         layout::CEnum { discr, signed, .. } => {
             return FinalMetadata(discriminant_type_metadata(discr, signed))
         },
-        layout::RawNullablePointer { .. }           |
-        layout::StructWrappedNullablePointer { .. } |
-        layout::Univariant { .. }                      => None,
+        layout::NullablePointer { .. } | layout::Univariant { .. } => None,
         layout::General { discr, .. } => Some(discriminant_type_metadata(discr, false)),
         ref l @ _ => bug!("Not an enum layout: {:#?}", l)
     };
@@ -1604,7 +1532,6 @@ fn prepare_enum_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             type_rep,
             discriminant_type_metadata,
             containing_scope,
-            file_metadata,
             span,
         }),
     );

src/librustc_trans/mir/constant.rs

@@ -1127,15 +1127,7 @@ fn trans_const_adt<'a, 'tcx>(
         layout::Vector { .. } => {
             Const::new(C_vector(&vals.iter().map(|x| x.llval).collect::<Vec<_>>()), t)
         }
-        layout::RawNullablePointer { nndiscr, .. } => {
-            if variant_index as u64 == nndiscr {
-                assert_eq!(vals.len(), 1);
-                Const::new(vals[0].llval, t)
-            } else {
-                Const::new(C_null(ccx.llvm_type_of(t)), t)
-            }
-        }
-        layout::StructWrappedNullablePointer { ref nonnull, nndiscr, .. } => {
+        layout::NullablePointer { ref nonnull, nndiscr, .. } => {
             if variant_index as u64 == nndiscr {
                 build_const_struct(ccx, l, &nonnull, vals, None)
             } else {