rustc: pre-compute field placements out of Layout.

Author: eddyb

src/librustc/ty/layout.rs

@@ -34,7 +34,6 @@ use session::config::OutputFilenames;
 use traits::Vtable;
 use traits::specialization_graph;
 use ty::{self, CrateInherentImpls, Ty, TyCtxt};
-use ty::layout::{Layout, LayoutError};
 use ty::steal::Steal;
 use ty::subst::Substs;
 use util::nodemap::{DefIdSet, DefIdMap, ItemLocalSet};
@@ -265,7 +264,8 @@ define_maps! { <'tcx>
     [] fn is_freeze_raw: is_freeze_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
     [] fn needs_drop_raw: needs_drop_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
     [] fn layout_raw: layout_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>)
-                                  -> Result<&'tcx Layout, LayoutError<'tcx>>,
+                                  -> Result<ty::layout::CachedLayout<'tcx>,
+                                            ty::layout::LayoutError<'tcx>>,
 
     [] fn dylib_dependency_formats: DylibDepFormats(CrateNum)
                                     -> Rc<Vec<(CrateNum, LinkagePreference)>>,

src/librustc/ty/maps/mod.rs

@@ -17,6 +17,7 @@ use rustc::hir::map::blocks::FnLikeNode;
 use rustc::hir::def::{Def, CtorKind};
 use rustc::hir::def_id::DefId;
 use rustc::ty::{self, Ty, TyCtxt};
+use rustc::ty::layout::LayoutOf;
 use rustc::ty::maps::Providers;
 use rustc::ty::util::IntTypeExt;
 use rustc::ty::subst::{Substs, Subst};
@@ -313,7 +314,7 @@ fn eval_const_expr_partial<'a, 'tcx>(cx: &ConstContext<'a, 'tcx>,
           if tcx.fn_sig(def_id).abi() == Abi::RustIntrinsic {
             let layout_of = |ty: Ty<'tcx>| {
                 let ty = tcx.erase_regions(&ty);
-                tcx.at(e.span).layout_raw(cx.param_env.reveal_all().and(ty)).map_err(|err| {
+                (tcx.at(e.span), cx.param_env).layout_of(ty).map_err(|err| {
                     ConstEvalErr { span: e.span, kind: LayoutError(err) }
                 })
             };

src/librustc_const_eval/eval.rs

@@ -334,7 +334,7 @@ impl<'tcx> LayoutExt<'tcx> for FullLayout<'tcx> {
                 let mut unaligned_offset = Size::from_bytes(0);
                 let mut result = None;
 
-                for i in 0..self.field_count() {
+                for i in 0..self.fields.count() {
                     if unaligned_offset != variant.offsets[i] {
                         return None;
                     }
@@ -371,7 +371,7 @@ impl<'tcx> LayoutExt<'tcx> for FullLayout<'tcx> {
                 let mut max = Size::from_bytes(0);
                 let mut result = None;
 
-                for i in 0..self.field_count() {
+                for i in 0..self.fields.count() {
                     let field = self.field(ccx, i);
                     match (result, field.homogeneous_aggregate(ccx)) {
                         // The field itself must be a homogeneous aggregate.

src/librustc_trans/abi.rs

@@ -209,7 +209,7 @@ pub fn memory_index_to_gep(index: u64) -> u64 {
 pub fn struct_llfields<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                  layout: FullLayout<'tcx>,
                                  variant: &layout::Struct) -> Vec<Type> {
-    let field_count = layout.field_count();
+    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);

src/librustc_trans/adt.rs

@@ -30,7 +30,7 @@ fn is_single_fp_element<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         Layout::Scalar { value: layout::F32, .. } |
         Layout::Scalar { value: layout::F64, .. } => true,
         Layout::Univariant { .. } => {
-            if layout.field_count() == 1 {
+            if layout.fields.count() == 1 {
                 is_single_fp_element(ccx, layout.field(ccx, 0))
             } else {
                 false

src/librustc_trans/cabi_s390x.rs

@@ -25,7 +25,7 @@ fn is_single_fp_element<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         Layout::Scalar { value: layout::F32, .. } |
         Layout::Scalar { value: layout::F64, .. } => true,
         Layout::Univariant { .. } => {
-            if layout.field_count() == 1 {
+            if layout.fields.count() == 1 {
                 is_single_fp_element(ccx, layout.field(ccx, 0))
             } else {
                 false

src/librustc_trans/cabi_x86.rs

@@ -102,14 +102,14 @@ fn classify_arg<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, arg: &ArgType<'tcx>)
             }
 
             Layout::Univariant(ref variant) => {
-                for i in 0..layout.field_count() {
+                for i in 0..layout.fields.count() {
                     let field_off = off + variant.offsets[i];
                     classify(ccx, layout.field(ccx, i), cls, field_off)?;
                 }
             }
 
             Layout::UntaggedUnion { .. } => {
-                for i in 0..layout.field_count() {
+                for i in 0..layout.fields.count() {
                     classify(ccx, layout.field(ccx, i), cls, off)?;
                 }
             }

src/librustc_trans/cabi_x86_64.rs

@@ -429,15 +429,15 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             type_metadata: type_metadata(cx,
                 cx.tcx().mk_mut_ptr(cx.tcx().types.u8),
                 syntax_pos::DUMMY_SP),
-            offset: layout.field_offset(cx, 0),
+            offset: layout.fields.offset(0),
             size: data_ptr_field.size(cx),
             align: data_ptr_field.align(cx),
             flags: DIFlags::FlagArtificial,
         },
         MemberDescription {
             name: "vtable".to_string(),
             type_metadata: type_metadata(cx, vtable_field.ty, syntax_pos::DUMMY_SP),
-            offset: layout.field_offset(cx, 1),
+            offset: layout.fields.offset(1),
             size: vtable_field.size(cx),
             align: vtable_field.align(cx),
             flags: DIFlags::FlagArtificial,
@@ -1321,8 +1321,8 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> {
                                                 layout: FullLayout<'tcx>,
                                                 offset: Size,
                                                 size: Size) {
-                    for i in 0..layout.field_count() {
-                        let field_offset = layout.field_offset(ccx, i);
+                    for i in 0..layout.fields.count() {
+                        let field_offset = layout.fields.offset(i);
                         if field_offset > offset {
                             continue;
                         }
@@ -1414,7 +1414,7 @@ fn describe_enum_variant<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     };
 
     let layout = layout.for_variant(variant_index);
-    let mut field_tys = (0..layout.field_count()).map(|i| {
+    let mut field_tys = (0..layout.fields.count()).map(|i| {
         layout.field(cx, i).ty
     }).collect::<Vec<_>>();
 

src/librustc_trans/debuginfo/metadata.rs

@@ -74,7 +74,7 @@ pub fn size_and_align_of_dst<'a, 'tcx>(bcx: &Builder<'a, 'tcx>, t: Ty<'tcx>, inf
 
             // Recurse to get the size of the dynamically sized field (must be
             // the last field).
-            let field_ty = layout.field(ccx, layout.field_count() - 1).ty;
+            let field_ty = layout.field(ccx, layout.fields.count() - 1).ty;
             let (unsized_size, unsized_align) = size_and_align_of_dst(bcx, field_ty, info);
 
             // FIXME (#26403, #27023): We should be adding padding