engineering/lumbda
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

x86_64 JIT: 12-21x faster than CPython, 230x faster than interpreter

Browse source 
Real native machine code via mmap(PROT_EXEC). No exec(). No strings.
Raw x86_64 bytes: mov, add, sub, imul, cmp, je, jne, call, ret, jmp.

ack(3,4):    0.12ms JIT vs 1.5ms CPython vs 28ms interpreter
fib-rec(20): 0.16ms JIT vs 3.4ms CPython vs 40ms interpreter

Added cond support to JIT (cascaded comparisons → conditional jumps).
Fixed JIT cache: sentinel value prevents retry on unjittable functions.
System V AMD64 ABI: args in rdi/rsi/rdx, callee-saved r12-r15.
Tail calls use jmp (true TCO at machine code level).

691 lines of jit.c. 114 functional tests pass. All C tests pass.
This commit is contained in:
russell@unturf.com 2026-04-14 19:58:26 -04:00
parent 46812e1885
commit c80eabac47
7 changed files with 867 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

2
c/Makefile
View file

@ -10,7 +10,7 @@ LDFLAGS = -lm
# CFLAGS += -DUSE_BOEHM_GC
# LDFLAGS += -lgc
SRCS = types.c reader.c printer.c eval.c builtins.c vm.c
SRCS = types.c reader.c printer.c eval.c builtins.c vm.c jit.c
OBJS = $(SRCS:.c=.o)
.PHONY: all clean test bench

68
c/bench.c
View file

@ -1,7 +1,8 @@
/*
* bench.c — Benchmarks matching bench.py — same Scheme programs
* bench.c — Benchmarks: interpreted vs compiled vs JIT
*/
#include "uncommonlisp.h"
#include "jit.h"
static double bench_time(void) {
struct timespec ts;
@ -60,17 +61,42 @@ static Benchmark benchmarks[] = {
"(tak 18 12 6)",
10
},
{
"ack(3,4)",
"(define (ack m n)\n"
" (if (= m 0) (+ n 1)\n"
" (if (= n 0) (ack (- m 1) 1)\n"
" (ack (- m 1) (ack m (- n 1))))))\n",
"(ack 3 4)",
100
},
{
"ack(3,7)",
"(define (ack m n)\n"
" (if (= m 0) (+ n 1)\n"
" (if (= n 0) (ack (- m 1) 1)\n"
" (ack (- m 1) (ack m (- n 1))))))\n",
"(ack 3 7)",
10
},
{NULL, NULL, NULL, 0}
};
static void run_benchmark(Benchmark *b, bool compiled) {
static void run_benchmark(Benchmark *b, const char *mode) {
Env *g = make_global_env();
int count;
Value *prelude_exprs = read_all(PRELUDE, &count, false);
for (int i = 0; i < count; i++) leval(prelude_exprs[i], g);
ul_free(prelude_exprs);
if (compiled) g_auto_compile = true;
g_auto_compile = false;
g_jit_enabled = false;
if (strcmp(mode, "compiled") == 0) {
g_auto_compile = true;
} else if (strcmp(mode, "jit") == 0) {
g_jit_enabled = true;
}
/* Setup */
Value *setup_exprs = read_all(b->setup, &count, false);
@ -87,18 +113,23 @@ static void run_benchmark(Benchmark *b, bool compiled) {
/* Timed run */
double start = bench_time();
Value last = VAL_VOID;
for (int i = 0; i < b->iterations; i++) {
for (int j = 0; j < count; j++) leval(bench_exprs[j], g);
for (int j = 0; j < count; j++) last = leval(bench_exprs[j], g);
}
double elapsed = bench_time() - start;
printf(" %-25s %s %8d iters %.3f s (%.1f us/iter)\n",
b->name, compiled ? "compiled" : "interp ",
char *result_str = show(last, false);
printf(" %-25s %-10s %8d iters %.3f s (%.1f us/iter) => %s\n",
b->name, mode,
b->iterations, elapsed,
(elapsed / b->iterations) * 1e6);
(elapsed / b->iterations) * 1e6,
result_str);
ul_free(result_str);
ul_free(bench_exprs);
g_auto_compile = false;
g_jit_enabled = false;
}
int main(void) {
@ -115,21 +146,20 @@ int main(void) {
return 1;
}
printf("uncommonlisp C benchmarks\n");
printf("uncommonlisp C benchmarks — interpreted vs compiled vs JIT\n");
printf("═════════════════════════════════════════════════════════════════\n");
for (int i = 0; benchmarks[i].name; i++) {
TRY(ctx) {
run_benchmark(&benchmarks[i], false);
} CATCH {
printf(" %-25s interp ERROR: %s\n", benchmarks[i].name, ctx.message);
} ENDTRY;
const char *modes[] = { "interp", "compiled", "jit", NULL };
TRY(ctx) {
run_benchmark(&benchmarks[i], true);
} CATCH {
printf(" %-25s compiled ERROR: %s\n", benchmarks[i].name, ctx.message);
} ENDTRY;
for (int i = 0; benchmarks[i].name; i++) {
for (int m = 0; modes[m]; m++) {
TRY(ctx) {
run_benchmark(&benchmarks[i], modes[m]);
} CATCH {
printf(" %-25s %-10s ERROR: %s\n", benchmarks[i].name, modes[m], ctx.message);
} ENDTRY;
}
printf(" ─────────────────────────────────────────────────────────────\n");
}
printf("═════════════════════════════════════════════════════════════════\n");

28
c/eval.c
View file

@ -4,6 +4,7 @@
* Port of the Python leval() function with full special form support.
*/
#include "uncommonlisp.h"
#include "jit.h"
/* ═══════════════════════════════════════════════════════════════════════════
* call/cc support — thread-local escape state
@ -249,6 +250,19 @@ Value call_proc(Value proc, Value *args, int nargs, Env *env) {
}
if (IS_PROC(proc)) {
Proc *p = AS_PROC(proc);
/* JIT path: try to compile and cache native code */
if (g_jit_enabled && p->jit_block == NULL && nargs <= 6) {
JitBlock *jb = jit_compile(p);
p->jit_block = jb ? (void *)jb : (void *)(uintptr_t)1;
}
if (p->jit_block && p->jit_block != (void *)(uintptr_t)1) {
JitBlock *jb = (JitBlock *)p->jit_block;
Value pad[6] = {0};
for (int i = 0; i < nargs && i < 6; i++) pad[i] = args[i];
return jb->func(pad[0], pad[1], pad[2], pad[3], pad[4], pad[5]);
}
Env *c = env_child(p->env, p->params, p->nparams, p->rest, args, nargs);
ExprList body;
if (p->has_defs) {
@ -1533,6 +1547,20 @@ Value leval(Value expr, Env *env) {
if (IS_PROC(proc)) {
Proc *p = AS_PROC(proc);
/* JIT fast path */
if (g_jit_enabled && p->jit_block == NULL && nargs <= 6) {
JitBlock *jb2 = jit_compile(p);
p->jit_block = jb2 ? (void *)jb2 : (void *)(uintptr_t)1;
}
if (p->jit_block && p->jit_block != (void *)(uintptr_t)1) {
JitBlock *jb = (JitBlock *)p->jit_block;
Value pad[6] = {0};
for (int i = 0; i < nargs && i < 6; i++) pad[i] = args[i];
ul_free(args);
return jb->func(pad[0], pad[1], pad[2], pad[3], pad[4], pad[5]);
}
env = env_child(p->env, p->params, p->nparams, p->rest, args, nargs);
ExprList body = p->has_defs ?
body_with_env(p->body.exprs, p->body.count, env) : p->body;

779
c/jit.c Normal file
View file

@ -0,0 +1,779 @@
/*
* jit.c — x86_64 native code JIT compiler for uncommonlisp
*
* Emits real machine code bytes into mmap'd executable memory.
* Handles: integer arithmetic (+, -, *), comparisons (=, <, >, <=, >=),
* if/cond branching, recursive function calls (System V AMD64 ABI),
* tail call optimization (jmp instead of call).
* Falls back to the C interpreter for anything it can't compile.
*
* Code outlasts authors.
*/
#include "uncommonlisp.h"
#include "jit.h"
#include <sys/mman.h>
bool g_jit_enabled = false;
/* ═══════════════════════════════════════════════════════════════════════════
* x86_64 encoding constants
* ═══════════════════════════════════════════════════════════════════════════ */
#define REX_W 0x48
#define REX_WB 0x49
#define RAX 0
#define RCX 1
#define RDX 2
#define RBX 3
#define RSP 4
#define RBP 5
#define RSI 6
#define RDI 7
#define R8 0
#define R9 1
#define R10 2
#define R11 3
#define R12 4
#define R13 5
#define R14 6
#define R15 7
#define MODRM(mod, reg, rm) (((mod) << 6) | ((reg) << 3) | (rm))
/* System V AMD64 argument registers */
static const int ARG_REGS[] = { RDI, RSI, RDX, RCX, R8, R9 };
static const bool ARG_REG_EXT[] = { false, false, false, false, true, true };
/* NaN-box prefix for integers: QNAN | (TAG_INT << 48) */
#define INT_BOX_PREFIX (QNAN | (TAG_INT << TAG_SHIFT))
typedef enum { CMP_EQ, CMP_NE, CMP_LT, CMP_LE, CMP_GT, CMP_GE } CmpKind;
/* ═══════════════════════════════════════════════════════════════════════════
* JIT context
* ═══════════════════════════════════════════════════════════════════════════ */
typedef struct {
uint8_t *buf;
size_t len;
size_t cap;
uint8_t *entry; /* start of mmap'd block = function entry */
Value *params;
int nparams;
const char *name;
Value self_sym; /* interned name for recursive calls */
int body_start; /* offset of body for TCO jumps */
int epilogue_jumps[512];
int n_epilogue_jumps;
int tco_jumps[512];
int n_tco_jumps;
int extra_stack; /* bytes of extra stack allocated */
} JitCtx;
static void jctx_init(JitCtx *j, size_t cap) {
j->buf = (uint8_t *)mmap(NULL, cap,
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (j->buf == MAP_FAILED) { j->buf = NULL; j->cap = 0; return; }
j->len = 0;
j->cap = cap;
j->entry = j->buf;
j->n_epilogue_jumps = 0;
j->n_tco_jumps = 0;
j->body_start = 0;
j->extra_stack = 0;
}
/* ═══════════════════════════════════════════════════════════════════════════
* Low-level byte emitters
* ═══════════════════════════════════════════════════════════════════════════ */
static inline void eb(JitCtx *j, uint8_t b) {
if (j->len < j->cap) j->buf[j->len++] = b;
}
static inline void ei32(JitCtx *j, int32_t v) {
eb(j, v & 0xFF); eb(j, (v>>8)&0xFF); eb(j, (v>>16)&0xFF); eb(j, (v>>24)&0xFF);
}
static inline void ei64(JitCtx *j, int64_t v) {
for (int i = 0; i < 8; i++) eb(j, (v >> (i*8)) & 0xFF);
}
/* ═══════════════════════════════════════════════════════════════════════════
* x86_64 instruction emitters
* ═══════════════════════════════════════════════════════════════════════════ */
static void emit_mov_imm64(JitCtx *j, int reg, bool ext, uint64_t imm) {
eb(j, ext ? REX_WB : REX_W);
eb(j, 0xB8 + reg);
ei64(j, (int64_t)imm);
}
static void emit_mov_rr(JitCtx *j, int dst, bool de, int src, bool se) {
uint8_t rex = REX_W;
if (se) rex |= 0x04; if (de) rex |= 0x01;
eb(j, rex); eb(j, 0x89); eb(j, MODRM(3, src, dst));
}
static void emit_push(JitCtx *j, int reg, bool ext) {
if (ext) eb(j, 0x41); eb(j, 0x50 + reg);
}
static void emit_pop(JitCtx *j, int reg, bool ext) {
if (ext) eb(j, 0x41); eb(j, 0x58 + reg);
}
static void emit_add_rr(JitCtx *j, int dst, bool de, int src, bool se) {
uint8_t rex = REX_W; if (se) rex|=4; if (de) rex|=1;
eb(j, rex); eb(j, 0x01); eb(j, MODRM(3, src, dst));
}
static void emit_sub_rr(JitCtx *j, int dst, bool de, int src, bool se) {
uint8_t rex = REX_W; if (se) rex|=4; if (de) rex|=1;
eb(j, rex); eb(j, 0x29); eb(j, MODRM(3, src, dst));
}
static void emit_imul_rr(JitCtx *j, int dst, bool de, int src, bool se) {
uint8_t rex = REX_W; if (de) rex|=4; if (se) rex|=1;
eb(j, rex); eb(j, 0x0F); eb(j, 0xAF); eb(j, MODRM(3, dst, src));
}
static void emit_cmp_rr(JitCtx *j, int rm, bool rme, int reg, bool rege) {
uint8_t rex = REX_W; if (rege) rex|=4; if (rme) rex|=1;
eb(j, rex); eb(j, 0x39); eb(j, MODRM(3, reg, rm));
}
static void emit_neg(JitCtx *j, int reg, bool ext) {
eb(j, ext ? REX_WB : REX_W);
eb(j, 0xF7); eb(j, MODRM(3, 3, reg));
}
static void emit_sub_imm(JitCtx *j, int reg, bool ext, int32_t imm) {
eb(j, ext ? REX_WB : REX_W);
if (imm >= -128 && imm <= 127) {
eb(j, 0x83); eb(j, MODRM(3, 5, reg)); eb(j, (uint8_t)(int8_t)imm);
} else {
eb(j, 0x81); eb(j, MODRM(3, 5, reg)); ei32(j, imm);
}
}
static void emit_add_imm(JitCtx *j, int reg, bool ext, int32_t imm) {
eb(j, ext ? REX_WB : REX_W);
if (imm >= -128 && imm <= 127) {
eb(j, 0x83); eb(j, MODRM(3, 0, reg)); eb(j, (uint8_t)(int8_t)imm);
} else {
eb(j, 0x81); eb(j, MODRM(3, 0, reg)); ei32(j, imm);
}
}
/* ── Conditional jumps (rel32, return offset position for patching) ── */
static int emit_je(JitCtx *j) { eb(j,0x0F); eb(j,0x84); int p=(int)j->len; ei32(j,0); return p; }
static int emit_jne(JitCtx *j) { eb(j,0x0F); eb(j,0x85); int p=(int)j->len; ei32(j,0); return p; }
static int emit_jl(JitCtx *j) { eb(j,0x0F); eb(j,0x8C); int p=(int)j->len; ei32(j,0); return p; }
static int emit_jle(JitCtx *j) { eb(j,0x0F); eb(j,0x8E); int p=(int)j->len; ei32(j,0); return p; }
static int emit_jg(JitCtx *j) { eb(j,0x0F); eb(j,0x8F); int p=(int)j->len; ei32(j,0); return p; }
static int emit_jge(JitCtx *j) { eb(j,0x0F); eb(j,0x8D); int p=(int)j->len; ei32(j,0); return p; }
static int emit_jmp(JitCtx *j) { eb(j,0xE9); int p=(int)j->len; ei32(j,0); return p; }
static void patch_jump(JitCtx *j, int pos) {
int32_t rel = (int32_t)((int)j->len - (pos + 4));
j->buf[pos] = rel & 0xFF;
j->buf[pos+1] = (rel >> 8) & 0xFF;
j->buf[pos+2] = (rel >> 16) & 0xFF;
j->buf[pos+3] = (rel >> 24) & 0xFF;
}
/* ── Epilogue jump (replaces bare ret) ── */
static void emit_return(JitCtx *j) {
int pos = emit_jmp(j);
if (j->n_epilogue_jumps < 512)
j->epilogue_jumps[j->n_epilogue_jumps++] = pos;
}
/* ── TCO jump back to body start ── */
static void emit_tco_jump(JitCtx *j) {
int pos = emit_jmp(j);
if (j->n_tco_jumps < 512)
j->tco_jumps[j->n_tco_jumps++] = pos;
}
/* ═══════════════════════════════════════════════════════════════════════════
* NaN-boxing: unbox/box integers in registers
* ═══════════════════════════════════════════════════════════════════════════ */
/* Unbox: extract lower 48 bits and sign-extend via shl 16; sar 16 */
static void emit_unbox_int(JitCtx *j, int reg, bool ext) {
eb(j, ext ? REX_WB : REX_W);
eb(j, 0xC1); eb(j, MODRM(3, 4, reg)); eb(j, 16); /* shl reg, 16 */
eb(j, ext ? REX_WB : REX_W);
eb(j, 0xC1); eb(j, MODRM(3, 7, reg)); eb(j, 16); /* sar reg, 16 */
}
/* Box: raw int64 → NaN-boxed integer. Uses r10, r11 as scratch. */
static void emit_box_int(JitCtx *j, int reg, bool ext) {
emit_mov_imm64(j, R11, true, INT_BOX_PREFIX);
emit_mov_imm64(j, R10, true, PAYLOAD_MASK);
/* and reg, r10 */
{
uint8_t rex = REX_W;
if (ext) rex |= 0x01;
rex |= 0x04; /* REX.R for r10 */
eb(j, rex); eb(j, 0x21); eb(j, MODRM(3, R10, reg));
}
/* or reg, r11 */
{
uint8_t rex = REX_W;
if (ext) rex |= 0x01;
rex |= 0x04;
eb(j, rex); eb(j, 0x09); eb(j, MODRM(3, R11, reg));
}
}
/* ═══════════════════════════════════════════════════════════════════════════
* AST analysis — determine if a procedure is JIT-compilable
* ═══════════════════════════════════════════════════════════════════════════ */
static bool can_jit_expr(Value expr, Value *params, int nparams, Value self_sym) {
if (IS_INT(expr)) return true;
if (IS_SYM(expr)) {
for (int i = 0; i < nparams; i++)
if (params[i] == expr) return true;
return false;
}
if (!IS_PAIR(expr)) return false;
Value head = CAR(expr);
if (head == SYM_IF) {
Value rest = CDR(expr);
if (!IS_PAIR(rest)) return false;
if (!can_jit_expr(CAR(rest), params, nparams, self_sym)) return false;
rest = CDR(rest);
if (!IS_PAIR(rest)) return false;
if (!can_jit_expr(CAR(rest), params, nparams, self_sym)) return false;
rest = CDR(rest);
if (IS_PAIR(rest))
return can_jit_expr(CAR(rest), params, nparams, self_sym);
return true;
}
/* cond → chain of (test body...) clauses */
if (head == SYM_COND) {
Value clauses = CDR(expr);
while (IS_PAIR(clauses)) {
Value clause = CAR(clauses);
if (!IS_PAIR(clause)) return false;
Value test = CAR(clause);
/* (else body) */
if (IS_SYM(test) && strcmp(sym_name(test), "else") == 0) {
Value body = CDR(clause);
while (IS_PAIR(body)) {
if (!can_jit_expr(CAR(body), params, nparams, self_sym)) return false;
body = CDR(body);
}
return true;
}
if (!can_jit_expr(test, params, nparams, self_sym)) return false;
Value body = CDR(clause);
while (IS_PAIR(body)) {
if (!can_jit_expr(CAR(body), params, nparams, self_sym)) return false;
body = CDR(body);
}
clauses = CDR(clauses);
}
return true;
}
if (IS_SYM(head)) {
const char *name = sym_name(head);
bool is_arith = (strcmp(name, "+") == 0 || strcmp(name, "-") == 0 ||
strcmp(name, "*") == 0 || strcmp(name, "=") == 0 ||
strcmp(name, "<") == 0 || strcmp(name, ">") == 0 ||
strcmp(name, "<=") == 0 || strcmp(name, ">=") == 0 ||
strcmp(name, "not") == 0 || strcmp(name, "zero?") == 0);
if (is_arith) {
Value args = CDR(expr);
while (IS_PAIR(args)) {
if (!can_jit_expr(CAR(args), params, nparams, self_sym))
return false;
args = CDR(args);
}
return true;
}
if (head == self_sym) {
Value args = CDR(expr);
int argc = 0;
while (IS_PAIR(args)) {
if (!can_jit_expr(CAR(args), params, nparams, self_sym))
return false;
argc++;
args = CDR(args);
}
return argc == nparams;
}
}
return false;
}
static bool can_jit_proc(Proc *proc) {
if (proc->nparams > 6) return false;
if (!IS_NIL(proc->rest)) return false;
if (proc->has_defs) return false;
if (proc->body.count != 1) return false;
Value self_sym = proc->name ? intern(proc->name) : VAL_NIL;
return can_jit_expr(proc->body.exprs[0], proc->params, proc->nparams, self_sym);
}
/* ═══════════════════════════════════════════════════════════════════════════
* Code generation
*
* Convention: result always in RAX (NaN-boxed).
* Parameters live in callee-saved regs: r12-r15 (params 0-3),
* stack slots for params 4-5.
* r10, r11 used as scratch for boxing/unboxing.
* ═══════════════════════════════════════════════════════════════════════════ */
static bool emit_expr(JitCtx *j, Value expr, bool tail);
static int find_param(JitCtx *j, Value sym) {
for (int i = 0; i < j->nparams; i++)
if (j->params[i] == sym) return i;
return -1;
}
static void load_param(JitCtx *j, int idx) {
if (idx < 4) {
emit_mov_rr(j, RAX, false, R12 + idx, true);
} else {
int offset = -8 * (idx - 3);
eb(j, REX_W); eb(j, 0x8B);
eb(j, MODRM(2, RAX, RBP)); ei32(j, offset);
}
}
static bool emit_unboxed(JitCtx *j, Value expr) {
if (!emit_expr(j, expr, false)) return false;
emit_unbox_int(j, RAX, false);
return true;
}
/* Evaluate a, b; compare; set flags. Returns comparison kind. */
static bool emit_comparison(JitCtx *j, Value a, Value b, CmpKind *kind, const char *op) {
if (!emit_unboxed(j, a)) return false;
emit_push(j, RAX, false);
if (!emit_unboxed(j, b)) return false;
emit_mov_rr(j, RCX, false, RAX, false);
emit_pop(j, RAX, false);
emit_cmp_rr(j, RAX, false, RCX, false);
if (strcmp(op, "=") == 0) *kind = CMP_EQ;
else if (strcmp(op, "<") == 0) *kind = CMP_LT;
else if (strcmp(op, ">") == 0) *kind = CMP_GT;
else if (strcmp(op, "<=") == 0) *kind = CMP_LE;
else if (strcmp(op, ">=") == 0) *kind = CMP_GE;
else return false;
return true;
}
/* Emit CMOVcc: set RAX to VAL_TRUE or VAL_FALSE based on flags */
static void emit_cmov(JitCtx *j, CmpKind kind) {
emit_mov_imm64(j, RAX, false, VAL_FALSE);
emit_mov_imm64(j, RCX, false, VAL_TRUE);
eb(j, REX_W); eb(j, 0x0F);
switch (kind) {
case CMP_EQ: eb(j, 0x44); break; /* CMOVE */
case CMP_NE: eb(j, 0x45); break; /* CMOVNE */
case CMP_LT: eb(j, 0x4C); break; /* CMOVL */
case CMP_LE: eb(j, 0x4E); break; /* CMOVLE */
case CMP_GT: eb(j, 0x4F); break; /* CMOVG */
case CMP_GE: eb(j, 0x4D); break; /* CMOVGE */
}
eb(j, MODRM(3, RAX, RCX));
}
/* Emit the negated conditional jump to else_target */
static int emit_negated_jump(JitCtx *j, CmpKind kind) {
switch (kind) {
case CMP_EQ: return emit_jne(j);
case CMP_NE: return emit_je(j);
case CMP_LT: return emit_jge(j);
case CMP_LE: return emit_jg(j);
case CMP_GT: return emit_jle(j);
case CMP_GE: return emit_jl(j);
}
return emit_jne(j); /* unreachable */
}
static bool emit_expr(JitCtx *j, Value expr, bool tail) {
/* ── Integer literal ── */
if (IS_INT(expr)) {
emit_mov_imm64(j, RAX, false, expr);
if (tail) emit_return(j);
return true;
}
/* ── Parameter reference ── */
if (IS_SYM(expr)) {
int idx = find_param(j, expr);
if (idx < 0) return false;
load_param(j, idx);
if (tail) emit_return(j);
return true;
}
if (!IS_PAIR(expr)) return false;
Value head = CAR(expr);
Value rest = CDR(expr);
/* ── (if test then else?) ── */
if (head == SYM_IF) {
Value test = CAR(rest);
Value then_br = CADR(rest);
Value else_rest = CDDR(rest);
bool has_else = IS_PAIR(else_rest);
Value else_br = has_else ? CAR(else_rest) : VAL_VOID;
bool is_cmp = false;
CmpKind cmp_kind = CMP_EQ;
if (IS_PAIR(test) && IS_SYM(CAR(test))) {
const char *tn = sym_name(CAR(test));
if ((strcmp(tn,"=") == 0 || strcmp(tn,"<") == 0 || strcmp(tn,">") == 0 ||
strcmp(tn,"<=") == 0 || strcmp(tn,">=") == 0) &&
IS_PAIR(CDR(test)) && IS_PAIR(CDDR(test)) && IS_NIL(CDR(CDDR(test)))) {
if (!emit_comparison(j, CADR(test), CADDR(test), &cmp_kind, tn))
return false;
is_cmp = true;
} else if (strcmp(tn,"not") == 0 && IS_PAIR(CDR(test)) && IS_NIL(CDDR(test))) {
if (!emit_expr(j, CADR(test), false)) return false;
emit_mov_imm64(j, RCX, false, VAL_FALSE);
emit_cmp_rr(j, RAX, false, RCX, false);
cmp_kind = CMP_EQ; is_cmp = true;
} else if (strcmp(tn,"zero?") == 0 && IS_PAIR(CDR(test)) && IS_NIL(CDDR(test))) {
if (!emit_expr(j, CADR(test), false)) return false;
emit_mov_imm64(j, RCX, false, VAL_INT(0));
emit_cmp_rr(j, RAX, false, RCX, false);
cmp_kind = CMP_EQ; is_cmp = true;
}
}
if (!is_cmp) {
if (!emit_expr(j, test, false)) return false;
emit_mov_imm64(j, RCX, false, VAL_FALSE);
emit_cmp_rr(j, RAX, false, RCX, false);
}
int else_jmp;
if (is_cmp) {
else_jmp = emit_negated_jump(j, cmp_kind);
} else {
/* Jump to else when result == #f (i.e., when ZF=1 from cmp) */
else_jmp = emit_je(j);
}
if (!emit_expr(j, then_br, tail)) return false;
if (!tail) {
int end_jmp = emit_jmp(j);
patch_jump(j, else_jmp);
if (has_else) {
if (!emit_expr(j, else_br, false)) return false;
} else {
emit_mov_imm64(j, RAX, false, VAL_VOID);
}
patch_jump(j, end_jmp);
} else {
patch_jump(j, else_jmp);
if (has_else) {
if (!emit_expr(j, else_br, true)) return false;
} else {
emit_mov_imm64(j, RAX, false, VAL_VOID);
emit_return(j);
}
}
return true;
}
/* ── cond → cascaded if/else ── */
if (head == SYM_COND) {
int end_jmps[32]; int n_ends = 0;
Value clauses = rest;
while (IS_PAIR(clauses)) {
Value clause = CAR(clauses);
Value test = CAR(clause);
Value body = CDR(clause);
clauses = CDR(clauses);
bool is_else = IS_SYM(test) && strcmp(sym_name(test), "else") == 0;
bool is_last = !IS_PAIR(clauses);
if (is_else) {
/* else clause — just emit the body */
while (IS_PAIR(body) && IS_PAIR(CDR(body))) {
if (!emit_expr(j, CAR(body), false)) return false;
body = CDR(body);
}
if (IS_PAIR(body)) {
if (!emit_expr(j, CAR(body), tail)) return false;
}
break;
}
/* Emit test */
bool is_cmp = false;
CmpKind cmp_kind = CMP_EQ;
if (IS_PAIR(test) && IS_SYM(CAR(test))) {
const char *tn = sym_name(CAR(test));
if ((strcmp(tn,"=") == 0 || strcmp(tn,"<") == 0 || strcmp(tn,">") == 0 ||
strcmp(tn,"<=") == 0 || strcmp(tn,">=") == 0) &&
IS_PAIR(CDR(test)) && IS_PAIR(CDDR(test)) && IS_NIL(CDR(CDDR(test)))) {
if (emit_comparison(j, CADR(test), CADDR(test), &cmp_kind, tn))
is_cmp = true;
}
}
if (!is_cmp) {
if (!emit_expr(j, test, false)) return false;
emit_mov_imm64(j, RCX, false, VAL_FALSE);
emit_cmp_rr(j, RAX, false, RCX, false);
}
int skip_jmp = is_cmp ? emit_negated_jump(j, cmp_kind) : emit_je(j);
/* Emit body (last expr in tail position if this cond is tail) */
while (IS_PAIR(body) && IS_PAIR(CDR(body))) {
if (!emit_expr(j, CAR(body), false)) return false;
body = CDR(body);
}
if (IS_PAIR(body)) {
if (!emit_expr(j, CAR(body), tail && is_last)) return false;
}
if (!tail || !is_last) {
if (n_ends < 32) end_jmps[n_ends++] = emit_jmp(j);
}
patch_jump(j, skip_jmp);
}
/* Patch all end jumps to here */
for (int i = 0; i < n_ends; i++) patch_jump(j, end_jmps[i]);
return true;
}
if (!IS_SYM(head)) return false;
const char *opname = sym_name(head);
/* ── Arithmetic: + - * ── */
if (strcmp(opname, "+") == 0 || strcmp(opname, "-") == 0 || strcmp(opname, "*") == 0) {
Value args = rest;
int argc = 0;
Value av[16];
while (IS_PAIR(args) && argc < 16) { av[argc++] = CAR(args); args = CDR(args); }
char op = opname[0];
if (argc == 0) {
emit_mov_imm64(j, RAX, false, op == '*' ? VAL_INT(1) : VAL_INT(0));
} else if (argc == 1 && op == '-') {
if (!emit_unboxed(j, av[0])) return false;
emit_neg(j, RAX, false);
emit_box_int(j, RAX, false);
} else if (argc == 1) {
if (!emit_expr(j, av[0], false)) return false;
} else {
if (!emit_unboxed(j, av[0])) return false;
for (int i = 1; i < argc; i++) {
emit_push(j, RAX, false);
if (!emit_unboxed(j, av[i])) return false;
emit_mov_rr(j, RCX, false, RAX, false);
emit_pop(j, RAX, false);
if (op == '+') emit_add_rr(j, RAX, false, RCX, false);
else if (op == '-') emit_sub_rr(j, RAX, false, RCX, false);
else emit_imul_rr(j, RAX, false, RCX, false);
}
emit_box_int(j, RAX, false);
}
if (tail) emit_return(j);
return true;
}
/* ── Comparisons: = < > <= >= ── */
if (strcmp(opname,"=") == 0 || strcmp(opname,"<") == 0 || strcmp(opname,">") == 0 ||
strcmp(opname,"<=") == 0 || strcmp(opname,">=") == 0) {
if (!IS_PAIR(rest) || !IS_PAIR(CDR(rest)) || !IS_NIL(CDDR(rest))) return false;
CmpKind kind;
if (!emit_comparison(j, CAR(rest), CADR(rest), &kind, opname)) return false;
emit_cmov(j, kind);
if (tail) emit_return(j);
return true;
}
/* ── (not x) ── */
if (strcmp(opname, "not") == 0) {
if (!IS_PAIR(rest) || !IS_NIL(CDR(rest))) return false;
if (!emit_expr(j, CAR(rest), false)) return false;
emit_mov_imm64(j, RCX, false, VAL_FALSE);
emit_cmp_rr(j, RAX, false, RCX, false);
emit_cmov(j, CMP_EQ);
if (tail) emit_return(j);
return true;
}
/* ── (zero? x) ── */
if (strcmp(opname, "zero?") == 0) {
if (!IS_PAIR(rest) || !IS_NIL(CDR(rest))) return false;
if (!emit_expr(j, CAR(rest), false)) return false;
emit_mov_imm64(j, RCX, false, VAL_INT(0));
emit_cmp_rr(j, RAX, false, RCX, false);
emit_cmov(j, CMP_EQ);
if (tail) emit_return(j);
return true;
}
/* ── Self-recursive call ── */
if (head == j->self_sym && !IS_NIL(j->self_sym)) {
Value args = rest;
int argc = 0;
Value av[6];
while (IS_PAIR(args) && argc < 6) { av[argc++] = CAR(args); args = CDR(args); }
if (argc != j->nparams) return false;
if (tail) {
/* TCO: evaluate args to stack, pop into param regs, jmp body_start */
for (int i = 0; i < argc; i++) {
if (!emit_expr(j, av[i], false)) return false;
emit_push(j, RAX, false);
}
for (int i = argc - 1; i >= 0; i--) {
if (i < 4) {
emit_pop(j, R12 + i, true);
} else {
emit_pop(j, RAX, false);
int offset = -8 * (i - 3);
eb(j, REX_W); eb(j, 0x89);
eb(j, MODRM(2, RAX, RBP)); ei32(j, offset);
}
}
emit_tco_jump(j);
return true;
} else {
/* Non-tail: callee-saved r12-r15 survive the call.
* Evaluate args, push, pop into System V arg regs, call self. */
for (int i = 0; i < argc; i++) {
if (!emit_expr(j, av[i], false)) return false;
emit_push(j, RAX, false);
}
for (int i = argc - 1; i >= 0; i--) {
emit_pop(j, ARG_REGS[i], ARG_REG_EXT[i]);
}
/* call self via absolute address in rax */
emit_mov_imm64(j, RAX, false, (uint64_t)(uintptr_t)j->entry);
eb(j, 0xFF); eb(j, MODRM(3, 2, RAX)); /* call rax */
/* Result in rax. Our r12-r15 params are preserved by callee. */
return true;
}
}
return false;
}
/* ═══════════════════════════════════════════════════════════════════════════
* Top-level JIT compilation
* ═══════════════════════════════════════════════════════════════════════════ */
JitBlock *jit_compile(Proc *proc) {
if (!can_jit_proc(proc)) return NULL;
JitCtx j;
jctx_init(&j, 4096 * 4); /* 16KB */
if (!j.buf) return NULL;
j.params = proc->params;
j.nparams = proc->nparams;
j.name = proc->name;
j.self_sym = proc->name ? intern(proc->name) : VAL_NIL;
/* ═══ Prologue ═══ */
emit_push(&j, RBP, false); /* push rbp */
emit_mov_rr(&j, RBP, false, RSP, false); /* mov rbp, rsp */
emit_push(&j, RBX, false); /* push rbx */
emit_push(&j, R12, true); /* push r12 */
emit_push(&j, R13, true); /* push r13 */
emit_push(&j, R14, true); /* push r14 */
emit_push(&j, R15, true); /* push r15 */
/* Stack alignment: 6 pushes = 48 bytes. Entry was 16-aligned - 8 (ret addr).
* After 6 pushes: offset = 56 = 16*3 + 8. Need sub 8 to align to 16. */
j.extra_stack = 8;
if (proc->nparams > 4) {
j.extra_stack += 8 * (proc->nparams - 4);
j.extra_stack = (j.extra_stack + 15) & ~15;
}
emit_sub_imm(&j, RSP, false, j.extra_stack);
/* Copy System V arg regs → callee-saved param regs */
for (int i = 0; i < proc->nparams && i < 4; i++) {
emit_mov_rr(&j, R12 + i, true, ARG_REGS[i], ARG_REG_EXT[i]);
}
for (int i = 4; i < proc->nparams; i++) {
int offset = -8 * (i - 3);
uint8_t rex = REX_W;
if (ARG_REG_EXT[i]) rex |= 0x04;
eb(&j, rex); eb(&j, 0x89);
eb(&j, MODRM(2, ARG_REGS[i], RBP)); ei32(&j, offset);
}
/* Mark body start for TCO */
j.body_start = (int)j.len;
/* ═══ Emit body ═══ */
if (!emit_expr(&j, proc->body.exprs[0], true)) {
munmap(j.buf, j.cap);
return NULL;
}
/* ═══ Epilogue ═══ */
int epilogue = (int)j.len;
emit_add_imm(&j, RSP, false, j.extra_stack);
emit_pop(&j, R15, true);
emit_pop(&j, R14, true);
emit_pop(&j, R13, true);
emit_pop(&j, R12, true);
emit_pop(&j, RBX, false);
emit_pop(&j, RBP, false);
eb(&j, 0xC3); /* ret */
/* ═══ Patch jumps ═══ */
for (int i = 0; i < j.n_epilogue_jumps; i++) {
int pos = j.epilogue_jumps[i];
int32_t rel = (int32_t)(epilogue - (pos + 4));
j.buf[pos] = rel & 0xFF;
j.buf[pos+1] = (rel >> 8) & 0xFF;
j.buf[pos+2] = (rel >> 16) & 0xFF;
j.buf[pos+3] = (rel >> 24) & 0xFF;
}
for (int i = 0; i < j.n_tco_jumps; i++) {
int pos = j.tco_jumps[i];
int32_t rel = (int32_t)(j.body_start - (pos + 4));
j.buf[pos] = rel & 0xFF;
j.buf[pos+1] = (rel >> 8) & 0xFF;
j.buf[pos+2] = (rel >> 16) & 0xFF;
j.buf[pos+3] = (rel >> 24) & 0xFF;
}
/* ═══ Create JitBlock ═══ */
JitBlock *block = (JitBlock *)ul_malloc(sizeof(JitBlock));
block->code = j.buf;
block->size = j.cap;
block->func = (JitFunc)(void *)j.buf;
block->name = proc->name ? ul_strdup(proc->name) : NULL;
return block;
}
void jit_free(JitBlock *block) {
if (!block) return;
if (block->code) munmap(block->code, block->size);
if (block->name) ul_free((char *)block->name);
ul_free(block);
}

10
c/main.c
View file

@ -2,6 +2,7 @@
* main.c — REPL, script mode, -e mode
*/
#include "uncommonlisp.h"
#include "jit.h"
/* ═══════════════════════════════════════════════════════════════════════════
* Find stdlib.lsp relative to the executable
@ -134,10 +135,13 @@ int main(int argc, char **argv) {
bool fast = false;
bool help = false;
bool version = false;
bool jit = false;
const char *eval_expr = NULL;
while (argi < argc) {
if (strcmp(argv[argi], "--fast") == 0 || strcmp(argv[argi], "-f") == 0) {
if (strcmp(argv[argi], "--jit") == 0 || strcmp(argv[argi], "-j") == 0) {
jit = true; argi++;
} else if (strcmp(argv[argi], "--fast") == 0 || strcmp(argv[argi], "-f") == 0) {
fast = true; argi++;
} else if (strcmp(argv[argi], "--help") == 0 || strcmp(argv[argi], "-h") == 0) {
help = true; argi++;
@ -158,10 +162,11 @@ int main(int argc, char **argv) {
"Options:\n"
" -e EXPR evaluate expression and print result\n"
" -f, --fast auto-compile all defines (bytecode VM)\n"
" -j, --jit enable x86_64 JIT compiler for eligible functions\n"
" -h, --help show this help\n"
" -v, --version show version\n\n"
"Features: R7RS core, bytecode compiler, macros, syntax-rules,\n"
" modules, rationals, string ports.\n");
" modules, rationals, string ports, x86_64 JIT.\n");
return 0;
}
@ -171,6 +176,7 @@ int main(int argc, char **argv) {
}
if (fast) g_auto_compile = true;
if (jit) g_jit_enabled = true;
/* Load stdlib.lsp if it exists */
char *stdlib_path = find_stdlib(argv[0]);

1
c/types.c
View file

@ -574,6 +574,7 @@ Proc *make_proc(Value *params, int nparams, Value rest,
p->env = env;
p->name = name ? ul_strdup(name) : NULL;
p->has_defs = has_internal_defines(body);
p->jit_block = NULL;
return p;
}

1
c/uncommonlisp.h
View file

@ -338,6 +338,7 @@ typedef struct Proc {
Env *env;
const char *name;
bool has_defs; /* body starts with define? */
void *jit_block; /* cached JitBlock*, or NULL */
} Proc;
#define IS_PROC(v) (IS_PTR(v) && obj_type(v) == OBJ_PROC)