sparc64 cleanup

Author: folkertdev

compiler/rustc_target/src/callconv/mips64.rs

@@ -1,7 +1,7 @@
 use arrayvec::ArrayVec;
 use rustc_abi::{
-    BackendRepr, FieldsShape, Float, HasDataLayout, Numeric, Primitive, Reg, RegKind, Size,
-    TyAbiInterface,
+    BackendRepr, FieldsShape, Float, HasDataLayout, Integer, Numeric, Primitive, Reg, RegKind,
+    Size, TyAbiInterface,
 };
 
 use crate::callconv::{ArgAbi, ArgAttribute, ArgExtension, CastTarget, FnAbi, PassMode, Uniform};
@@ -59,14 +59,17 @@ where
     let bits = size.bits();
     if bits <= 128 {
         if let Some(component) = ret.layout.complex_number(cx) {
-            if matches!(component, Numeric::Int(..)) && size <= cx.data_layout().pointer_size() {
-                // Return a Complex<{integer}> packed into a single register when that fits.
-                // We match GCC, not Clang, see https://github.com/llvm/llvm-project/issues/212109.
-                ret.cast_to(Reg { kind: RegKind::Integer, size });
-            } else {
-                // Otherwise pass in 2 registers.
-                let reg = Reg { kind: component.reg_kind(), size: component.size() };
-                ret.cast_to(CastTarget::pair(reg, reg));
+            match component {
+                Numeric::Int(Integer::I8 | Integer::I16 | Integer::I32, _) => {
+                    // Return a Complex<{integer}> packed into a single register when that fits.
+                    // We match GCC, not Clang, see https://github.com/llvm/llvm-project/issues/212109.
+                    ret.cast_to(Reg { kind: RegKind::Integer, size });
+                }
+                _ => {
+                    // Otherwise pass in 2 registers.
+                    let reg = Reg { kind: component.reg_kind(), size: component.size() };
+                    ret.cast_to(CastTarget::pair(reg, reg));
+                }
             }
             return;
         }
@@ -118,33 +121,38 @@ where
         extend_integer_width_mips(arg, 64);
     } else if arg.layout.pass_indirectly_in_non_rustic_abis(cx) {
         arg.make_indirect();
-    } else if arg.layout.complex_float(cx).is_some() && size > dl.pointer_size() * 2 {
-        // Complex<f128> is passed in 4 GPRs, but aligned to 16 so may need padding.
-        let reg = Reg { kind: RegKind::Float, size: arg.layout.field(cx, 0).size };
-        arg.cast_to_and_pad_i32(CastTarget::pair(reg, reg), pad_i32);
-    } else if arg.layout.is_complex_number(cx) && size <= dl.pointer_size() * 2 {
+    } else if let Some(component) = arg.layout.complex_number(cx) {
         let slot = dl.pointer_size();
         let curr_offset = offset.align_to(align);
 
-        if arg.layout.complex_float(cx).is_some() {
-            // Only pass a Complex<f32>/Complex<f64> in FPRs when two argument slots are free,
-            // otherwise pack it into GPRs (or the stack) like an integer of the same size.
-            if curr_offset.bytes() / slot.bytes() + 2 <= NUM_ARG_SLOTS {
-                // The default `PassMode::Pair` already passes one component per register. Both
-                // components claim a slot, even for a Complex<f32> which could fit into one slot.
-                *offset = curr_offset + slot * 2;
-                return;
+        match component {
+            Numeric::Float(Float::F128) => {
+                // Complex<f128> is passed in 4 GPRs, but aligned to 16 so may need padding.
+                let reg = Reg { kind: RegKind::Float, size: arg.layout.field(cx, 0).size };
+                arg.cast_to_and_pad_i32(CastTarget::pair(reg, reg), pad_i32);
             }
+            Numeric::Float(_) => {
+                // Only pass a Complex<f32>/Complex<f64> in FPRs when two argument slots are free,
+                if curr_offset.bytes() / slot.bytes() + 2 <= NUM_ARG_SLOTS {
+                    // The default `PassMode::Pair` already passes one component per register. Both
+                    // components claim a slot, even a Complex<f32> which could fit into one slot.
+                    *offset = curr_offset + slot * 2;
+                    return;
+                }
 
-            arg.cast_to_and_pad_i32(Uniform::new(Reg::i64(), size), pad_i32);
-        } else if size > slot {
-            // Complex<i64> is passed as 2 separate arguments, which is what the default
-            // `PassMode::Pair` already does.
-        } else {
-            // Cast Complex<i8> into i16, Complex<i16> to i32, etc. The inreg attribute is required
-            // to make the bits land in the right (upper) bits on big endian targets.
-            let cast_target = CastTarget::from(Reg { kind: RegKind::Integer, size });
-            arg.cast_to(cast_target.with_attrs(ArgAttribute::InReg.into()));
+                // Otherwise pack it into GPRs (or the stack) like an integer of the same size.
+                arg.cast_to_and_pad_i32(Uniform::new(Reg::i64(), size), pad_i32);
+            }
+            Numeric::Int(Integer::I8 | Integer::I16 | Integer::I32, _) => {
+                // Cast Complex<i8> into i16, Complex<i16> to i32, etc.
+                let cast_target = CastTarget::from(Reg { kind: RegKind::Integer, size });
+                // The inreg attribute makes the bits land in the right (upper) bits on BE targets.
+                arg.cast_to(cast_target.with_attrs(ArgAttribute::InReg.into()));
+            }
+            Numeric::Int(Integer::I64 | Integer::I128, _) => {
+                // Complex<i64> is passed as 2 separate arguments, which is what the default
+                // `PassMode::Pair` already does.
+            }
         }
     } else {
         match arg.layout.fields {