TEMP FOR PERF: remove the optimization, leaving only the field reordering

Author: erikdesjardins

compiler/rustc_middle/src/ty/layout.rs

@@ -898,123 +898,72 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                 if !def.repr.inhibit_enum_layout_opt() && no_explicit_discriminants {
                     let mut dataful_variant = None;
                     let mut niche_variants = VariantIdx::MAX..=VariantIdx::new(0);
-                    let mut max_size = Size::ZERO;
-                    let mut second_max_size = Size::ZERO;
-                    let mut align = dl.aggregate_align;
 
-                    // The size computations below assume that the padding is minimum.
-                    // This is the case when fields are re-ordered.
-                    let struct_reordering_opt = !def.repr.inhibit_struct_field_reordering_opt();
-
-                    let mut extend_niche_range = |d| {
-                        niche_variants =
-                            *niche_variants.start().min(&d)..=*niche_variants.end().max(&d);
-                    };
-
-                    // Find the largest and second largest variant.
-                    for (v, fields) in variants.iter_enumerated() {
+                    // Find one non-ZST variant.
+                    'variants: for (v, fields) in variants.iter_enumerated() {
                         if absent(fields) {
-                            continue;
+                            continue 'variants;
                         }
-                        let mut size = Size::ZERO;
-                        for &f in fields {
-                            align = align.max(f.align);
-                            size += f.size;
-                        }
-                        if size > max_size {
-                            second_max_size = max_size;
-                            max_size = size;
-                            if let Some(d) = dataful_variant {
-                                extend_niche_range(d);
-                            }
-                            dataful_variant = Some(v);
-                        } else if size == max_size {
-                            if let Some(d) = dataful_variant {
-                                extend_niche_range(d);
+                        for f in fields {
+                            if !f.is_zst() {
+                                if dataful_variant.is_none() {
+                                    dataful_variant = Some(v);
+                                    continue 'variants;
+                                } else {
+                                    dataful_variant = None;
+                                    break 'variants;
+                                }
                             }
-                            dataful_variant = None;
-                            extend_niche_range(v);
-                        } else {
-                            second_max_size = second_max_size.max(size);
-                            extend_niche_range(v);
                         }
+                        niche_variants = *niche_variants.start().min(&v)..=v;
                     }
 
                     if niche_variants.start() > niche_variants.end() {
                         dataful_variant = None;
                     }
 
-                    if let Some(dataful_variant) = dataful_variant {
+                    if let Some(i) = dataful_variant {
                         let count = (niche_variants.end().as_u32()
                             - niche_variants.start().as_u32()
                             + 1) as u128;
 
                         // Find the field with the largest niche
-                        let niche_candidate = variants[dataful_variant]
+                        let niche_candidate = variants[i]
                             .iter()
                             .enumerate()
                             .filter_map(|(j, &field)| Some((j, field.largest_niche.as_ref()?)))
-                            .max_by_key(|(_, n)| (n.available(dl), cmp::Reverse(n.offset)))
-                            .and_then(|(field_index, niche)| {
-                                if !struct_reordering_opt && second_max_size > Size::ZERO {
-                                    return None;
-                                }
-                                // make sure there is enough room for the other variants
-                                if max_size - (niche.offset + niche.scalar.value.size(dl))
-                                    < second_max_size
-                                {
-                                    return None;
-                                }
-                                Some((field_index, niche, niche.reserve(self, count)?))
-                            });
+                            .max_by_key(|(_, niche)| niche.available(dl));
 
                         if let Some((field_index, niche, (niche_start, niche_scalar))) =
-                            niche_candidate
+                            niche_candidate.and_then(|(field_index, niche)| {
+                                Some((field_index, niche, niche.reserve(self, count)?))
+                            })
                         {
-                            let prefix = niche.offset + niche.scalar.value.size(dl);
+                            let mut align = dl.aggregate_align;
                             let st = variants
                                 .iter_enumerated()
                                 .map(|(j, v)| {
                                     let mut st = self.univariant_uninterned(
                                         ty,
                                         v,
                                         &def.repr,
-                                        if j == dataful_variant || second_max_size == Size::ZERO {
-                                            StructKind::AlwaysSized
-                                        } else {
-                                            StructKind::Prefixed(
-                                                prefix,
-                                                Align::from_bytes(1).unwrap(),
-                                            )
-                                        },
+                                        StructKind::AlwaysSized,
                                     )?;
                                     st.variants = Variants::Single { index: j };
 
-                                    debug_assert_eq!(align, align.max(st.align));
+                                    align = align.max(st.align);
+
                                     Ok(st)
                                 })
                                 .collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
 
-                            let offset = if struct_reordering_opt {
-                                debug_assert_eq!(
-                                    st[dataful_variant].fields.offset(field_index),
-                                    Size::ZERO
-                                );
-                                niche.offset
-                            } else {
-                                st[dataful_variant].fields.offset(field_index) + niche.offset
-                            };
-
-                            let size = st[dataful_variant].size.align_to(align.abi);
-                            debug_assert!(
-                                !struct_reordering_opt || size == max_size.align_to(align.abi)
-                            );
-                            debug_assert!(st.iter().all(|v| v.size <= size));
+                            let offset = st[i].fields.offset(field_index) + niche.offset;
+                            let size = st[i].size;
 
                             let abi = if st.iter().all(|v| v.abi.is_uninhabited()) {
                                 Abi::Uninhabited
-                            } else if second_max_size == Size::ZERO {
-                                match st[dataful_variant].abi {
+                            } else {
+                                match st[i].abi {
                                     Abi::Scalar(_) => Abi::Scalar(niche_scalar.clone()),
                                     Abi::ScalarPair(ref first, ref second) => {
                                         // We need to use scalar_unit to reset the
@@ -1036,8 +985,6 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                                     }
                                     _ => Abi::Aggregate { sized: true },
                                 }
-                            } else {
-                                Abi::Aggregate { sized: true }
                             };
 
                             let largest_niche =
@@ -1047,7 +994,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
                                 variants: Variants::Multiple {
                                     tag: niche_scalar,
                                     tag_encoding: TagEncoding::Niche {
-                                        dataful_variant,
+                                        dataful_variant: i,
                                         niche_variants,
                                         niche_start,
                                     },

compiler/rustc_mir_build/src/thir/mod.rs

@@ -97,7 +97,7 @@ crate enum StmtKind<'tcx> {
 
 // `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_arch = "x86_64")]
-rustc_data_structures::static_assert_size!(Expr<'_>, if cfg!(bootstrap) { 168 } else { 160 });
+rustc_data_structures::static_assert_size!(Expr<'_>, 168);
 
 /// The Thir trait implementor lowers their expressions (`&'tcx H::Expr`)
 /// into instances of this `Expr` enum. This lowering can be done