rustc: hide details in Layout in favor of Abi or FieldPlacement.

Author: eddyb

src/librustc/ty/layout.rs

@@ -753,11 +753,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences {
                     bug!("failed to get layout for `{}`: {}", t, e)
                 });
 
-                if let Layout::General { ref variants, size, discr, .. } = *layout.layout {
+                if let Layout::General { ref variants, discr, .. } = *layout.layout {
                     let discr_size = discr.size(cx.tcx).bytes();
 
                     debug!("enum `{}` is {} bytes large with layout:\n{:#?}",
-                      t, size.bytes(), layout);
+                      t, layout.size(cx.tcx).bytes(), layout);
 
                     let (largest, slargest, largest_index) = enum_definition.variants
                         .iter()

src/librustc_lint/types.rs

@@ -307,8 +307,8 @@ impl<'tcx> LayoutExt<'tcx> for FullLayout<'tcx> {
             }
 
             layout::Abi::Aggregate { .. } => {
-                if let Layout::Array { count, .. } = *self.layout {
-                    if count > 0 {
+                if let Layout::Array { .. } = *self.layout {
+                    if self.fields.count() > 0 {
                         return self.field(ccx, 0).homogeneous_aggregate(ccx);
                     }
                 }

src/librustc_trans/abi.rs

@@ -42,7 +42,7 @@
 //!   taken to it, implementing them for Rust seems difficult.
 
 use rustc::ty::{self, Ty};
-use rustc::ty::layout::{self, Align, HasDataLayout, LayoutOf, Size, FullLayout};
+use rustc::ty::layout::{self, HasDataLayout, LayoutOf, Size, FullLayout};
 
 use context::CrateContext;
 use type_::Type;
@@ -72,11 +72,7 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         return;
     }
     match *l.layout {
-        layout::NullablePointer { .. } |
-        layout::General { .. } |
-        layout::UntaggedUnion { .. } => { }
-
-        layout::Univariant(ref variant) => {
+        layout::Univariant(_) => {
             let is_enum = if let ty::TyAdt(def, _) = t.sty {
                 def.is_enum()
             } else {
@@ -87,9 +83,11 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             } else {
                 l
             };
-            llty.set_struct_body(&struct_llfields(cx, variant_layout), variant.packed)
-        },
-        _ => bug!("This function cannot handle {} with layout {:#?}", t, l)
+            llty.set_struct_body(&struct_llfields(cx, variant_layout),
+                                 variant_layout.is_packed())
+        }
+
+        _ => {}
     }
 }
 
@@ -102,81 +100,65 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         return cx.llvm_type_of(value.to_ty(cx.tcx()));
     }
     match *l.layout {
-        layout::Univariant(ref variant) => {
+        layout::Univariant(_) => {
             match name {
                 None => {
-                    Type::struct_(cx, &struct_llfields(cx, l), variant.packed)
+                    Type::struct_(cx, &struct_llfields(cx, l), l.is_packed())
                 }
                 Some(name) => {
                     Type::named_struct(cx, name)
                 }
             }
         }
-        layout::UntaggedUnion(ref un) => {
-            // Use alignment-sized ints to fill all the union storage.
-            let fill = union_fill(cx, un.stride(), un.align);
-            match name {
-                None => {
-                    Type::struct_(cx, &[fill], un.packed)
-                }
-                Some(name) => {
-                    let mut llty = Type::named_struct(cx, name);
-                    llty.set_struct_body(&[fill], un.packed);
-                    llty
-                }
-            }
-        }
-        layout::NullablePointer { size, align, .. } |
-        layout::General { size, align, .. } => {
-            let fill = union_fill(cx, size, align);
+        _ => {
+            let align = l.align(cx);
+            let abi_align = align.abi();
+            let elem_ty = if let Some(ity) = layout::Integer::for_abi_align(cx, align) {
+                Type::from_integer(cx, ity)
+            } else {
+                let vec_align = cx.data_layout().vector_align(Size::from_bytes(abi_align));
+                assert_eq!(vec_align.abi(), abi_align);
+                Type::vector(&Type::i32(cx), abi_align / 4)
+            };
+
+            let size = l.size(cx).bytes();
+            assert_eq!(size % abi_align, 0);
+            let fill = Type::array(&elem_ty, size / abi_align);
             match name {
                 None => {
-                    Type::struct_(cx, &[fill], false)
+                    Type::struct_(cx, &[fill], l.is_packed())
                 }
                 Some(name) => {
                     let mut llty = Type::named_struct(cx, name);
-                    llty.set_struct_body(&[fill], false);
+                    llty.set_struct_body(&[fill], l.is_packed());
                     llty
                 }
             }
         }
-        _ => bug!("Unsupported type {} represented as {:#?}", t, l)
     }
 }
 
-fn union_fill(cx: &CrateContext, size: Size, align: Align) -> Type {
-    let abi_align = align.abi();
-    let elem_ty = if let Some(ity) = layout::Integer::for_abi_align(cx, align) {
-        Type::from_integer(cx, ity)
-    } else {
-        let vec_align = cx.data_layout().vector_align(Size::from_bytes(abi_align));
-        assert_eq!(vec_align.abi(), abi_align);
-        Type::vector(&Type::i32(cx), abi_align / 4)
-    };
-
-    let size = size.bytes();
-    assert_eq!(size % abi_align, 0);
-    Type::array(&elem_ty, size / abi_align)
-}
-
 /// Double an index and add 1 to account for padding.
 pub fn memory_index_to_gep(index: u64) -> u64 {
     1 + index * 2
 }
 
 pub fn struct_llfields<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                  layout: FullLayout<'tcx>) -> Vec<Type> {
-    let variant = match *layout.layout {
-        layout::Univariant(ref variant) => variant,
-        _ => bug!("unexpected {:#?}", layout)
-    };
+    debug!("struct_llfields: {:#?}", layout);
+    let align = layout.align(cx);
+    let size = layout.size(cx);
     let field_count = layout.fields.count();
-    debug!("struct_llfields: variant: {:?}", variant);
+
     let mut offset = Size::from_bytes(0);
     let mut result: Vec<Type> = Vec::with_capacity(1 + field_count * 2);
-    for i in variant.field_index_by_increasing_offset() {
+    let field_index_by_increasing_offset = match *layout.layout {
+        layout::Univariant(ref variant) => variant.field_index_by_increasing_offset(),
+        _ => bug!("unexpected {:#?}", layout)
+    };
+    for i in field_index_by_increasing_offset {
         let field = layout.field(cx, i);
-        let target_offset = variant.offsets[i as usize];
+        let target_offset = layout.fields.offset(i as usize);
         debug!("struct_llfields: {}: {:?} offset: {:?} target_offset: {:?}",
             i, field, offset, target_offset);
         assert!(target_offset >= offset);
@@ -187,30 +169,30 @@ pub fn struct_llfields<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         let llty = cx.llvm_type_of(field.ty);
         result.push(llty);
 
-        if variant.packed {
+        if layout.is_packed() {
             assert_eq!(padding.bytes(), 0);
         } else {
             let field_align = field.align(cx);
-            assert!(field_align.abi() <= variant.align.abi(),
+            assert!(field_align.abi() <= align.abi(),
                     "non-packed type has field with larger align ({}): {:#?}",
-                    field_align.abi(), variant);
+                    field_align.abi(), layout);
         }
 
         offset = target_offset + field.size(cx);
     }
-    if variant.sized && field_count > 0 {
-        if offset > variant.stride() {
-            bug!("variant: {:?} stride: {:?} offset: {:?}",
-                variant, variant.stride(), offset);
+    if !layout.is_unsized() && field_count > 0 {
+        if offset > size {
+            bug!("layout: {:#?} stride: {:?} offset: {:?}",
+                 layout, size, offset);
         }
-        let padding = variant.stride() - offset;
-        debug!("struct_llfields: pad_bytes: {:?} offset: {:?} min_size: {:?} stride: {:?}",
-            padding, offset, variant.min_size, variant.stride());
+        let padding = size - offset;
+        debug!("struct_llfields: pad_bytes: {:?} offset: {:?} stride: {:?}",
+               padding, offset, size);
         result.push(Type::array(&Type::i8(cx), padding.bytes()));
         assert!(result.len() == 1 + field_count * 2);
     } else {
-        debug!("struct_llfields: offset: {:?} min_size: {:?} stride: {:?}",
-               offset, variant.min_size, variant.stride());
+        debug!("struct_llfields: offset: {:?} stride: {:?}",
+               offset, size);
     }
 
     result

src/librustc_trans/adt.rs

@@ -65,9 +65,9 @@ pub fn type_is_imm_pair<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>)
     let layout = ccx.layout_of(ty);
     match *layout.layout {
         Layout::FatPointer { .. } => true,
-        Layout::Univariant(ref variant) => {
+        Layout::Univariant(_) => {
             // There must be only 2 fields.
-            if variant.offsets.len() != 2 {
+            if layout.fields.count() != 2 {
                 return false;
             }
 

src/librustc_trans/common.rs

@@ -939,20 +939,6 @@ impl<'tcx> StructMemberDescriptionFactory<'tcx> {
     fn create_member_descriptions<'a>(&self, cx: &CrateContext<'a, 'tcx>)
                                       -> Vec<MemberDescription> {
         let layout = cx.layout_of(self.ty);
-
-        let tmp;
-        let offsets = match *layout.layout {
-            layout::Univariant(ref variant) => &variant.offsets,
-            layout::Vector { element, count } => {
-                let element_size = element.size(cx).bytes();
-                tmp = (0..count).
-                  map(|i| layout::Size::from_bytes(i*element_size))
-                  .collect::<Vec<layout::Size>>();
-                &tmp
-            }
-            _ => bug!("{} is not a struct", self.ty)
-        };
-
         self.variant.fields.iter().enumerate().map(|(i, f)| {
             let name = if self.variant.ctor_kind == CtorKind::Fn {
                 format!("__{}", i)
@@ -964,7 +950,7 @@ impl<'tcx> StructMemberDescriptionFactory<'tcx> {
             MemberDescription {
                 name,
                 type_metadata: type_metadata(cx, field.ty, self.span),
-                offset: offsets[i],
+                offset: layout.fields.offset(i),
                 size,
                 align,
                 flags: DIFlags::FlagZero,
@@ -1022,18 +1008,12 @@ impl<'tcx> TupleMemberDescriptionFactory<'tcx> {
     fn create_member_descriptions<'a>(&self, cx: &CrateContext<'a, 'tcx>)
                                       -> Vec<MemberDescription> {
         let layout = cx.layout_of(self.ty);
-        let offsets = if let layout::Univariant(ref variant) = *layout.layout {
-            &variant.offsets
-        } else {
-            bug!("{} is not a tuple", self.ty);
-        };
-
         self.component_types.iter().enumerate().map(|(i, &component_type)| {
             let (size, align) = cx.size_and_align_of(component_type);
             MemberDescription {
                 name: format!("__{}", i),
                 type_metadata: type_metadata(cx, component_type, self.span),
-                offset: offsets[i],
+                offset: layout.fields.offset(i),
                 size,
                 align,
                 flags: DIFlags::FlagZero,

src/librustc_trans/debuginfo/metadata.rs

@@ -58,23 +58,17 @@ pub fn size_and_align_of_dst<'a, 'tcx>(bcx: &Builder<'a, 'tcx>, t: Ty<'tcx>, inf
             let layout = ccx.layout_of(t);
             debug!("DST {} layout: {:?}", t, layout);
 
-            let (sized_size, sized_align) = match *layout.layout {
-                ty::layout::Layout::Univariant(ref variant) => {
-                    (variant.offsets.last().map_or(0, |o| o.bytes()), variant.align.abi())
-                }
-                _ => {
-                    bug!("size_and_align_of_dst: expcted Univariant for `{}`, found {:#?}",
-                         t, layout);
-                }
-            };
+            let i = layout.fields.count() - 1;
+            let sized_size = layout.fields.offset(i).bytes();
+            let sized_align = layout.align(ccx).abi();
             debug!("DST {} statically sized prefix size: {} align: {}",
                    t, sized_size, sized_align);
             let sized_size = C_usize(ccx, sized_size);
             let sized_align = C_usize(ccx, sized_align);
 
             // Recurse to get the size of the dynamically sized field (must be
             // the last field).
-            let field_ty = layout.field(ccx, layout.fields.count() - 1).ty;
+            let field_ty = layout.field(ccx, i).ty;
             let (unsized_size, unsized_align) = size_and_align_of_dst(bcx, field_ty, info);
 
             // FIXME (#26403, #27023): We should be adding padding

src/librustc_trans/glue.rs

@@ -1108,14 +1108,14 @@ fn trans_const_adt<'a, 'tcx>(
                 build_const_struct(ccx, l.for_variant(variant_index), vals, Some(discr))
             }
         }
-        layout::UntaggedUnion(ref un) => {
+        layout::UntaggedUnion => {
             assert_eq!(variant_index, 0);
             let contents = [
                 vals[0].llval,
-                padding(ccx, un.stride() - ccx.size_of(vals[0].ty))
+                padding(ccx, l.size(ccx) - ccx.size_of(vals[0].ty))
             ];
 
-            Const::new(C_struct(ccx, &contents, un.packed), t)
+            Const::new(C_struct(ccx, &contents, l.is_packed()), t)
         }
         layout::Univariant(_) => {
             assert_eq!(variant_index, 0);
@@ -1162,11 +1162,11 @@ fn build_const_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         offset = ccx.size_of(discr.ty);
     }
 
-    let st = match *layout.layout {
-        layout::Univariant(ref variant) => variant,
+    let field_index_by_increasing_offset = match *layout.layout {
+        layout::Univariant(ref variant) => variant.field_index_by_increasing_offset(),
         _ => bug!("unexpected {:#?}", layout)
     };
-    let parts = st.field_index_by_increasing_offset().map(|i| {
+    let parts = field_index_by_increasing_offset.map(|i| {
         (vals[i], layout.fields.offset(i))
     });
     for (val, target_offset) in parts {
@@ -1178,7 +1178,7 @@ fn build_const_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     // Pad to the size of the whole type, not e.g. the variant.
     cfields.push(padding(ccx, ccx.size_of(layout.ty) - offset));
 
-    Const::new(C_struct(ccx, &cfields, st.packed), layout.ty)
+    Const::new(C_struct(ccx, &cfields, layout.is_packed()), layout.ty)
 }
 
 fn padding(ccx: &CrateContext, size: Size) -> ValueRef {