Remove an extra monomorphize and try to be smarter about tuples

Author: scottmcm

Cargo.lock

@@ -3686,6 +3686,7 @@ name = "rustc_codegen_ssa"
 version = "0.0.0"
 dependencies = [
  "ar_archive_writer",
+ "arrayvec",
  "bitflags 2.5.0",
  "cc",
  "itertools 0.12.1",

compiler/rustc_codegen_ssa/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 [dependencies]
 # tidy-alphabetical-start
 ar_archive_writer = "0.1.5"
+arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 cc = "1.0.90"
 itertools = "0.12"

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -15,7 +15,9 @@ use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, adjustment::PointerCoercion, Instance, Ty, TyCtxt};
 use rustc_session::config::OptLevel;
 use rustc_span::{Span, DUMMY_SP};
-use rustc_target::abi::{self, FieldIdx, FIRST_VARIANT};
+use rustc_target::abi::{self, FIRST_VARIANT};
+
+use arrayvec::ArrayVec;
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     #[instrument(level = "trace", skip(self, bx))]
@@ -722,25 +724,44 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             mir::Rvalue::Use(ref operand) => self.codegen_operand(bx, operand),
             mir::Rvalue::Repeat(..) => {
                 // According to `rvalue_creates_operand`, only ZST
-                // repat rvalues are allowed to be operands.
+                // repeat rvalues are allowed to be operands.
                 let ty = rvalue.ty(self.mir, self.cx.tcx());
                 OperandRef::zero_sized(self.cx.layout_of(self.monomorphize(ty)))
             }
             mir::Rvalue::Aggregate(ref kind, ref fields) => {
                 let ty = rvalue.ty(self.mir, self.cx.tcx());
                 let ty = self.monomorphize(ty);
-                let layout = self.cx.layout_of(self.monomorphize(ty));
+                let layout = self.cx.layout_of(ty);
                 match **kind {
                     _ if layout.is_zst() => OperandRef::zero_sized(layout),
                     mir::AggregateKind::Tuple => {
-                        debug_assert_eq!(
-                            fields.len(),
-                            2,
-                            "We should only get pairs, but got {rvalue:?}"
+                        debug_assert!(
+                            self.cx.is_backend_scalar_pair(layout),
+                            "Expected a scalar pair, but this isn't: {layout:?}",
                         );
-                        let a = self.codegen_operand(bx, &fields[FieldIdx::ZERO]);
-                        let b = self.codegen_operand(bx, &fields[FieldIdx::from_u32(1)]);
-                        let val = OperandValue::Pair(a.immediate(), b.immediate());
+                        let mut immediates = ArrayVec::<Bx::Value, 2>::new();
+                        for (field_idx, field) in fields.iter_enumerated() {
+                            let mut push = |v| {
+                                immediates.try_push(v).unwrap_or_else(|_| {
+                                    bug!("Too many immediates at {field_idx:?} in {layout:?}")
+                                })
+                            };
+
+                            let op = self.codegen_operand(bx, field);
+                            match op.val {
+                                OperandValue::ZeroSized => {}
+                                OperandValue::Immediate(v) => push(v),
+                                OperandValue::Pair(v, w) => {
+                                    push(v);
+                                    push(w);
+                                }
+                                OperandValue::Ref(_) => {
+                                    bug!("reference operand for field {field_idx:?} in {layout:?}")
+                                }
+                            }
+                        }
+                        let [a, b] = immediates.into_inner().unwrap();
+                        let val = OperandValue::Pair(a, b);
                         OperandRef { val, layout }
                     }
                     mir::AggregateKind::Adt(..) => {
@@ -1070,23 +1091,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let layout = self.cx.spanned_layout_of(ty, span);
                 layout.is_zst()
             }
-            mir::Rvalue::Aggregate(ref kind, ref fields) => {
+            mir::Rvalue::Aggregate(ref kind, _) => {
                 let ty = rvalue.ty(self.mir, self.cx.tcx());
                 let ty = self.monomorphize(ty);
                 let layout = self.cx.spanned_layout_of(ty, span);
                 match **kind {
                     // OperandValue::ZeroSized is easy
                     _ if layout.is_zst() => true,
-                    // 2-Tuple of scalars is an easy scalar pair
+                    // If a tuple is a scalar pair, we can grab the immediates from the operands
                     mir::AggregateKind::Tuple => {
-                        fields.len() == 2
-                            && self.cx.is_backend_scalar_pair(layout)
-                            && fields.iter().all(|field| {
-                                let field_ty = field.ty(self.mir, self.cx.tcx());
-                                let field_ty = self.monomorphize(field_ty);
-                                let field_layout = self.cx.spanned_layout_of(field_ty, span);
-                                self.cx.is_backend_immediate(field_layout)
-                            })
+                        self.cx.is_backend_scalar_pair(layout)
                     }
                     // If a non-union is transparent, we can pass it along
                     mir::AggregateKind::Adt(_, _, _, _, None) => {