Make index_by_increasing_offset return one item for primitives

scottmcm · scottmcm · commit 99213ae164e4 · 2024-05-11T21:22:51.000-07:00
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
@@ -1271,7 +1271,12 @@ impl<FieldIdx: Idx> FieldsShape<FieldIdx> {
             }
         }
 
-        (0..self.count()).map(move |i| match *self {
+        // Primitives don't really have fields in the way that structs do,
+        // but having this return an empty iterator for them is unhelpful
+        // since that makes them look kinda like ZSTs, which they're not.
+        let pseudofield_count = if let FieldsShape::Primitive = self { 1 } else { self.count() };
+
+        (0..pseudofield_count).map(move |i| match *self {
             FieldsShape::Primitive | FieldsShape::Union(_) | FieldsShape::Array { .. } => i,
             FieldsShape::Arbitrary { .. } => {
                 if use_small {
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -18,7 +18,6 @@ use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::{self, FieldIdx, FIRST_VARIANT};
 
 use arrayvec::ArrayVec;
-use either::Either;
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     #[instrument(level = "trace", skip(self, bx))]
@@ -698,24 +697,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
             mir::Rvalue::Use(ref operand) => self.codegen_operand(bx, operand),
             mir::Rvalue::Repeat(..) => bug!("{rvalue:?} in codegen_rvalue_operand"),
-            mir::Rvalue::Aggregate(ref kind, ref fields) => {
+            mir::Rvalue::Aggregate(_, ref fields) => {
                 let ty = rvalue.ty(self.mir, self.cx.tcx());
                 let ty = self.monomorphize(ty);
                 let layout = self.cx.layout_of(ty);
 
-                let field_indices = if let mir::AggregateKind::RawPtr(..) = **kind {
-                    // `index_by_increasing_offset` gives an empty iterator for primitives
-                    Either::Left([0_usize, 1_usize].iter().copied())
-                } else {
-                    Either::Right(layout.fields.index_by_increasing_offset())
-                };
-                debug_assert_eq!(field_indices.len(), fields.len());
-
                 // `rvalue_creates_operand` has arranged that we only get here if
                 // we can build the aggregate immediate from the field immediates.
                 let mut inputs = ArrayVec::<Bx::Value, 2>::new();
                 let mut input_scalars = ArrayVec::<abi::Scalar, 2>::new();
-                for field_idx in field_indices {
+                for field_idx in layout.fields.index_by_increasing_offset() {
                     let field_idx = FieldIdx::from_usize(field_idx);
                     let op = self.codegen_operand(bx, &fields[field_idx]);
                     let values = op.val.immediates_or_place().left_or_else(|p| {

Original file line number	Diff line number	Diff line change
`@@ -1271,7 +1271,12 @@ impl<FieldIdx: Idx> FieldsShape<FieldIdx> {`
`1271`	`1271`	`}`
`1272`	`1272`	`}`
`1273`	`1273`
`1274`		`- (0..self.count()).map(move \|i\| match *self {`
	`1274`	`+ // Primitives don't really have fields in the way that structs do,`
	`1275`	`+ // but having this return an empty iterator for them is unhelpful`
	`1276`	`+ // since that makes them look kinda like ZSTs, which they're not.`
	`1277`	`+ let pseudofield_count = if let FieldsShape::Primitive = self { 1 } else { self.count() };`
	`1278`	`+`
	`1279`	`+ (0..pseudofield_count).map(move \|i\| match *self {`
`1275`	`1280`	`FieldsShape::Primitive \| FieldsShape::Union(_) \| FieldsShape::Array { .. } => i,`
`1276`	`1281`	`FieldsShape::Arbitrary { .. } => {`
`1277`	`1282`	`if use_small {`