Merge pull request #489 from rustcoreutils/updates

Fixes to compile zlib

Author: jgarzik

cc/arch/aarch64/call.rs

@@ -127,6 +127,10 @@ impl Aarch64CodeGen {
     }
 
     /// Set up register arguments for standard AAPCS64 calls
+    ///
+    /// AAPCS64 requires stack arguments to be placed in parameter order at
+    /// consecutive 8-byte slots starting from SP. Unlike x86-64, we don't use
+    /// push instructions - instead we pre-allocate space and store directly.
     pub(super) fn setup_register_args(
         &mut self,
         insn: &Instruction,
@@ -136,9 +140,17 @@ impl Aarch64CodeGen {
     ) -> i32 {
         let int_arg_regs = Reg::arg_regs();
         let fp_arg_regs = VReg::arg_regs();
+
+        // First pass: identify which args go to registers vs stack
+        // Collect stack args with their info for the second pass
+        struct StackArg {
+            pseudo: PseudoId,
+            is_fp: bool,
+            size: u32,
+        }
+        let mut stack_args_info: Vec<StackArg> = Vec::new();
         let mut int_arg_idx = 0;
         let mut fp_arg_idx = 0;
-        let mut stack_args = 0;
 
         for (i, &arg) in insn.src.iter().enumerate().skip(args_start) {
             let arg_type = insn.arg_types.get(i).copied();
@@ -168,52 +180,96 @@ impl Aarch64CodeGen {
                     );
                     fp_arg_idx += 2;
                 } else {
-                    stack_args += 2;
+                    // Complex on stack needs 2 slots
+                    stack_args_info.push(StackArg {
+                        pseudo: arg,
+                        is_fp: true,
+                        size: arg_size,
+                    });
+                    stack_args_info.push(StackArg {
+                        pseudo: arg,
+                        is_fp: true,
+                        size: arg_size,
+                    });
                 }
             } else if is_fp {
-                let fp_size = if let Some(typ) = arg_type {
-                    types.size_bits(typ)
-                } else {
-                    64
-                };
                 if fp_arg_idx < fp_arg_regs.len() {
+                    let fp_size = if let Some(typ) = arg_type {
+                        types.size_bits(typ)
+                    } else {
+                        64
+                    };
                     self.emit_fp_move(arg, fp_arg_regs[fp_arg_idx], fp_size, frame_size);
                     fp_arg_idx += 1;
                 } else {
-                    self.emit_fp_move(arg, VReg::V16, fp_size, frame_size);
-                    let fp_sz = if fp_size == 32 {
-                        FpSize::Single
-                    } else {
-                        FpSize::Double
-                    };
-                    self.push_lir(Aarch64Inst::StrFp {
-                        size: fp_sz,
-                        src: VReg::V16,
-                        addr: MemAddr::PreIndex {
-                            base: Reg::SP,
-                            offset: -16,
-                        },
+                    stack_args_info.push(StackArg {
+                        pseudo: arg,
+                        is_fp: true,
+                        size: arg_size,
                     });
-                    stack_args += 1;
                 }
             } else if int_arg_idx < int_arg_regs.len() {
                 self.emit_move(arg, int_arg_regs[int_arg_idx], arg_size, frame_size);
                 int_arg_idx += 1;
             } else {
-                self.emit_move(arg, Reg::X9, arg_size, frame_size);
+                stack_args_info.push(StackArg {
+                    pseudo: arg,
+                    is_fp: false,
+                    size: arg_size,
+                });
+            }
+        }
+
+        // If no stack args, we're done
+        if stack_args_info.is_empty() {
+            return 0;
+        }
+
+        // Pre-allocate stack space for all stack args (8 bytes each, 16-byte aligned)
+        let num_stack_args = stack_args_info.len();
+        let stack_bytes = (num_stack_args * 8) as i32;
+        let aligned_bytes = (stack_bytes + 15) & !15;
+
+        self.push_lir(Aarch64Inst::Sub {
+            size: OperandSize::B64,
+            src1: Reg::sp(),
+            src2: GpOperand::Imm(aligned_bytes as i64),
+            dst: Reg::sp(),
+        });
+
+        // Store each stack arg at its proper offset from SP (in parameter order)
+        for (idx, stack_arg) in stack_args_info.into_iter().enumerate() {
+            let offset = (idx * 8) as i32;
+            if stack_arg.is_fp {
+                self.emit_fp_move(stack_arg.pseudo, VReg::V16, stack_arg.size, frame_size);
+                let fp_sz = if stack_arg.size == 32 {
+                    FpSize::Single
+                } else {
+                    FpSize::Double
+                };
+                self.push_lir(Aarch64Inst::StrFp {
+                    size: fp_sz,
+                    src: VReg::V16,
+                    addr: MemAddr::BaseOffset {
+                        base: Reg::SP,
+                        offset,
+                    },
+                });
+            } else {
+                self.emit_move(stack_arg.pseudo, Reg::X9, stack_arg.size, frame_size);
                 self.push_lir(Aarch64Inst::Str {
                     size: OperandSize::B64,
                     src: Reg::X9,
-                    addr: MemAddr::PreIndex {
+                    addr: MemAddr::BaseOffset {
                         base: Reg::SP,
-                        offset: -16,
+                        offset,
                     },
                 });
-                stack_args += 1;
             }
         }
 
-        stack_args
+        // Return number of 16-byte units allocated (for cleanup)
+        (aligned_bytes + 15) / 16
     }
 
     /// Set up a complex number argument (real + imaginary in two V registers)