The LLVM Backend Implementation

.cargo/config.toml

@@ -0,0 +1,2 @@
+[env]
+LLVM_SYS_181_PREFIX = "/usr/lib/llvm18"

.gitattributes

@@ -0,0 +1,28 @@
+* text=auto
+
+*.rs text eol=lf
+*.toml text eol=lf
+*.md text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+*.json text eol=lf
+*.aelys text eol=lf
+*.aasm text eol=lf
+*.sh text eol=lf
+
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.pdf binary
+*.dll binary
+*.lib binary
+*.a binary
+*.so binary
+*.dylib binary
+*.exe binary
+
+# exclude from github language detection
+*.inc linguist-vendored
+*.cpp linguist-vendored

.gitignore

@@ -4,4 +4,17 @@ Cargo.lock
 /aelys/target/
 \target
 .idea/
-AELYS_TECHNICAL_REFERENCE.md
+architecture.md
+backend_status.md
+aelys/tests/exploration/*
+*.ps1
+**/*.obj
+**/*.exe
+main.aelys
+main.ll
+torture/
+audit/**
+audit_tmp/**
+.vs/**
+.idea/**
+tests_e2e/**

ACKNOWLEDGEMENTS.md

@@ -1,35 +1,17 @@
 # Acknowledgements
 
-## Helps and Contributions
+## Helps and Indirect Contributions
 
-**[Keggek](https://codeberg.org/gek)** - For the discussions about the project and language design <3  
-**[Lekebabiste](https://github.com/Lekebabiste)** - For helping with the UDP implementation <3  
-**[SpaceGame](https://github.com/SpaceGame-wq)** - For making an Aelys syntax highlighting [VSCode extension](https://marketplace.visualstudio.com/items?itemName=SpaceGame.aelys-lang) <3
-
-## Inspirations
-
-**Rust** - The syntax style, `let mut` for mutability, range expressions (`..` and `..=`).  
-Also happens to be what Aelys is written in lol
-
-**Go** - Automatic semicolon insertion, the philosophy of simplicity, fast compilation.
-
-**Lua** - Lightweight VM design, embeddability goals. The original inspiration for trying to build something small and fast.
-
-**Python** - Readability focus. The `and`/`or`/`not` keywords.
-
-Honestly I really want do make a language that feels like a blend of all these things, taking the best ideas from each.  
-Some sort of « python but that treats you as an adult »
+**[Keggek](https://codeberg.org/gek)** - For the discussions about the project and language design. You are more than a mentor, thank you.  
 
 ---
 
-## Usage of AI
-
-Debugging sessions, architectural discussions, and keeping me sane when the VM decides to just.. not work.  
+**[SpaceGame](https://github.com/SpaceGame-wq)** - For making an Aelys syntax highlighting [VSCode extension](https://marketplace.visualstudio.com/items?itemName=SpaceGame.aelys-lang)
 
-AI also wrote most of the tests for Aelys, some stuff in the examples/ folder (notably the benchmarks), and also some parts of the stdlib, which saved a lot of time.  
-I prefer not to focus too much on that and instead work on the VM rather than anything else
+## Inspirations
 
+TODO: 
 
-Without AI assistance this would've taken 10x longer, maybe more.
+## Usage of AI
 
-This whole thing started as a way to actually understand how compilers work beyond just reading about them, and turns out building one is the best way to learn
+TODO: 

CHANGELOG.md

@@ -2,9 +2,43 @@
 
 All notable changes to Aelys, roughly grouped by version. I don't always tag releases perfectly, so this is reconstructed from git history
 
+## 0.21.x - LLVM backend implementation
+
+**0.21.5-a**
+- LLVM codegen: Windows x64 MSVC sret ABI fix for struct returns (fixes bootstrap println segfault)
+- string comparison (==, !=), logical not (!), println` accepts i64/f64/bool (bootstrap to_string)
+- Delete the legacy VM backend
+
+#### Note about that : 
+
+The previous VM served its purpose for prototyping, but Aelys is a systems programming language, not a scripting engine.  
+
+A compact alternative VM will return later once LLVM is mature enough (meta-programming?)
+
+**0.21.4-a**
+- LLVM codegen: SSA-aware local lowering, no more round-tripping with alloca/store/load
+- LLVM backend hardening, no panic/todo path now, unsupported AIR node will give a compile time error
+- Stable native entrypoint for LLVM: `__aelys_user_main` + C runtime main
+
+**0.21.3-a**
+- Hardened Aelys string ABI: `str` is now consistently lowered as `{ ptr, len }`
+- Temporary `print/println` bootstrap, they're reserved during LLVM bootstrap and lowered to `__aelys_write(ptr, len)`; added regression tests for IR ABI and internal `\0` handling.
+- Added `s.len` field access on `Str` (untiil proper bootstrapping)
+
+**0.21.2-a**
+- Added `core/` crate (`aelys-core`) as a C runtime static library built via `cc` (`build.rs` + `src/aelys_core.c`).
+- LLVM native linking now auto-resolves and links `aelys-core` for `--backend llvm` executables.
+
+**0.21.1-a**
+- AIR pass `copy_elim`: élimination des copies paramètre -> local en single-assignment.
+- AIR pass `dead_locals`: suppression des `AirLocal` jamais référencés.
+
+**0.21.0-a**
+- LLVM backend bootstrap: inkwell integration, AIR->LLVM type lowering, function declaration/body codegen, `module.verify()`, and `--backend llvm --emit-llvm-ir`.
+
 ## 0.20.x - Preparing for LLVM
 
-Groundwork for LLVM: sized types, structs, generics, monomorphization, and a new intermediate representation (AIR) with System V AMD64 layout. Nothing implemented in the VM though. I'd rather focus on the new backend than on that. 
+Groundwork for LLVM: sized types, structs, generics, monomorphization, and a new intermediate representation (AIR) with System V AMD64 layout. Nothing implemented in the VM though. I'd rather focus on the new backend than on that.  is mature enough.
 
 **0.20.4-a**
 - AIR pretty-printer, `--emit-air` CLI flag for `compile` command
@@ -60,7 +94,7 @@ Language maturity: arrays, vecs, compound operators, dot-syntax string methods,
 - String indexing with `s[i]` (unicode-aware, returns single-character string)
 - `for c in "hello" { }` iteration syntax
 
-**0.19.10-a** (i'll squash all of these updates)
+**0.19.10-a**
 - fn foo(mut param: type) now working
 
 **0.19.9-a** (not a "real" update again sorry, needed a new tag
@@ -109,7 +143,7 @@ Language maturity: arrays, vecs, compound operators, dot-syntax string methods,
 
 ## 0.18.x - Native Binary Data Manipulation 
 
-This update adds real memory manipulation for @no_gc mode
+This update adds real memory manipulation for @no_gc mode & some bug fixes
 
 **0.18.6-a**
 - Fixed call site cache using stale entries after global mutation

Cargo.toml

@@ -2,24 +2,20 @@
 resolver = "3"
 members = [
     "aelys",
+    "core",
     "common",
     "syntax",
     "frontend",
     "sema",
     "opt",
     "air",
-    "bytecode",
-    "backend",
-    "runtime",
-    "modules",
+    "codegen",
     "driver",
     "cli",
-    "native",
-    "native-macros",
 ]
 
 [workspace.package]
-version = "0.20.3-a"
+version = "0.21.8-a"
 
 [profile.release]
 lto = "fat"
@@ -30,4 +26,4 @@ strip = true
 debug = false
 overflow-checks = false
 debug-assertions = false
-rpath = false
+rpath = false

NOTICE

@@ -0,0 +1,4 @@
+This project uses LLVM (https://llvm.org/).
+Copyright (c) 2003-present, LLVM Contributors.
+Licensed under the Apache License 2.0 with LLVM Exceptions.
+See https://llvm.org/LICENSE.txt for license information.

README.md

@@ -1,29 +1,119 @@
 <p align="center">
-  <img src="docs/aelys_banner.png?v=2" alt="aelys virtual machine" width="1000">
+  <img src="docs/aelys_banner.png?v=3" alt="aelys" width="1000">
 </p>
 
-<a href="https://github.com/vbxq/aelys_lang/actions/workflows/ci.yml"><img src="https://github.com/vbxq/aelys_lang/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
-<a href="LICENSE"><img src="https://img.shields.io/github/license/vbxq/aelys_lang?color=8A2BE2" alt="License"></a>
-<a href="https://github.com/vbxq/aelys_lang/releases/latest"><img src="https://img.shields.io/github/v/release/vbxq/aelys_lang?color=8A2BE2" alt="Release"></a>
+# Aelys
 
-# aelys 0.20.3-a
+A programming language with garbage collection by default and explicit opt-out for performance-critical code.
 
-Register-based VM with dual memory management: GC by default, `@no_gc` for performance-critical code.
+Most languages force a single memory model on the entire program. GC'd languages pay for a runtime on every path; systems languages demand manual control everywhere.
 
-You choose between comfort and performance on a per-function basis.
+Aelys starts from a tracing GC and lets you leave it behind one function at a time. Default mode gives you heap allocation, type inference, and minimal annotation. `nogc` gives you compiler-enforced zero-allocation with statically checked references, no user-written lifetime annotations.
 
-## Documentation
+<!-- ```rust is used for syntax highlighting only — this is Aelys -->
+```rust
+fn load_mesh(path: str) -> Result<Mesh, IoError> {
+    let data = read_file(path) fail |e| IoError::from(e)
+    let points = parse_vertices(data) fail IoError::ParseFailed
+    Ok(Mesh { vertices: points })
+}
 
-- [Build Instructions](docs/installation.md)
-- [Getting Started Guide](docs/getting-started.md)
-- [Language Specification](docs/language-spec.md)
-- [Standard Library Documentation](docs/standard-library.md)
+nogc fn compute_normals(vertices: &[Vec3], normals: &mut [Vec3]) {
+    for i in range(0, vertices.len() - 2, step: 3) {
+        let e1 = vertices[i + 1] - vertices[i]
+        let e2 = vertices[i + 2] - vertices[i]
+        normals[i / 3] = cross(e1, e2).normalize()
+    }
+}
 
-## Additional Information
+fn main() {
+    let mesh = match load_mesh("model.obj") or load_mesh("default.obj") {
+        Ok(m)                     => m,
+        Err(IoError::NotFound)    => { println("no mesh found");     return },
+        Err(IoError::ParseFailed) => { println("mesh is corrupted"); return }
+    }
 
-- [Performance Benchmarks](docs/performance-benchmarks.md)
-- [Acknowledgements](ACKNOWLEDGEMENTS.md)
-- [Changelog](CHANGELOG.md)
-- [Examples](examples/README.md)
-- [License](LICENSE)
-- [FAQ](docs/faq.md)
+    let mut normals = Vec<Vec3>::new(mesh.vertices.len() / 3)
+    compute_normals(&mesh.vertices, &mut normals)
+}
+```
+
+`load_mesh` is default mode: GC-backed allocation, `Result` for errors, `fail` for propagation, `or` for fallback. `compute_normals` is `nogc`, meaning no heap allocation, no GC containers, and references checked at compile time. In `main`, `&` at the call site marks the boundary where data is borrowed into `nogc` territory.
+
+GC code calls `nogc` freely; the reverse is a compile error.
+
+Beyond the memory model: inferred types, pattern matching, Result-based error handling with `fail` for propagation and `or` for fallback composition, direct C header imports through `needs`, and compilation to native code via LLVM.
+
+## Memory model
+
+The language provides three levels of control, each narrowing what the runtime provides.
+
+**Default mode.** A tracing garbage collector manages the heap, types are inferred, and standard collections are GC-backed. Type annotations are optional. `fail` propagates errors, either through a closure for remapping or directly for a fixed error, and `or` provides fallback between results. This is the intended level for most code.
+
+<br>
+
+**`nogc` functions.** A function-level opt-out from GC allocation. Inside a `nogc` function, GC-backed allocation is rejected at compile time, GC-managed containers cannot be created, references are checked for escape and aliasing violations, and calls into GC code are rejected.
+
+The compiler proves that the function satisfies these constraints or rejects it. No warnings, no user-written lifetime annotations. `unsafe {}` permits operations the checker cannot validate statically but does not re-enable GC allocation. FFI is handled through `needs`, which imports C headers directly.
+
+```rust
+needs "GL/glext.h"
+
+nogc fn upload_normals(buffer_id: u32, normals: &[Vec3]) {
+    let byte_size = (normals.len() * size_of(Vec3)) as isize
+    unsafe {
+        glNamedBufferData(
+            buffer_id,
+            byte_size,
+            normals.as_ptr() as *const void,
+            GL_STATIC_DRAW
+        )
+    }
+}
+```
+
+<br>
+
+**`#![no_gc]` `#![no_std]` modules.** At the module level, these attributes remove the garbage collector, runtime, and standard library entirely. The language exposes raw pointers, `extern fn`, and inline assembly, while parsing, typing, and semantic analysis still apply. This mode is intended for kernels, boot code, and freestanding targets.
+
+```rust
+#![no_gc]
+#![no_std]
+
+extern {
+    static __bss_start: u8
+    static __bss_end:   u8
+}
+
+fn zero_bss() {
+    let mut ptr = &__bss_start as *const u8 as *mut u8
+    let end     = &__bss_end   as *const u8
+    while ptr < end {
+        *ptr = 0u8
+        ptr  = ptr + 1
+    }
+}
+
+#[no_mangle]
+fn kernel_entry() -> ! {
+    zero_bss()
+    uart::write("boot ok\n")
+    loop { asm("wfi") }
+}
+```
+
+## Status
+
+Aelys is an experimental language and compiler project under active rewrite. It is not ready for use.
+
+```
+source → parser → semantic analysis → AIR (Aelys IR) → LLVM IR → native code
+```
+
+Parser and semantic analysis are partially implemented. The `nogc` checker rules are under active design. Codegen targets LLVM.
+
+Language semantics, the IR, and parts of the standard library are not stable. Open design questions include the GC strategy, panic behavior in `#![no_std]`, iterator design, the GC / `nogc` boundary rules, and static guarantees in freestanding mode.
+
+## Contributing
+
+Bug reports, design feedback, and discussion around language semantics and compiler behavior are the most useful contributions right now. The codebase changes quickly, so if you want to contribute code, open an issue first so the work can be aligned with the current direction.

_build.ps1

@@ -0,0 +1,11 @@
+$vs = & "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath
+$vc = "$vs\VC\Auxiliary\Build\vcvars64.bat"
+cmd /c ('"' + $vc + '" >nul 2>&1 && set') | ForEach-Object {
+    if ($_ -match '^(.*?)=(.*)$') {
+        Set-Item -Path "Env:$($matches[1])" -Value $matches[2]
+    }
+}
+$env:LLVM_SYS_181_PREFIX = 'C:\llvm'
+$env:PATH = "C:\llvm\bin;$env:PATH"
+Set-Location 'C:\Users\admin\RustroverProjects\aelys_lang'
+.\target\debug\aelys-cli.exe compile test.aelys

aelys/Cargo.toml

@@ -5,24 +5,21 @@ edition = "2024"
 
 [dependencies]
 aelys-common = { path = "../common" }
-aelys-syntax = { path = "../syntax" }
-aelys-frontend = { path = "../frontend" }
-aelys-sema = { path = "../sema" }
-aelys-opt = { path = "../opt" }
-aelys-bytecode = { path = "../bytecode" }
-aelys-backend = { path = "../backend" }
-aelys-runtime = { path = "../runtime" }
-aelys-modules = { path = "../modules" }
 aelys-driver = { path = "../driver" }
 
 [dev-dependencies]
 tempfile = "3"
 aelys-opt = { path = "../opt" }
 aelys-air = { path = "../air" }
-aelys-bytecode = { path = "../bytecode" }
+aelys-codegen = { path = "../codegen" }
+aelys-driver = { path = "../driver" }
+aelys-frontend = { path = "../frontend" }
+aelys-sema = { path = "../sema" }
+aelys-syntax = { path = "../syntax" }
+inkwell = { git = "https://github.com/TheDan64/inkwell", branch = "master", default-features = false, features = ["llvm18-1", "target-x86"] }
 
 [build-dependencies]
 regex = "1"
 
 [lib]
-doctest = false
+doctest = false