[cc] aarch64 regalloc fix

Fixed bug in cc/arch/aarch64/regalloc.rs:

  The aarch64 register allocator was calculating stack offsets independently for int and FP overflow arguments:
  // Before (wrong):
  // FP overflow: offset = 16 + (fp_arg_idx - 8) * 8
  // Int overflow: offset = 16 + (int_arg_idx - 8) * 8
  // Both start at 16 → collision when both overflow!

  Per AAPCS64, stack arguments must be placed in parameter order (not separated by type). Fixed by using a single shared stack_arg_offset counter.

  Verified with clang cross-compilation:
  - q (int #9) should be at stack offset 0
  - r (double #9) should be at stack offset 8

Author: jgarzik

cc/arch/aarch64/regalloc.rs

@@ -653,11 +653,19 @@ impl RegAlloc {
     }
 
     /// Pre-allocate argument registers per AAPCS64
+    ///
+    /// AAPCS64 passes arguments as follows:
+    /// - First 8 integer/pointer args in X0-X7
+    /// - First 8 FP args in V0-V7 (D0-D7 for doubles, S0-S7 for floats)
+    /// - Remaining args go on the stack in parameter order (not separated by type)
     fn allocate_arguments(&mut self, func: &Function, types: &TypeTable) {
         let int_arg_regs = Reg::arg_regs();
         let fp_arg_regs = VReg::arg_regs();
         let mut int_arg_idx = 0usize;
         let mut fp_arg_idx = 0usize;
+        // Stack offset for overflow args - must be shared across all types
+        // because AAPCS64 places stack args in parameter order
+        let mut stack_arg_offset = 16i32;
 
         // Detect hidden return pointer for large struct returns
         let sret_pseudo = func
@@ -684,9 +692,11 @@ impl RegAlloc {
                                 self.free_fp_regs.retain(|&r| r != fp_arg_regs[fp_arg_idx]);
                                 self.fp_pseudos.insert(pseudo.id);
                             } else {
-                                let offset = 16 + (fp_arg_idx - fp_arg_regs.len()) as i32 * 8;
-                                self.locations.insert(pseudo.id, Loc::Stack(offset));
+                                // Stack args are placed in parameter order per AAPCS64
+                                self.locations
+                                    .insert(pseudo.id, Loc::Stack(stack_arg_offset));
                                 self.fp_pseudos.insert(pseudo.id);
+                                stack_arg_offset += 8;
                             }
                             fp_arg_idx += 1;
                         } else {
@@ -695,8 +705,10 @@ impl RegAlloc {
                                     .insert(pseudo.id, Loc::Reg(int_arg_regs[int_arg_idx]));
                                 self.free_regs.retain(|&r| r != int_arg_regs[int_arg_idx]);
                             } else {
-                                let offset = 16 + (int_arg_idx - int_arg_regs.len()) as i32 * 8;
-                                self.locations.insert(pseudo.id, Loc::Stack(offset));
+                                // Stack args are placed in parameter order per AAPCS64
+                                self.locations
+                                    .insert(pseudo.id, Loc::Stack(stack_arg_offset));
+                                stack_arg_offset += 8;
                             }
                             int_arg_idx += 1;
                         }