Merge pull request #499 from rustcoreutils/updates

[cc] Bug fixes, shared lib support

Author: jgarzik

cc/arch/aarch64/codegen.rs

@@ -51,6 +51,8 @@ pub struct Aarch64CodeGen {
     pub(super) num_fixed_gp_params: usize,
     /// External symbols (need GOT access on macOS)
     pub(super) extern_symbols: HashSet<String>,
+    /// Position-independent code mode (for shared libraries)
+    pic_mode: bool,
 }
 
 /// Result of computing a memory address for load/store operations
@@ -75,13 +77,18 @@ impl Aarch64CodeGen {
             reg_save_area_size: 0,
             num_fixed_gp_params: 0,
             extern_symbols: HashSet::new(),
+            pic_mode: false,
         }
     }
 
-    /// Check if a symbol needs GOT access (extern on macOS)
+    /// Check if a symbol needs GOT access
+    /// - In PIC mode: all external symbols need GOT access
+    /// - On macOS: external symbols always need GOT access (even without PIC)
     #[inline]
     pub(super) fn needs_got_access(&self, name: &str) -> bool {
-        self.base.target.os == Os::MacOS && self.extern_symbols.contains(name)
+        let is_extern = self.extern_symbols.contains(name);
+        // PIC mode or macOS: external symbols need GOT
+        (self.pic_mode || self.base.target.os == Os::MacOS) && is_extern
     }
 
     /// Compute the actual FP-relative offset for a stack location.
@@ -2355,4 +2362,8 @@ impl CodeGenerator for Aarch64CodeGen {
     fn set_emit_unwind_tables(&mut self, emit: bool) {
         self.base.emit_unwind_tables = emit;
     }
+
+    fn set_pic_mode(&mut self, pic: bool) {
+        self.pic_mode = pic;
+    }
 }

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;
@@ -602,12 +606,16 @@ pub trait CodeGenerator {
 
     /// Set whether to emit basic unwind tables (cfi_startproc/cfi_endproc)
     fn set_emit_unwind_tables(&mut self, emit: bool);
+
+    /// Set position-independent code mode (for shared libraries)
+    fn set_pic_mode(&mut self, pic: bool);
 }
 
 /// Create a code generator for the given target with options
 pub fn create_codegen_with_options(
     target: Target,
     emit_unwind_tables: bool,
+    pic_mode: bool,
 ) -> Box<dyn CodeGenerator> {
     use crate::target::Arch;
 
@@ -616,5 +624,6 @@ pub fn create_codegen_with_options(
         Arch::Aarch64 => Box::new(super::aarch64::codegen::Aarch64CodeGen::new(target)),
     };
     codegen.set_emit_unwind_tables(emit_unwind_tables);
+    codegen.set_pic_mode(pic_mode);
     codegen
 }

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/codegen.rs

@@ -47,6 +47,8 @@ pub struct X86_64CodeGen {
     pub(super) unique_label_counter: u32,
     /// External symbols (need GOT access on macOS)
     pub(super) extern_symbols: HashSet<String>,
+    /// Position-independent code mode (for shared libraries)
+    pic_mode: bool,
 }
 
 impl X86_64CodeGen {
@@ -62,6 +64,7 @@ impl X86_64CodeGen {
             num_fixed_fp_params: 0,
             unique_label_counter: 0,
             extern_symbols: HashSet::new(),
+            pic_mode: false,
         }
     }
 
@@ -104,10 +107,14 @@ impl X86_64CodeGen {
         }
     }
 
-    /// Check if a symbol needs GOT access (extern on macOS)
+    /// Check if a symbol needs GOT access
+    /// - In PIC mode: all external symbols need GOT access
+    /// - On macOS: external symbols always need GOT access (even without PIC)
     #[inline]
     pub(super) fn needs_got_access(&self, name: &str) -> bool {
-        self.base.target.os == Os::MacOS && self.extern_symbols.contains(name)
+        let is_extern = self.extern_symbols.contains(name);
+        // PIC mode or macOS: external symbols need GOT
+        (self.pic_mode || self.base.target.os == Os::MacOS) && is_extern
     }
 
     /// Emit .loc directive for source line tracking (delegates to base)
@@ -2667,4 +2674,8 @@ impl CodeGenerator for X86_64CodeGen {
     fn set_emit_unwind_tables(&mut self, emit: bool) {
         self.base.emit_unwind_tables = emit;
     }
+
+    fn set_pic_mode(&mut self, pic: bool) {
+        self.pic_mode = pic;
+    }
 }

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