Persona: Senior Compiler Systems Architect

Abstract: This technical synthesis examines the methodologies for utilizing C as a high-fidelity intermediate representation (IR) for language compilers, as articulated by senior engineer Andy Wingo and peer specialists. The discourse focuses on bypassing the inherent "undefined behavior" pitfalls of hand-written C by leveraging the language as a "portable assembler." Key strategies include the use of static inline functions for zero-cost data abstraction, the implementation of single-member "type forests" to preserve source-language type safety, and manual register allocation techniques to ensure ABI compliance and tail-call reliability. The analysis further addresses the limitations of the C-target approach, specifically regarding stack control, precise garbage collection (GC) via shadow stacks, and the use of #line directives for source-level debugging.

Technical Summary: Strategies for Generating C from Compiler Frontends

• [Static Inline for Zero-Cost Abstraction]: Utilizing static inline __attribute__((always_inline)) allows the generator to define high-level data accessors (e.g., write_ptr) that the C compiler collapses into direct pointer arithmetic. This ensures that abstractions do not incur memory-passing overhead, particularly circumventing the SYS-V x64 ABI limitation where structs exceeding two registers are passed via memory.
• [Integer Conversion Safety]: To avoid C's non-intuitive default promotion rules (e.g., uint8_t to signed int), generators should implement explicit conversion helpers (e.g., u8_to_u32). Enabling -Wconversion ensures the generated code remains strictly typed and free of implicit promotion bugs.
• [Pointer Wrapping and Type Forests]: Raw pointers and uintptr_t values are encapsulated in single-member structs (e.g., struct gc_ref, struct anyref). This "type forest" approach allows the compiler to machine-check subtyping relationships and prevents the application of invalid operations to specific pointer types in the residualized C.
• [Unaligned Memory via memcpy]: For languages like WebAssembly with unaligned linear memory access, generators should use memcpy for loads and stores. Modern C compilers (GCC/Clang) reliably optimize these calls into native unaligned load/store instructions, avoiding the undefined behavior of casting unaligned pointers.
• [Manual Register Allocation & Tail Calls]: To guarantee __attribute__((musttail)) reliability, especially for functions with high argument counts (30+), excess arguments and multiple return values are manually allocated to global variables or thread-local storage. This prevents the C compiler from failing to meet tail-call obligations due to stack-shuffling constraints.
• [The Shadow Stack for Precise GC]: Discussion highlights that because C lacks standard stack-walking primitives, precise or moving garbage collectors must maintain a manual "shadow stack" (a linked list of frame pointers) to track roots. While this enables accurate scanning, it introduces overhead and can obfuscate pointer visibility for debuggers.
• [Debugging via #line Directives]: While embedding DWARF information directly into generated C is complex, the use of #line directives (e.g., #line 12 "source.wasm") effectively maps the generated C back to the original source in GDB/LLDB, facilitating manageable source-level debugging.
• [Aliasing and restrict Constraints]: Implementers note difficulty in convincing C optimizers that heap-allocated helper stacks do not alias other data. The restrict qualifier is often insufficient or "fiddly," leading to missed optimization opportunities in the final binary.
• [Infrastructure Trade-offs]: Targeting C is identified as a "local optimum" that grants access to mature industrial-strength instruction selection and register allocation (via GCC/Clang) but sacrifices precise control over stack slicing and zero-cost exception handling.