fix the Xtensa ABI implementation

Author: MabezDev

compiler/rustc_target/src/abi/call/xtensa.rs

@@ -1,7 +1,7 @@
 // reference: https://github.com/MabezDev/llvm-project/blob/xtensa_release_9.0.1_with_rust_patches-31-05-2020-cherry-pick/clang/lib/CodeGen/TargetInfo.cpp#L9668-L9767
 
 use crate::abi::call::{ArgAbi, FnAbi, Reg, Uniform};
-use crate::abi::{Abi, HasDataLayout, Size, TyAbiInterface};
+use crate::abi::{Abi, Align, FieldsShape, HasDataLayout, Size, TyAbiInterface};
 use crate::spec::HasTargetSpec;
 
 const NUM_ARG_GPRS: u64 = 6;
@@ -12,27 +12,41 @@ where
     Ty: TyAbiInterface<'a, C> + Copy,
 {
     let mut arg_gprs_left = NUM_RET_ARG_GPRS;
-    classify_arg_ty(arg, &mut arg_gprs_left, NUM_RET_ARG_GPRS);
-    
-    // classify_arg_ty can make the arg indirect by value which is not valid for ret args
-    match arg.mode {
-        super::PassMode::Indirect { attrs: _, extra_attrs: _, ref mut on_stack } => *on_stack = false,
-        _ => {}
+
+    let size = arg.layout.size.align_to(Align::from_bits(32).unwrap());
+
+    // The rules for return and argument with type size more then 4 bytes
+    // are the same, so defer to classifyArgumentType.
+    if size.bits() > 32 {
+        classify_arg_ty(arg, &mut arg_gprs_left, NUM_RET_ARG_GPRS);
+
+        // classify_arg_ty can make the arg indirect by value which is not valid for ret args
+        match arg.mode {
+            super::PassMode::Indirect { attrs: _, extra_attrs: _, ref mut on_stack } => {
+                *on_stack = false
+            }
+            _ => {}
+        }
+    } else {
+        // LLVM DefaultABIInfo::classifyReturnType
+        if arg.layout.is_aggregate() {
+            arg.make_indirect()
+        } else {
+            arg.extend_integer_width_to(32)
+        }
     }
 }
 
 fn classify_arg_ty<'a, Ty, C>(arg: &mut ArgAbi<'_, Ty>, arg_gprs_left: &mut u64, num_gprs: u64)
 where
     Ty: TyAbiInterface<'a, C> + Copy,
 {
-    assert!(*arg_gprs_left <= num_gprs, "Arg GPR tracking underflow");
+    assert!(*arg_gprs_left <= num_gprs, "GPR tracking underflow");
 
     if arg.layout.is_zst() {
         return; // ignore args that take no size
     }
 
-    // TODO check is arg has non-trvial constructor
-
     let size = arg.layout.size.bits();
     let align = arg.layout.align.abi.bits();
     let mut must_use_stack = false;
@@ -43,40 +57,51 @@ where
         required_gprs += *arg_gprs_left % 2;
     }
 
-    // Put on stack objects which are not fit to 6 registers,
+    // Put on stack objects which are not fit to num_gprs registers,
     // also on stack object which alignment more then 16 bytes and
     // object with 16-byte alignment if it isn't the first argument.
-    if required_gprs > *arg_gprs_left || align > 128 || *arg_gprs_left < 6 && align == 128 {
+    if required_gprs > *arg_gprs_left || align > 128 || *arg_gprs_left < num_gprs && align == 128 {
         must_use_stack = true;
         required_gprs = *arg_gprs_left;
     }
     *arg_gprs_left -= required_gprs;
 
-    if arg.layout.is_aggregate() && !matches!(arg.layout.abi, Abi::Vector { element: _ , count: _ }) && !must_use_stack {
-        if size < 32 && !must_use_stack {
-            arg.extend_integer_width_to(32);
-        } else if size == 64 {
-            arg.cast_to(Reg::i64());
+    if must_use_stack {
+        arg.make_indirect_byval();
+    } else {
+        if arg.layout.is_aggregate()
+            && !matches!(arg.layout.abi, Abi::Vector { element: _, count: _ })
+        {
+            if size < 32 && matches!(arg.layout.fields, FieldsShape::Primitive) {
+                arg.extend_integer_width_to(32);
+            } else if size == 64 {
+                arg.cast_to(Reg::i64());
+            } else {
+                arg.cast_to(Uniform {
+                    unit: Reg::i32(),
+                    total: Size::from_bits(required_gprs * 32),
+                });
+            }
+        } else if size <= num_gprs * 32 {
+            // Aggregates which are <= num_gprs*32 will be passed in registers if possible,
+            // so coerce to integers.
+            if size <= 32 {
+                arg.cast_to(Reg::i32())
+            } else if align == 64 {
+                arg.cast_to(Uniform {
+                    unit: Reg::i64(),
+                    total: Size::from_bits((required_gprs / 2) * 32),
+                });
+            } else {
+                arg.cast_to(Uniform {
+                    unit: Reg::i32(),
+                    total: Size::from_bits(required_gprs * 32),
+                });
+            }
         } else {
-            arg.cast_to(Reg::i32());
+            panic!("unhandled GPR")
         }
-        return;
     }
-
-    // Aggregates which are <= 6*32 will be passed in registers if possible,
-    // so coerce to integers.
-    if size <= (num_gprs * 32) && !must_use_stack {
-        if size <= 32 {
-            arg.cast_to(Reg::i32())
-        } else if align == 64 {
-            arg.cast_to(Uniform { unit: Reg::i64(), total: Size::from_bits((required_gprs / 2) * 32) });
-        } else {
-            arg.cast_to(Uniform { unit: Reg::i32(), total: Size::from_bits(required_gprs * 32) });
-        }
-        return;
-    }
-
-    arg.make_indirect_byval()
 }
 
 pub fn compute_abi_info<'a, Ty, C>(_cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
@@ -87,17 +112,13 @@ where
     if !fn_abi.ret.is_ignore() {
         classify_ret_ty(&mut fn_abi.ret);
     }
-    
+
     let mut avail_gprs = NUM_ARG_GPRS;
 
-    for arg in fn_abi.args.iter_mut(){
+    for arg in fn_abi.args.iter_mut() {
         if arg.is_ignore() {
             continue;
         }
-        classify_arg_ty(
-            arg,
-            &mut avail_gprs,
-            NUM_ARG_GPRS
-        );
+        classify_arg_ty(arg, &mut avail_gprs, NUM_ARG_GPRS);
     }
 }