[cc] Fix loop regalloc, macOS .comm alignment, and array alignment

- Loop-carried values now use callee-saved registers to prevent clobber
  across iterations when no function calls force spills. Added `in_loop`
  flag to LiveInterval for intervals spanning loop back edges.

- macOS .comm directive now emits log2(alignment) per Apple assembler
  convention, while Linux/FreeBSD continue using byte alignment.

- Global arrays >= 16 bytes now get 16-byte alignment, matching clang's
  LargeArrayMinWidth optimization for vectorization.

These fixes enable successful compilation of zlib (`make test` passes).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: jgarzik

cc/arch/codegen.rs

@@ -210,7 +210,11 @@ impl<I: LirInst + EmitAsm> CodeGenBase<I> {
         let is_static = types.get(*typ).modifiers.contains(TypeModifiers::STATIC);
 
         // Get alignment from type info - use natural alignment per ABI
-        let align = types.alignment(*typ) as u32;
+        let mut align = types.alignment(*typ) as u32;
+        // Use 16-byte alignment for arrays >= 16 bytes (matches clang behavior for optimization)
+        if matches!(types.get(*typ).kind, crate::types::TypeKind::Array) && size >= 16 {
+            align = align.max(16);
+        }
 
         // Use .comm for uninitialized external (non-static) globals
         let use_bss = matches!(init, Initializer::None) && !is_static;

cc/arch/lir.rs

@@ -617,12 +617,24 @@ impl EmitAsm for Directive {
                 }
             }
             Directive::Comm { sym, size, align } => {
+                // macOS uses log2(alignment) for .comm, Linux uses byte alignment
+                let align_value = match target.os {
+                    Os::MacOS => {
+                        // Convert byte alignment to log2
+                        if *align == 0 {
+                            0
+                        } else {
+                            align.trailing_zeros()
+                        }
+                    }
+                    Os::Linux | Os::FreeBSD => *align,
+                };
                 let _ = writeln!(
                     out,
                     ".comm {},{},{}",
                     sym.format_for_target(target),
                     size,
-                    align
+                    align_value
                 );
             }
 
@@ -890,13 +902,58 @@ mod tests {
     fn test_directive_comm() {
         let linux = Target::new(Arch::X86_64, Os::Linux);
         let macos = Target::new(Arch::X86_64, Os::MacOS);
+        let freebsd = Target::new(Arch::X86_64, Os::FreeBSD);
 
+        // Linux uses byte alignment directly
         let mut out = String::new();
         Directive::comm("my_var", 8, 8).emit(&linux, &mut out);
         assert_eq!(out, ".comm my_var,8,8\n");
 
+        // macOS uses log2(alignment): 8 bytes = 2^3, so log2(8) = 3
         let mut out = String::new();
         Directive::comm("my_var", 8, 8).emit(&macos, &mut out);
-        assert_eq!(out, ".comm _my_var,8,8\n");
+        assert_eq!(out, ".comm _my_var,8,3\n");
+
+        // FreeBSD uses byte alignment like Linux
+        let mut out = String::new();
+        Directive::comm("my_var", 8, 8).emit(&freebsd, &mut out);
+        assert_eq!(out, ".comm my_var,8,8\n");
+
+        // Test alignment=1: macOS log2(1)=0, Linux/FreeBSD=1
+        let mut out = String::new();
+        Directive::comm("byte_var", 1, 1).emit(&linux, &mut out);
+        assert_eq!(out, ".comm byte_var,1,1\n");
+
+        let mut out = String::new();
+        Directive::comm("byte_var", 1, 1).emit(&macos, &mut out);
+        assert_eq!(out, ".comm _byte_var,1,0\n");
+
+        // Test alignment=2: macOS log2(2)=1, Linux=2
+        let mut out = String::new();
+        Directive::comm("short_var", 2, 2).emit(&linux, &mut out);
+        assert_eq!(out, ".comm short_var,2,2\n");
+
+        let mut out = String::new();
+        Directive::comm("short_var", 2, 2).emit(&macos, &mut out);
+        assert_eq!(out, ".comm _short_var,2,1\n");
+
+        // Test alignment=4: macOS log2(4)=2, Linux=4
+        let mut out = String::new();
+        Directive::comm("int_var", 4, 4).emit(&linux, &mut out);
+        assert_eq!(out, ".comm int_var,4,4\n");
+
+        let mut out = String::new();
+        Directive::comm("int_var", 4, 4).emit(&macos, &mut out);
+        assert_eq!(out, ".comm _int_var,4,2\n");
+
+        // Test alignment=16: macOS log2(16)=4, Linux=16
+        // (used for large arrays per clang's LargeArrayMinWidth)
+        let mut out = String::new();
+        Directive::comm("big_array", 64, 16).emit(&linux, &mut out);
+        assert_eq!(out, ".comm big_array,64,16\n");
+
+        let mut out = String::new();
+        Directive::comm("big_array", 64, 16).emit(&macos, &mut out);
+        assert_eq!(out, ".comm _big_array,64,4\n");
     }
 }

cc/arch/regalloc.rs

@@ -23,6 +23,8 @@ pub struct LiveInterval {
     pub pseudo: PseudoId,
     pub start: usize,
     pub end: usize,
+    /// True if this interval spans a loop back edge (used within a loop)
+    pub in_loop: bool,
 }
 
 /// A point in the function where register constraints apply.
@@ -143,6 +145,7 @@ where
         first_def: usize,
         last_def: usize,
         last_use: usize,
+        in_loop: bool,
     }
 
     let mut intervals: HashMap<PseudoId, IntervalInfo> = HashMap::new();
@@ -170,6 +173,7 @@ where
                     first_def: 0,
                     last_def: 0,
                     last_use: 0,
+                    in_loop: false,
                 },
             );
         }
@@ -193,6 +197,7 @@ where
                         first_def: pos,
                         last_def: pos,
                         last_use: pos,
+                        in_loop: false,
                     });
             }
 
@@ -207,6 +212,7 @@ where
                             first_def: pos,
                             last_def: pos,
                             last_use: pos,
+                            in_loop: false,
                         },
                     );
                 }
@@ -224,6 +230,7 @@ where
                             first_def: pos,
                             last_def: pos,
                             last_use: pos,
+                            in_loop: false,
                         },
                     );
                 }
@@ -262,6 +269,7 @@ where
                         first_def: end_pos,
                         last_def: end_pos,
                         last_use: end_pos,
+                        in_loop: false,
                     },
                 );
             }
@@ -281,6 +289,7 @@ where
                         first_def: end_pos,
                         last_def: end_pos,
                         last_use: end_pos,
+                        in_loop: false,
                     },
                 );
             }
@@ -310,16 +319,22 @@ where
         }
     }
 
-    // Extend lifetimes for loop variables
+    // Extend lifetimes for loop variables and mark them as in_loop
+    // Only mark variables that need to persist across loop iterations:
+    // - Defined before the loop but used within the loop
+    // - Used at or after the back edge (survive iteration boundary)
     for (_from_bb, to_bb, back_edge_pos) in &loop_back_edges {
         let loop_start = block_start_pos.get(to_bb).copied().unwrap_or(0);
 
         for info in intervals.values_mut() {
-            if info.first_def < loop_start
+            // This is a loop-carried value that spans iterations
+            let spans_loop_iteration = info.first_def < loop_start
                 && info.last_use >= loop_start
-                && info.last_use <= *back_edge_pos
-            {
+                && info.last_use <= *back_edge_pos;
+
+            if spans_loop_iteration {
                 info.last_use = info.last_use.max(*back_edge_pos);
+                info.in_loop = true;
             }
         }
     }
@@ -338,6 +353,7 @@ where
                 pseudo: info.pseudo,
                 start: info.first_def,
                 end,
+                in_loop: info.in_loop,
             }
         })
         .collect();

cc/arch/x86_64/regalloc.rs

@@ -740,8 +740,9 @@ impl RegAlloc {
                     self.locations
                         .insert(interval.pseudo, Loc::Stack(self.stack_offset));
                 }
-            } else if crosses_call {
-                // Interval crosses a call - must use callee-saved register or spill
+            } else if crosses_call || interval.in_loop {
+                // Interval crosses a call or is inside a loop - must use callee-saved register or spill
+                // For loops without calls, this prevents values from being clobbered by register pressure
                 // Also exclude registers that conflict with constraints
                 if let Some(idx) = self
                     .free_regs