Let LLVM also handle small aggregate

Author: Urgau

compiler/rustc_middle/src/ty/layout.rs

@@ -14,7 +14,7 @@ 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, PassMode, /* Reg, RegKind, */
 };
 use rustc_target::abi::*;
 use rustc_target::spec::{abi::Abi as SpecAbi, HasTargetSpec, PanicStrategy, Target};
@@ -3340,16 +3340,16 @@ 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)))
-            }
-        }
-    }
+    // /// 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,
@@ -3380,24 +3380,24 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
 
                         if arg.layout.is_unsized() || size > max_by_val_size {
                             arg.make_indirect();
-                        } else if self.has_all_float(&arg.layout) {
-                            // We don't want to aggregate floats as an aggregates of Integer
-                            // 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 > Pointer.size(self) {
-                                arg.make_indirect();
-                            }
-                        } else {
-                            // We want to pass small aggregates as immediates, but using
-                            // a LLVM aggregate type for this leads to bad optimizations,
-                            // so we pick an appropriately sized integer type instead.
-                            //
-                            // NOTE: This is sub-optimal because in the case of (f32, f32, u32, u32)
-                            // we could do ([f32; 2], u64) which is better but this is the best we
-                            // can do right now.
-                            arg.cast_to(Reg { kind: RegKind::Integer, size });
+                        // } else if self.has_all_float(&arg.layout) {
+                        //     // We don't want to aggregate floats as an aggregates of Integer
+                        //     // 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 > Pointer.size(self) {
+                        //         arg.make_indirect();
+                        //     }
+                        // } else {
+                        //     // We want to pass small aggregates as immediates, but using
+                        //     // a LLVM aggregate type for this leads to bad optimizations,
+                        //     // so we pick an appropriately sized integer type instead.
+                        //     //
+                        //     // NOTE: This is sub-optimal because in the case of (f32, f32, u32, u32)
+                        //     // we could do ([f32; 2], u64) which is better but this is the best we
+                        //     // can do right now.
+                        //     arg.cast_to(Reg { kind: RegKind::Integer, size });
                         }
                     }