feat: implement export(abi), standalone Windows linking, and ASM stack contracts

[LunaStev]

This PR introduces critical low-level features required for OS development, shared library creation, and bare-metal programming. Key highlights include the export(abi) syntax for exposing Wave functions to external callers, a fully standalone Windows linking pipeline, and a sophisticated "Stack Contract" system for inline assembly to prevent memory corruption in systems-level code.

Key Changes

1. export(abi) Support

Wave can now formally export functions to C or Assembly callers, eliminating the need for hacky internal symbol manipulation.

• Syntax: Supports export(c) fun name(), export(c, "symbol_name") fun, and block-based export(c) { ... }.
• Linkage: Functions marked with export receive External linkage in LLVM and the appropriate calling convention.
• Entry Points: Custom symbol redirection ("symbol_name") allows developers to define exact OS entry points like _start (Linux) or efi_main (UEFI).

2. Standalone Windows GNU Linking

The Windows cross-compilation pipeline is now fully self-contained.

• Direct Linker: The compiler now prefers and invokes the bundled ld.lld instead of relying on a system-installed gcc or mingw.
• Bundled CRT: Automatically links against the bundled MinGW C runtime (crt2.o) and essential Windows libraries (-lkernel32, -luser32, -lmsvcrt) when the standard library is enabled.

3. Inline Assembly Stack Contracts

To prevent subtle and dangerous bugs in kernel-space, Wave now enforces "Stack Contracts" for inline assembly blocks.

• Static Analysis: Implemented architecture-specific scanners (x86_64, AArch64, RISC-V) that inspect ASM instructions for SP mutations (push, pop, sub rsp, etc.) or branching (ret, jmp).
• Pseudo-Clobbers:
  • clobber("stack"): Declares that the ASM block modifies the stack pointer.
  • clobber("noreturn"): Declares a terminal assembly block (e.g., a CPU reset or infinite loop). Generates an LLVM unreachable instruction for optimization.
  • clobber("nostack"): The default contract; asserts the stack pointer remains unchanged.
• Strict Enforcement: The compiler will trigger a compile-time error if an ASM block modifies the stack pointer without an explicit clobber("stack") or clobber("noreturn").

4. Freestanding Backend Attributes

• Kernel Safety: Functions targeted for freestanding (--freestanding) environments now automatically receive the noredzone and nounwind LLVM attributes.
• Rationale: This ensures safe interrupt handling (no Red Zone corruption) and prevents the generation of implicit exception unwinding tables in environments where no unwinder exists.

5. Parser Refinement

• deref Lowering: Fixed an issue where deref ptr = x assignments were handled incorrectly. These are now properly lowered into explicit Expression::Assignment nodes during parsing.
• FFI Consolidation: Refactored parse_extern_header into a generalized parse_ffi_header to share logic between extern and export blocks.

Rationale

These features provide the "final mile" for developers using Wave for systems-level tasks. Explicit exports allow Wave code to be called from C/C++, while stack contracts and freestanding attributes provide the safety guarantees necessary for writing reliable kernels and firmware.

Example Usage

Exporting a function with a custom symbol:

export(c, "wave_add_i32") fun add_i32(a: i32, b: i32) -> i32 {
    return a + b;
}

export(c) {
    fun wave_inc_i32(a: i32) -> i32 {
        return a + 1;
    }

    fun wave_dec_i32(a: i32) -> i32 {
        return a - 1;
    }
}