[cc] aarch64 varargs fixes; new CLI arg

  Summary

  Root Cause of CI Failures

  The failing tests (varargs_caller_comprehensive and varargs_float_args)
  were caused by a calling convention mismatch on Apple ARM64
  (Darwin/macOS).

  The Apple ARM64 ABI differs from standard AAPCS64 for variadic functions:
  - AAPCS64 (Linux): Variadic arguments use normal register allocation
  (x0-x7 for integers, d0-d7 for floats)
  - Apple ARM64 (Darwin): ALL variadic arguments must be passed on the
  stack, not in registers

  Our codegen was using the same register-based passing for all platforms,
  which worked on Linux but failed on the macOS CI runners (Apple Silicon).

  Fix Applied

  Modified cc/arch/aarch64/codegen.rs emit_call() function to:
  1. Detect Darwin variadic calls via insn.variadic_arg_start and target.os
  == MacOS
  2. For Darwin variadic calls: Pass fixed args in registers as normal, but
  push all variadic arguments onto the stack
  3. For Linux/FreeBSD: Keep existing behavior (registers for all args)

  Assembly Comparison

  Before (incorrect for Darwin):
  mov w2, #42          ; variadic arg in register - WRONG
  bl _sprintf

  After (correct for Darwin):
  mov w9, #42
  str x9, [sp, #-16]!  ; variadic arg on stack - CORRECT
  bl _sprintf
  add sp, sp, #16

  Additional Feature

  Added --print-targets CLI argument that displays available target
  architectures, matching clang's behavior:
  $ ./target/release/pcc --print-targets
    Registered Targets:
      aarch64    - AArch64 (little endian)
      x86-64     - 64-bit X86: EM64T and AMD64

  Files Modified

  - cc/arch/aarch64/codegen.rs - Fixed variadic argument passing for Darwin
  - cc/main.rs - Added --print-targets argument

  Test Results

  - All 313 tests pass locally on x86-64
  - The varargs tests should now pass on the macOS aarch64 CI runner

  Sources:
  - https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst
  - https://dyncall.org/docs/manual/manualse11.html

Author: jgarzik

cc/arch/aarch64/codegen.rs

@@ -2984,13 +2984,22 @@ impl Aarch64CodeGen {
         // - Floating-point arguments: V0-V7 (8 registers)
         // - Indirect result (large struct return): X8
         // Each class has its own register allocation
+        //
+        // Apple ARM64 (Darwin) divergence for variadic functions:
+        // ALL variadic arguments (after the last named parameter) must be passed
+        // on the stack, not in registers. This differs from standard AAPCS64.
         let int_arg_regs = Reg::arg_regs();
         let fp_arg_regs = VReg::arg_regs();
 
         let mut int_arg_idx = 0;
         let mut fp_arg_idx = 0;
         let mut stack_args = 0;
 
+        // For Darwin variadic calls, determine where variadic args start
+        let variadic_start = insn.variadic_arg_start.unwrap_or(usize::MAX);
+        let is_darwin_variadic =
+            self.target.os == crate::target::Os::MacOS && insn.variadic_arg_start.is_some();
+
         // Check if this call returns a large struct
         // If so, the first argument is the sret pointer and goes in X8 (not X0)
         let returns_large_struct = insn.typ.as_ref().is_some_and(|t| {
@@ -3018,71 +3027,148 @@ impl Aarch64CodeGen {
             0
         };
 
-        // Move arguments to registers
-        for (i, &arg) in insn.src.iter().enumerate().skip(args_start) {
-            // Get argument type if available, otherwise fall back to location-based detection
-            let arg_type = insn.arg_types.get(i);
-            let is_fp = if let Some(typ) = arg_type {
-                typ.is_float()
-            } else {
-                // Fall back to location-based detection for backwards compatibility
-                let arg_loc = self.get_location(arg);
-                matches!(arg_loc, Loc::VReg(_) | Loc::FImm(_))
-            };
-
-            // Get argument size from type, with minimum 32-bit for register ops
-            let arg_size = if let Some(typ) = arg_type {
-                typ.size_bits().max(32)
-            } else {
-                64 // Default for backwards compatibility
-            };
+        // For Darwin variadic calls, we need to:
+        // 1. First pass fixed args in registers as normal
+        // 2. Then push ALL variadic args onto the stack (in reverse order for correct layout)
+        if is_darwin_variadic {
+            // Collect variadic args to push in reverse order
+            let mut variadic_args: Vec<(PseudoId, bool, u32)> = Vec::new();
+
+            // Process all arguments
+            for (i, &arg) in insn.src.iter().enumerate().skip(args_start) {
+                let arg_type = insn.arg_types.get(i);
+                let is_fp = if let Some(typ) = arg_type {
+                    typ.is_float()
+                } else {
+                    let arg_loc = self.get_location(arg);
+                    matches!(arg_loc, Loc::VReg(_) | Loc::FImm(_))
+                };
 
-            if is_fp {
-                // FP size from type (32 for float, 64 for double)
-                let fp_size = if let Some(typ) = arg_type {
-                    typ.size_bits()
+                let arg_size = if let Some(typ) = arg_type {
+                    typ.size_bits().max(32)
                 } else {
                     64
                 };
-                if fp_arg_idx < fp_arg_regs.len() {
-                    self.emit_fp_move(arg, fp_arg_regs[fp_arg_idx], fp_size, frame_size);
-                    fp_arg_idx += 1;
+
+                if i >= variadic_start {
+                    // Variadic arg - collect for stack pushing
+                    variadic_args.push((arg, is_fp, arg_size));
                 } else {
-                    // FP arg on stack
-                    self.emit_fp_move(arg, VReg::V16, fp_size, frame_size);
-                    // LIR: store FP reg to stack with pre-decrement
-                    let fp_sz = if fp_size == 32 {
-                        FpSize::Single
-                    } else {
-                        FpSize::Double
-                    };
+                    // Fixed arg - use registers as normal
+                    if is_fp {
+                        let fp_size = if let Some(typ) = arg_type {
+                            typ.size_bits()
+                        } else {
+                            64
+                        };
+                        if fp_arg_idx < fp_arg_regs.len() {
+                            self.emit_fp_move(arg, fp_arg_regs[fp_arg_idx], fp_size, frame_size);
+                            fp_arg_idx += 1;
+                        }
+                        // Fixed args shouldn't overflow to stack in well-formed calls
+                    } 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;
+                    }
+                }
+            }
+
+            // Push variadic args in reverse order so first variadic arg ends up at [sp]
+            for (arg, is_fp, arg_size) in variadic_args.into_iter().rev() {
+                if is_fp {
+                    // Load FP value to temp register, then store to stack
+                    // For variadic calls on Darwin, floats are passed as 8-byte values on stack
+                    self.emit_fp_move(arg, VReg::V16, arg_size, frame_size);
                     self.push_lir(Aarch64Inst::StrFp {
-                        size: fp_sz,
+                        size: FpSize::Double, // Always 8 bytes on stack for Darwin variadic
                         src: VReg::V16,
                         addr: MemAddr::PreIndex {
                             base: Reg::SP,
                             offset: -16,
                         },
                     });
-                    stack_args += 1;
+                } else {
+                    // Integer/pointer arg
+                    self.emit_move(arg, Reg::X9, arg_size, frame_size);
+                    self.push_lir(Aarch64Inst::Str {
+                        size: OperandSize::B64,
+                        src: Reg::X9,
+                        addr: MemAddr::PreIndex {
+                            base: Reg::SP,
+                            offset: -16,
+                        },
+                    });
                 }
-            } 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 {
-                // Integer arg on stack - always store 8 bytes on aarch64
-                self.emit_move(arg, Reg::X9, arg_size, frame_size);
-                // LIR: store GP reg to stack with pre-decrement
-                self.push_lir(Aarch64Inst::Str {
-                    size: OperandSize::B64,
-                    src: Reg::X9,
-                    addr: MemAddr::PreIndex {
-                        base: Reg::SP,
-                        offset: -16,
-                    },
-                });
                 stack_args += 1;
             }
+        } else {
+            // Standard AAPCS64 (Linux, FreeBSD) or non-variadic calls
+            // Move arguments to registers
+            for (i, &arg) in insn.src.iter().enumerate().skip(args_start) {
+                // Get argument type if available, otherwise fall back to location-based detection
+                let arg_type = insn.arg_types.get(i);
+                let is_fp = if let Some(typ) = arg_type {
+                    typ.is_float()
+                } else {
+                    // Fall back to location-based detection for backwards compatibility
+                    let arg_loc = self.get_location(arg);
+                    matches!(arg_loc, Loc::VReg(_) | Loc::FImm(_))
+                };
+
+                // Get argument size from type, with minimum 32-bit for register ops
+                let arg_size = if let Some(typ) = arg_type {
+                    typ.size_bits().max(32)
+                } else {
+                    64 // Default for backwards compatibility
+                };
+
+                if is_fp {
+                    // FP size from type (32 for float, 64 for double)
+                    let fp_size = if let Some(typ) = arg_type {
+                        typ.size_bits()
+                    } else {
+                        64
+                    };
+                    if fp_arg_idx < fp_arg_regs.len() {
+                        self.emit_fp_move(arg, fp_arg_regs[fp_arg_idx], fp_size, frame_size);
+                        fp_arg_idx += 1;
+                    } else {
+                        // FP arg on stack
+                        self.emit_fp_move(arg, VReg::V16, fp_size, frame_size);
+                        // LIR: store FP reg to stack with pre-decrement
+                        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 += 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 {
+                    // Integer arg on stack - always store 8 bytes on aarch64
+                    self.emit_move(arg, Reg::X9, arg_size, frame_size);
+                    // LIR: store GP reg to stack with pre-decrement
+                    self.push_lir(Aarch64Inst::Str {
+                        size: OperandSize::B64,
+                        src: Reg::X9,
+                        addr: MemAddr::PreIndex {
+                            base: Reg::SP,
+                            offset: -16,
+                        },
+                    });
+                    stack_args += 1;
+                }
+            }
         }
 
         // Call the function

cc/main.rs

@@ -43,9 +43,13 @@ use token::{preprocess, show_token, token_type_name, StreamTable, Tokenizer};
 #[command(version, about = gettext("pcc - compile standard C programs"))]
 struct Args {
     /// Input files
-    #[arg(required = true)]
+    #[arg(required_unless_present = "print_targets")]
     files: Vec<String>,
 
+    /// Print registered targets
+    #[arg(long = "print-targets", help = gettext("Display available target architectures"))]
+    print_targets: bool,
+
     /// Dump tokens (for debugging tokenizer)
     #[arg(
         short = 'T',
@@ -331,6 +335,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let args = Args::parse();
 
+    // Handle --print-targets
+    if args.print_targets {
+        println!("  Registered Targets:");
+        println!("    aarch64    - AArch64 (little endian)");
+        println!("    x86-64     - 64-bit X86: EM64T and AMD64");
+        return Ok(());
+    }
+
     // Detect target (use --target if specified, otherwise detect host)
     let target = if let Some(ref triple) = args.target {
         match Target::from_triple(triple) {