feat: implement System V ABI-compliant C FFI lowering

[LunaStev]

This PR introduces a robust C calling convention (ABI) lowering layer to the Wave compiler's LLVM backend. Until now, calling external C functions was limited to simple types. This update allows Wave to interface with complex C APIs that involve passing or returning structures and arrays by value, strictly adhering to the System V ABI (x86_64) standards.

Key Changes

1. ABI Lowering Logic (abi_c.rs)

Implemented a new lowering engine to classify how Wave types should be translated for the C ABI:

• SRet (Structured Return): Handles large return types by automatically inserting a hidden first parameter that points to a caller-allocated memory block.
• ByVal (By Value): Implements the ByVal attribute for structures, ensuring they are passed on the stack or in registers with correct alignment as expected by C.
• Split & HFA (Homogeneous Floating-point Aggregate): Implements logic to decompose small structs into multiple registers (integer or floating-point/SSE), allowing for efficient "register-splitting" of aggregates.
• Direct & Bit-Packing: Small structures are now "packed" into a single integer register (pack_agg_to_int) when possible, matching the standard optimization behavior of C compilers.

2. Backend Infrastructure & Metadata

• Target-Aware Codegen: The backend now initializes and propagates LLVM TargetData and TargetMachine. This ensures the compiler has precise information about the host's size and alignment requirements.
• ExternCInfo: Introduced a metadata container to track lowered function signatures, ensuring that the calling site (at the LLVM level) matches the ABI transformations applied to the declaration.
• Context Propagation: Propagated TargetData and ABI info through all major generators, including gen_function_call and generate_lvalue_ir.

3. Refactored Function Calls

• Call-site Transformation: The gen_function_call logic has been refactored to check if a target is an extern(c) function. If so, it applies the necessary transformations:
  • Casting arguments to the lowered ABI types.
  • Unpacking split registers back into a single Wave struct.
  • Managing SRet pointers for functions that return large aggregates.

4. Maintenance

• Removed several unused variables and refined internal type inference logic in the parser to accommodate the stricter backend requirements.

Example Impact

Previously, passing a struct like struct Vec2 { x: f32, y: f32 } to a C function might fail if the ABI expected them in a single SSE register. Now, Wave correctly identifies this as an HFA and emits the proper IR to match C's expected register layout.

Benefits

• Full FFI Compatibility: Wave can now reliably invoke any C library function, including those that use complex struct passing (e.g., stat, ioctl, or high-performance math libraries).
• Performance: Register-based aggregate passing is significantly faster than always falling back to stack-based pointers.
• Safety: Stricter alignment and size tracking prevents buffer overflows and memory corruption during FFI boundaries.