Retry with the homogeneous aggregate concept

Author: Urgau

compiler/rustc_middle/src/ty/layout.rs

@@ -14,7 +14,8 @@ use rustc_session::{config::OptLevel, DataTypeKind, FieldInfo, SizeKind, Variant
 use rustc_span::symbol::Symbol;
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::call::{
-    ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, Conv, FnAbi, PassMode, Reg, RegKind,
+    ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, Conv, FnAbi, HomogeneousAggregate, PassMode,
+    Reg, RegKind,
 };
 use rustc_target::abi::*;
 use rustc_target::spec::{abi::Abi as SpecAbi, HasTargetSpec, PanicStrategy, Target};
@@ -3340,17 +3341,6 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
         Ok(self.tcx.arena.alloc(fn_abi))
     }
 
-    /// Small heuristic for determining if layout has any float primitive
-    fn has_all_float(&self, layout: &'_ TyAndLayout<'tcx>) -> bool {
-        match layout.abi {
-            Abi::Uninhabited | Abi::Vector { .. } => false,
-            Abi::Scalar(scalar) => matches!(scalar.primitive(), Primitive::F32 | Primitive::F64),
-            Abi::ScalarPair(..) | Abi::Aggregate { .. } => {
-                (0..layout.fields.count()).all(|i| self.has_all_float(&layout.field(self, i)))
-            }
-        }
-    }
-
     fn fn_abi_adjust_for_abi(
         &self,
         fn_abi: &mut FnAbi<'tcx, Ty<'tcx>>,
@@ -3381,12 +3371,19 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
 
                         if arg.layout.is_unsized() || size > max_by_val_size {
                             arg.make_indirect();
-                        } else if size > ptr_size && self.has_all_float(&arg.layout) {
+                        } else if let Ok(HomogeneousAggregate::Homogeneous(Reg {
+                            kind: RegKind::Float,
+                            ..
+                        })) = arg.layout.homogeneous_aggregate(self)
+                        {
                             // We don't want to aggregate floats as an aggregates of Integer
-                            // because this will hurt the generated assembly (#93490) but as an
-                            // optimization we want to pass homogeneous aggregate of floats
-                            // greater than pointer size as indirect.
-                            arg.make_indirect();
+                            // because this will hurt the generated assembly (#93490)
+                            //
+                            // As an optimization we want to pass homogeneous aggregate of floats
+                            // greater than pointer size as indirect
+                            if size > ptr_size {
+                                arg.make_indirect();
+                            }
                         } else {
                             // We want to pass small aggregates as immediates, but using
                             // a LLVM aggregate type for this leads to bad optimizations,

src/test/codegen/homogeneous-floats.rs

@@ -13,7 +13,7 @@ pub struct Foo {
     bar4: f32,
 }
 
-// CHECK: define i64 @array_f32x2(i64 %0, i64 %1)
+// CHECK: define [2 x float] @array_f32x2([2 x float] %0, [2 x float] %1)
 #[no_mangle]
 pub fn array_f32x2(a: [f32; 2], b: [f32; 2]) -> [f32; 2] {
     todo!()