[cc] Refactor static local store logic and fix CI test portability

- Extract emit_static_local_store() helper to deduplicate 3 code blocks
- Add unreachable!() guards for static local sentinel lookup failures
- Replace #include <stdint.h> with manual typedef in alignment tests
  to fix Linux CI where system headers aren't available

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

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

Author: jgarzik

cc/ir/linearize.rs

@@ -2704,6 +2704,8 @@ impl<'a> Linearizer<'a> {
                                 self.types.pointer_to(static_info.typ),
                             ));
                             return result;
+                        } else {
+                            unreachable!("static local sentinel without static_locals entry");
                         }
                     }
                     let result = self.alloc_pseudo();
@@ -3629,16 +3631,7 @@ impl<'a> Linearizer<'a> {
                 if let Some(local) = self.locals.get(&name_str).cloned() {
                     // Check if this is a static local (sentinel value)
                     if local.sym.0 == u32::MAX {
-                        // Static local - look up the global name and emit store to global
-                        let key = format!("{}.{}", self.current_func_name, &name_str);
-                        if let Some(static_info) = self.static_locals.get(&key).cloned() {
-                            let sym_id = self.alloc_pseudo();
-                            let pseudo = Pseudo::sym(sym_id, static_info.global_name);
-                            if let Some(func) = &mut self.current_func {
-                                func.add_pseudo(pseudo);
-                            }
-                            self.emit(Instruction::store(final_result, sym_id, 0, typ, store_size));
-                        }
+                        self.emit_static_local_store(&name_str, final_result, typ, store_size);
                     } else {
                         // Regular local variable
                         self.emit(Instruction::store(
@@ -3947,22 +3940,7 @@ impl<'a> Linearizer<'a> {
                     if let Some(local) = self.locals.get(&name_str).cloned() {
                         // Check if this is a static local (sentinel value)
                         if local.sym.0 == u32::MAX {
-                            // Static local - look up the global name and emit store to global
-                            let key = format!("{}.{}", self.current_func_name, &name_str);
-                            if let Some(static_info) = self.static_locals.get(&key).cloned() {
-                                let sym_id = self.alloc_pseudo();
-                                let pseudo = Pseudo::sym(sym_id, static_info.global_name);
-                                if let Some(func) = &mut self.current_func {
-                                    func.add_pseudo(pseudo);
-                                }
-                                self.emit(Instruction::store(
-                                    final_result,
-                                    sym_id,
-                                    0,
-                                    typ,
-                                    store_size,
-                                ));
-                            }
+                            self.emit_static_local_store(&name_str, final_result, typ, store_size);
                         } else {
                             // Regular local variable
                             self.emit(Instruction::store(
@@ -4146,6 +4124,8 @@ impl<'a> Linearizer<'a> {
                         self.emit(Instruction::load(result, sym_id, 0, typ, size));
                         return result;
                     }
+                } else {
+                    unreachable!("static local sentinel without static_locals entry");
                 }
             }
             let result = self.alloc_pseudo();
@@ -4798,6 +4778,23 @@ impl<'a> Linearizer<'a> {
         id
     }
 
+    /// Emit a store to a static local variable.
+    /// The caller must have already verified that `name_str` refers to a static local
+    /// (i.e., the local's sym is the sentinel value u32::MAX).
+    fn emit_static_local_store(&mut self, name_str: &str, value: PseudoId, typ: TypeId, size: u32) {
+        let key = format!("{}.{}", self.current_func_name, name_str);
+        if let Some(static_info) = self.static_locals.get(&key).cloned() {
+            let sym_id = self.alloc_pseudo();
+            let pseudo = Pseudo::sym(sym_id, static_info.global_name);
+            if let Some(func) = &mut self.current_func {
+                func.add_pseudo(pseudo);
+            }
+            self.emit(Instruction::store(value, sym_id, 0, typ, size));
+        } else {
+            unreachable!("static local sentinel without static_locals entry");
+        }
+    }
+
     /// Emit stores to zero-initialize an aggregate (struct, union, or array)
     /// This handles C99 6.7.8p19: uninitialized members must be zero-initialized
     fn emit_aggregate_zero(&mut self, base_sym: PseudoId, typ: TypeId) {
@@ -5895,22 +5892,7 @@ impl<'a> Linearizer<'a> {
                 if let Some(local) = self.locals.get(&name_str).cloned() {
                     // Check if this is a static local (sentinel value)
                     if local.sym.0 == u32::MAX {
-                        // Static local - look up the global name and emit store to global
-                        let key = format!("{}.{}", self.current_func_name, &name_str);
-                        if let Some(static_info) = self.static_locals.get(&key).cloned() {
-                            let sym_id = self.alloc_pseudo();
-                            let pseudo = Pseudo::sym(sym_id, static_info.global_name);
-                            if let Some(func) = &mut self.current_func {
-                                func.add_pseudo(pseudo);
-                            }
-                            self.emit(Instruction::store(
-                                final_val,
-                                sym_id,
-                                0,
-                                target_typ,
-                                target_size,
-                            ));
-                        }
+                        self.emit_static_local_store(&name_str, final_val, target_typ, target_size);
                     } else {
                         // Regular local variable: emit Store
                         self.emit(Instruction::store(

cc/tests/globals/mod.rs

@@ -628,7 +628,8 @@ fn test_global_array_alignment_large() {
     let c_file = create_c_file(
         "array_align_large",
         r#"
-#include <stdint.h>
+// Define uintptr_t manually to avoid system header dependency
+typedef unsigned long uintptr_t;
 // 16-byte array - should be 16-byte aligned
 char big_array[16];
 // 32-byte array - should also be 16-byte aligned
@@ -662,7 +663,8 @@ fn test_global_array_alignment_small() {
     let c_file = create_c_file(
         "array_align_small",
         r#"
-#include <stdint.h>
+// Define uintptr_t manually to avoid system header dependency
+typedef unsigned long uintptr_t;
 // 8-byte array - smaller than threshold, natural alignment
 char small_array[8];
 // 15-byte array - smaller than threshold