[cc] TypeTable-related fixes

Author: jgarzik

cc/README.md

@@ -96,6 +96,7 @@ Supported:
 Not yet implemented:
 - goto, longjmp, setjmp
 - `inline` and inlining support
+- multi-register returns (for structs larger than 8 bytes)
 - -fverbose-asm
 - Complex initializers
 - VLAs (variable-length arrays)

cc/arch/aarch64/codegen.rs

@@ -20,8 +20,8 @@
 use crate::arch::aarch64::lir::{Aarch64Inst, CallTarget, Cond, GpOperand, MemAddr};
 use crate::arch::codegen::CodeGenerator;
 use crate::arch::lir::{Directive, FpSize, Label, OperandSize, Symbol};
+use crate::arch::DEFAULT_LIR_BUFFER_CAPACITY;
 use crate::ir::{Function, Initializer, Instruction, Module, Opcode, Pseudo, PseudoId, PseudoKind};
-use crate::linearize::MAX_REGISTER_AGGREGATE_BITS;
 use crate::target::Target;
 use crate::types::{TypeId, TypeModifiers, TypeTable};
 use std::collections::HashMap;
@@ -1022,7 +1022,7 @@ impl Aarch64CodeGen {
         Self {
             target,
             output: String::new(),
-            lir_buffer: Vec::new(),
+            lir_buffer: Vec::with_capacity(DEFAULT_LIR_BUFFER_CAPACITY),
             locations: HashMap::new(),
             pseudos: Vec::new(),
             current_fn: String::new(),
@@ -3002,28 +3002,9 @@ impl Aarch64CodeGen {
         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.is_some_and(|t| {
-            let kind = types.kind(t);
-            (kind == crate::types::TypeKind::Struct || kind == crate::types::TypeKind::Union)
-                && types.size_bits(t) > MAX_REGISTER_AGGREGATE_BITS
-        });
-
-        // Also check if return type is a pointer to a large struct (linearizer wraps it)
-        let returns_large_struct = returns_large_struct
-            || insn.typ.is_some_and(|t| {
-                if let Some(pointee) = types.base_type(t) {
-                    let kind = types.kind(pointee);
-                    (kind == crate::types::TypeKind::Struct
-                        || kind == crate::types::TypeKind::Union)
-                        && types.size_bits(pointee) > MAX_REGISTER_AGGREGATE_BITS
-                } else {
-                    false
-                }
-            });
-
-        let args_start = if returns_large_struct && !insn.src.is_empty() {
+        // Check if this call returns a large struct via sret (hidden pointer argument).
+        // The linearizer sets is_sret_call=true and puts the sret pointer as the first arg.
+        let args_start = if insn.is_sret_call && !insn.src.is_empty() {
             // First argument is sret pointer - move to X8
             self.emit_move(insn.src[0], Reg::X8, 64, frame_size);
             1 // Skip first arg in main loop

cc/arch/mod.rs

@@ -9,6 +9,9 @@
 // Architecture-specific predefined macros and code generators
 //
 
+/// Default capacity for LIR instruction buffers (reduces reallocation overhead)
+pub const DEFAULT_LIR_BUFFER_CAPACITY: usize = 5000;
+
 pub mod aarch64;
 pub mod codegen;
 pub mod lir;

cc/arch/x86_64/codegen.rs

@@ -19,6 +19,7 @@ use crate::arch::lir::{Directive, FpSize, Label, OperandSize, Symbol};
 use crate::arch::x86_64::lir::{
     CallTarget, GpOperand, IntCC, MemAddr, ShiftCount, X86Inst, XmmOperand,
 };
+use crate::arch::DEFAULT_LIR_BUFFER_CAPACITY;
 use crate::ir::{Function, Initializer, Instruction, Module, Opcode, Pseudo, PseudoId, PseudoKind};
 use crate::target::Target;
 use crate::types::{TypeId, TypeModifiers, TypeTable};
@@ -879,7 +880,7 @@ impl X86_64CodeGen {
         Self {
             target,
             output: String::new(),
-            lir_buffer: Vec::new(),
+            lir_buffer: Vec::with_capacity(DEFAULT_LIR_BUFFER_CAPACITY),
             locations: HashMap::new(),
             pseudos: Vec::new(),
             current_fn: String::new(),

cc/ir.rs

@@ -444,6 +444,9 @@ pub struct Instruction {
     /// For variadic calls: index where variadic arguments start (0-based)
     /// All arguments at this index and beyond are variadic (should be passed on stack)
     pub variadic_arg_start: Option<usize>,
+    /// For calls: true if this call returns a large struct via sret (hidden pointer arg).
+    /// The first element of `src` is the sret pointer when this is true.
+    pub is_sret_call: bool,
     /// Source position for debug info
     pub pos: Option<Position>,
 }
@@ -466,6 +469,7 @@ impl Default for Instruction {
             switch_default: None,
             arg_types: Vec::new(),
             variadic_arg_start: None,
+            is_sret_call: false,
             pos: None,
         }
     }

cc/linearize.rs

@@ -20,14 +20,10 @@ use crate::parse::ast::{
 };
 use crate::ssa::ssa_convert;
 use crate::symbol::SymbolTable;
+use crate::target::Target;
 use crate::types::{MemberInfo, TypeId, TypeKind, TypeModifiers, TypeTable};
 use std::collections::HashMap;
 
-/// Maximum size (in bits) for aggregate types (struct/union) to be passed or
-/// returned by value in registers. Aggregates larger than this require
-/// indirect passing (pointer) or sret (struct return pointer).
-pub const MAX_REGISTER_AGGREGATE_BITS: u32 = 64;
-
 /// Information about a local variable
 #[derive(Clone)]
 struct LocalVarInfo {
@@ -91,11 +87,13 @@ pub struct Linearizer<'a> {
     static_locals: HashMap<String, StaticLocalInfo>,
     /// Current source position for debug info
     current_pos: Option<Position>,
+    /// Target configuration (architecture, ABI details)
+    target: &'a Target,
 }
 
 impl<'a> Linearizer<'a> {
     /// Create a new linearizer
-    pub fn new(symbols: &'a SymbolTable, types: &'a TypeTable) -> Self {
+    pub fn new(symbols: &'a SymbolTable, types: &'a TypeTable, target: &'a Target) -> Self {
         Self {
             module: Module::new(),
             current_func: None,
@@ -116,15 +114,16 @@ impl<'a> Linearizer<'a> {
             static_local_counter: 0,
             static_locals: HashMap::new(),
             current_pos: None,
+            target,
         }
     }
 
     /// Create a linearizer with SSA conversion disabled (for testing)
     #[cfg(test)]
-    pub fn new_no_ssa(symbols: &'a SymbolTable, types: &'a TypeTable) -> Self {
+    pub fn new_no_ssa(symbols: &'a SymbolTable, types: &'a TypeTable, target: &'a Target) -> Self {
         Self {
             run_ssa: false,
-            ..Self::new(symbols, types)
+            ..Self::new(symbols, types, target)
         }
     }
 
@@ -510,7 +509,7 @@ impl<'a> Linearizer<'a> {
         // Large structs are returned via a hidden first parameter (sret)
         // that points to caller-allocated space
         let returns_large_struct = (ret_kind == TypeKind::Struct || ret_kind == TypeKind::Union)
-            && self.types.size_bits(func.return_type) > MAX_REGISTER_AGGREGATE_BITS;
+            && self.types.size_bits(func.return_type) > self.target.max_aggregate_register_bits;
 
         // Argument index offset: if returning large struct, first arg is hidden return pointer
         let arg_offset: u32 = if returns_large_struct { 1 } else { 0 };
@@ -570,7 +569,7 @@ impl<'a> Linearizer<'a> {
             let typ_size = self.types.size_bits(typ);
             // For large structs, arg_pseudo is a pointer to the struct
             // We need to copy the data from that pointer to local storage
-            if typ_size > MAX_REGISTER_AGGREGATE_BITS {
+            if typ_size > self.target.max_aggregate_register_bits {
                 // arg_pseudo is a pointer - copy each 8-byte chunk
                 let struct_size = typ_size / 8;
                 let mut offset = 0i64;
@@ -2239,7 +2238,7 @@ impl<'a> Linearizer<'a> {
                 let typ_kind = self.types.kind(typ);
                 let returns_large_struct = (typ_kind == TypeKind::Struct
                     || typ_kind == TypeKind::Union)
-                    && self.types.size_bits(typ) > MAX_REGISTER_AGGREGATE_BITS;
+                    && self.types.size_bits(typ) > self.target.max_aggregate_register_bits;
 
                 let (result_sym, mut arg_vals, mut arg_types_vec) = if returns_large_struct {
                     // Allocate local storage for the return value
@@ -2282,7 +2281,7 @@ impl<'a> Linearizer<'a> {
                     let arg_type = self.expr_type(a);
                     let arg_kind = self.types.kind(arg_type);
                     let arg_val = if (arg_kind == TypeKind::Struct || arg_kind == TypeKind::Union)
-                        && self.types.size_bits(arg_type) > MAX_REGISTER_AGGREGATE_BITS
+                        && self.types.size_bits(arg_type) > self.target.max_aggregate_register_bits
                     {
                         // Large struct: pass address instead of value
                         // The argument type becomes a pointer
@@ -2313,6 +2312,7 @@ impl<'a> Linearizer<'a> {
                         64, // pointers are 64-bit
                     );
                     call_insn.variadic_arg_start = variadic_arg_start;
+                    call_insn.is_sret_call = true;
                     self.emit(call_insn);
                     // Return the symbol (address) where struct is stored
                     result_sym
@@ -3688,19 +3688,25 @@ impl<'a> Linearizer<'a> {
 
 /// Linearize an AST to IR (convenience wrapper for tests)
 #[cfg(test)]
-pub fn linearize(tu: &TranslationUnit, symbols: &SymbolTable, types: &TypeTable) -> Module {
-    linearize_with_debug(tu, symbols, types, false, None)
+pub fn linearize(
+    tu: &TranslationUnit,
+    symbols: &SymbolTable,
+    types: &TypeTable,
+    target: &Target,
+) -> Module {
+    linearize_with_debug(tu, symbols, types, target, false, None)
 }
 
 /// Linearize an AST to IR with debug info support
 pub fn linearize_with_debug(
     tu: &TranslationUnit,
     symbols: &SymbolTable,
     types: &TypeTable,
+    target: &Target,
     debug: bool,
     source_file: Option<&str>,
 ) -> Module {
-    let mut linearizer = Linearizer::new(symbols, types);
+    let mut linearizer = Linearizer::new(symbols, types, target);
     let mut module = linearizer.linearize(tu);
     module.debug = debug;
     if let Some(path) = source_file {
@@ -3732,7 +3738,8 @@ mod tests {
 
     fn test_linearize(tu: &TranslationUnit, types: &TypeTable) -> Module {
         let symbols = SymbolTable::new();
-        linearize(tu, &symbols, types)
+        let target = Target::host();
+        linearize(tu, &symbols, types, &target)
     }
 
     fn make_simple_func(name: &str, body: Stmt, types: &TypeTable) -> FunctionDef {
@@ -4017,7 +4024,8 @@ mod tests {
 
         // Create linearizer and test that expr_type reads from the expression
         let symbols = SymbolTable::new();
-        let linearizer = Linearizer::new(&symbols, &types);
+        let target = Target::host();
+        let linearizer = Linearizer::new(&symbols, &types, &target);
         let typ = linearizer.expr_type(&expr);
         assert_eq!(types.kind(typ), TypeKind::Int);
 
@@ -4037,7 +4045,8 @@ mod tests {
         expr.typ = Some(types.double_id);
 
         let symbols = SymbolTable::new();
-        let linearizer = Linearizer::new(&symbols, &types);
+        let target = Target::host();
+        let linearizer = Linearizer::new(&symbols, &types, &target);
         let typ = linearizer.expr_type(&expr);
         assert_eq!(types.kind(typ), TypeKind::Double);
     }
@@ -4049,7 +4058,8 @@ mod tests {
     /// Helper to linearize without SSA conversion (for comparing before/after)
     fn linearize_no_ssa(tu: &TranslationUnit, types: &TypeTable) -> Module {
         let symbols = SymbolTable::new();
-        let mut linearizer = Linearizer::new_no_ssa(&symbols, types);
+        let target = Target::host();
+        let mut linearizer = Linearizer::new_no_ssa(&symbols, types, &target);
         linearizer.linearize(tu)
     }
 

cc/main.rs

@@ -218,8 +218,14 @@ fn process_file(
     }
 
     // Linearize to IR
-    let mut module =
-        linearize::linearize_with_debug(&ast, &symbols, &types, args.debug, Some(display_path));
+    let mut module = linearize::linearize_with_debug(
+        &ast,
+        &symbols,
+        &types,
+        target,
+        args.debug,
+        Some(display_path),
+    );
 
     if args.dump_ir {
         print!("{}", module);

cc/parse/parser.rs

@@ -5752,7 +5752,7 @@ mod tests {
     #[test]
     fn test_typedef_local_variable() {
         // Typedef used as local variable type inside function body
-        let (tu, types) =
+        let (tu, _types) =
             parse_tu("typedef int myint; int main(void) { myint x; x = 42; return 0; }").unwrap();
         assert_eq!(tu.items.len(), 2);
 

cc/target.rs

@@ -63,6 +63,10 @@ pub struct Target {
     pub long_width: u32,
     /// char is signed by default
     pub char_signed: bool,
+    /// Maximum size (in bits) for aggregate types (struct/union) that can be
+    /// passed or returned by value in registers. Aggregates larger than this
+    /// require indirect passing (pointer) or sret (struct return pointer).
+    pub max_aggregate_register_bits: u32,
 }
 
 impl Target {
@@ -91,12 +95,20 @@ impl Target {
             (Arch::X86_64, _) => true,
         };
 
+        // Maximum aggregate size that can be returned in registers.
+        // Both x86-64 SysV ABI and AAPCS64 technically support returning
+        // 16-byte structs in registers (rax+rdx or x0+x1), but pcc currently
+        // only supports single-register returns. Use sret for >8 byte structs
+        // until multi-register returns are implemented.
+        let max_aggregate_register_bits = 64;
+
         Self {
             arch,
             os,
             pointer_width,
             long_width,
             char_signed,
+            max_aggregate_register_bits,
         }
     }
 

cc/tests/datatypes/struct_type.rs

@@ -269,3 +269,44 @@ int main(void) {
 "#;
     assert_eq!(compile_and_run("struct_pointer", code), 0);
 }
+
+// ============================================================================
+// Large Struct Return: Return struct >8 bytes requiring sret (hidden pointer)
+// This tests the sret ABI where large structs are returned via a hidden pointer.
+// On ARM64, the sret pointer goes in X8 (not X0 like other args).
+// On x86-64, the sret pointer goes in RDI (first arg register).
+// ============================================================================
+
+#[test]
+fn struct_return_large() {
+    let code = r#"
+struct large {
+    long first;
+    long second;
+};
+
+struct large make_large(long a, long b) {
+    struct large s;
+    s.first = a;
+    s.second = b;
+    return s;
+}
+
+int main(void) {
+    struct large result;
+    result = make_large(300000, 200000);
+
+    // Verify the struct was correctly returned
+    if (result.first != 300000) return 1;
+    if (result.second != 200000) return 2;
+
+    // Test with different values to ensure correct member mapping
+    result = make_large(42, 84);
+    if (result.first != 42) return 3;
+    if (result.second != 84) return 4;
+
+    return 0;
+}
+"#;
+    assert_eq!(compile_and_run("struct_return_large", code), 0);
+}