Fix varargs support on aarch64-apple-darwin

Author: beetrees

src/abi/mod.rs

@@ -6,7 +6,7 @@ mod returning;
 
 use std::borrow::Cow;
 
-use cranelift_codegen::ir::SigRef;
+use cranelift_codegen::ir::{ArgumentPurpose, SigRef};
 use cranelift_codegen::isa::CallConv;
 use cranelift_module::ModuleError;
 use rustc_codegen_ssa::errors::CompilerBuiltinsCannotCall;
@@ -532,18 +532,64 @@ pub(crate) fn codegen_terminator_call<'tcx>(
     };
 
     self::returning::codegen_with_call_return_arg(fx, &fn_abi.ret, ret_place, |fx, return_ptr| {
-        let call_args = return_ptr
+        // The majority of this block is hacky workarounds for cranelift not supporting C variadic
+        // functions. The only bits that aren't are the `let mut call_args =` statement (excluding
+        // the `.take()`; `(&mut args_iter)` can be replace with `args.into_iter().enumerate()`)
+        // and the `let call_inst = ` statement.
+
+        let has_return_arg = return_ptr.is_some();
+        let mut args_iter = args.into_iter().enumerate();
+        let mut call_args = return_ptr
             .into_iter()
             .chain(first_arg_override.into_iter())
             .chain(
-                args.into_iter()
-                    .enumerate()
+                (&mut args_iter)
+                    // If the function is variadic, only add the fixed argument first so that how
+                    // many `Value`s the fixed arguments expand to can be counted.
+                    .take(fn_abi.fixed_count as usize)
                     .skip(if first_arg_override.is_some() { 1 } else { 0 })
                     .flat_map(|(i, arg)| {
                         adjust_arg_for_abi(fx, arg.value, &fn_abi.args[i], arg.is_owned).into_iter()
                     }),
             )
             .collect::<Vec<Value>>();
+        // Count how many `Value`s represent the fixed arguments.
+        let fixed_arg_count = call_args.len();
+        // Add the rest of the arguments. This is a no-op unless the function is variadic.
+        call_args.extend(args_iter.flat_map(|(i, arg)| {
+            adjust_arg_for_abi(fx, arg.value, &fn_abi.args[i], arg.is_owned).into_iter()
+        }));
+
+        let padding_arg_count = if fx.tcx.sess.target.is_like_osx
+            && fx.tcx.sess.target.arch == "aarch64"
+            && fn_sig.c_variadic()
+            // No need to pad the argument list unless variadic arguments are actually being passed.
+            && call_args.len() > fixed_arg_count
+        {
+            // 128-bit integers take 2 registers, and everything else takes 1.
+            // FIXME: Add support for non-integer types
+            // This relies on the checks below to ensure all arguments are integer types and that
+            // the ABI is "C".
+            // The return argument isn't counted as it goes in its own dedicated register.
+            let integer_registers_used: usize = call_args
+                [if has_return_arg { 1 } else { 0 }..fixed_arg_count]
+                .iter()
+                .map(|arg| if fx.bcx.func.dfg.value_type(*arg).bits() == 128 { 2 } else { 1 })
+                .sum();
+            // The ABI uses 8 registers before it starts pushing arguments to the stack. Pad out
+            // the registers if needed to ensure the variadic arguments are passed on the stack.
+            if integer_registers_used < 8 {
+                call_args.splice(
+                    fixed_arg_count..fixed_arg_count,
+                    (integer_registers_used..8).map(|_| fx.bcx.ins().iconst(types::I64, 0)),
+                );
+                8 - integer_registers_used
+            } else {
+                0
+            }
+        } else {
+            0
+        };
 
         let call_inst = match func_ref {
             CallTarget::Direct(func_ref) => fx.bcx.ins().call(func_ref, &call_args),
@@ -561,21 +607,37 @@ pub(crate) fn codegen_terminator_call<'tcx>(
                 );
             }
             let sig_ref = fx.bcx.func.dfg.call_signature(call_inst).unwrap();
-            let abi_params = call_args
-                .into_iter()
-                .map(|arg| {
-                    let ty = fx.bcx.func.dfg.value_type(arg);
-                    if !ty.is_int() {
-                        // FIXME set %al to upperbound on float args once floats are supported
-                        fx.tcx.dcx().span_fatal(
-                            source_info.span,
-                            format!("Non int ty {:?} for variadic call", ty),
-                        );
-                    }
-                    AbiParam::new(ty)
-                })
-                .collect::<Vec<AbiParam>>();
-            fx.bcx.func.dfg.signatures[sig_ref].params = abi_params;
+            // Ensure the signature includes all the extra arguments.
+            fx.bcx.func.dfg.signatures[sig_ref] =
+                clif_sig_from_fn_abi(fx.tcx, fx.target_config.default_call_conv, &fn_abi);
+            // Add any padding arguments needed for Apple AArch64.
+            fx.bcx.func.dfg.signatures[sig_ref].params.splice(
+                fixed_arg_count..fixed_arg_count,
+                (0..padding_arg_count).map(|_| AbiParam::new(types::I64)),
+            );
+            // Check all parameters are integers.
+            for param in &fx.bcx.func.dfg.signatures[sig_ref].params {
+                if !param.value_type.is_int() {
+                    // FIXME set %al to upperbound on float args once floats are supported
+                    fx.tcx.dcx().span_fatal(
+                        source_info.span,
+                        format!("Non int ty {:?} for variadic call", param.value_type),
+                    );
+                }
+            }
+
+            if fx.tcx.sess.target.is_like_osx && fx.tcx.sess.target.arch == "aarch64" {
+                // `StructArgument` is not currently used by the `aarch64`, and is therefore not
+                // handled when calculating how many padding arguments to use. Assert that this
+                // remains the case.
+                assert!(fx.bcx.func.dfg.signatures[sig_ref].params.iter().all(|param| matches!(
+                    param.purpose,
+                    // The only purposes used are `Normal` and `StructReturn`.
+                    ArgumentPurpose::Normal | ArgumentPurpose::StructReturn
+                )))
+            }
+
+            assert_eq!(fx.bcx.func.dfg.signatures[sig_ref].params.len(), call_args.len());
         }
 
         call_inst