pit: Add tests, fix binding bugHEADmaster

10 files changed, 942 insertions, 0 deletions

diff --git a/asm/.dir-locals.el b/asm/.dir-locals.el
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/asm/.dir-locals.el
diff --git a/asm/.envrc b/asm/.envrc
new file mode 100644
index 0000000..fed67eb
--- /dev/null
+++ b/asm/.envrc
@@ -0,0 +1 @@
+use_flake ..#asm
diff --git a/asm/Makefile b/asm/Makefile
new file mode 100644
index 0000000..bede40e
--- /dev/null
+++ b/asm/Makefile
@@ -0,0 +1,72 @@
+EXE ?= asm
+
+CC ?= gcc
+AR ?= ar
+override CPPFLAGS += -MMD -MP
+override CFLAGS += -O2 -fPIC --std=c99 -g -Ideps/ -Isrc/ -Iinclude/ -Wall -Wextra -Wpedantic -Wconversion -Wformat-security -Wshadow -Wpointer-arith -Wstrict-prototypes -Wmissing-prototypes -Wnull-dereference -Wfloat-equal -Wundef -Wpointer-arith -Wbad-function-cast -Wlogical-op -Wmissing-braces -Wcast-align -Wstrict-overflow=5 -fwrapv # -ftrapv
+override LDFLAGS += -g -static -lcolonq-pit-native -lcolonq-pit -lcolonq-elf
+
+BUILD = build_$(CC)
+
+SRCS := \
+  src/library.c \
+  src/main.c
+OBJECTS := $(SRCS:src/%.c=$(BUILD)/%.o)
+LIB := libcolonq-asm.a
+
+CHK_SOURCES ?= $(SRCS)
+
+prefix ?= /usr/local
+exec_prefix ?= $(prefix)
+bindir ?= $(exec_prefix)/bin
+includedir ?= $(prefix)/include
+libdir ?= $(exec_prefix)/lib
+
+GDBFLAGS ?=
+
+.PHONY: all clean install install-bin install-headers install-lib check-syntax gdb
+
+all: $(EXE) $(LIB)
+
+$(EXE): $(BUILD)/main.o $(LIB)
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+$(LIB): $(OBJECTS)
+	$(AR) rcs $@ $^
+
+$(BUILD):
+	mkdir $(BUILD)/
+
+$(BUILD)/%.o: src/%.c | $(BUILD)
+	$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ -c $<
+
+clean:
+	-rm $(EXE)
+	-rm $(LIB)
+	-rm -r $(BUILD)/
+
+tags: $(SRCS)
+	@ctags --kinds-all=* --fields=* --extras=* --recurse src/ include/
+
+install: install-bin install-headers install-lib
+
+install-bin: $(EXE)
+	mkdir -p $(DESTDIR)$(bindir) $(DESTDIR)$(libdir) $(DESTDIR)$(includedir)
+	install $(EXE) $(DESTDIR)$(bindir)/$(EXE)
+
+install-headers:
+	mkdir -p $(DESTDIR)$(bindir) $(DESTDIR)$(libdir) $(DESTDIR)$(includedir)
+	cp -r include/* $(DESTDIR)$(includedir)
+
+install-lib: $(LIB)
+	mkdir -p $(DESTDIR)$(bindir) $(DESTDIR)$(libdir) $(DESTDIR)$(includedir)
+	install $(LIB) $(DESTDIR)$(libdir)/$(LIB)
+
+check-syntax: tags
+	gcc $(CFLAGS) -fsyntax-only $(CHK_SOURCES)
+
+gdb: $(EXE)
+	gdb $(GDBFLAGS) $(EXE)
+
+-include $(BUILD)/main.d
+-include $(OBJECTS:.o=.d)
diff --git a/asm/include/lcq/asm/library.h b/asm/include/lcq/asm/library.h
new file mode 100644
index 0000000..8e2f311
--- /dev/null
+++ b/asm/include/lcq/asm/library.h
@@ -0,0 +1,8 @@
+#ifndef LCOLONQ_ASM_LIBRARY_H
+#define LCOLONQ_ASM_LIBRARY_H
+
+#include <lcq/pit.h>
+
+void asm_install_library_elf(pit_runtime *rt);
+
+#endif
diff --git a/asm/lisp/test.pit b/asm/lisp/test.pit
new file mode 100644
index 0000000..cafa8f4
--- /dev/null
+++ b/asm/lisp/test.pit
@@ -0,0 +1,29 @@
+(let ( (elf (elf/new!))
+       (entrypoint 0x696000)
+       (toff 0x1000)
+       (phdroff 0x2000))
+  (elf/write-bytes! elf toff
+    '( 0xb8 0x3c 0x00 0x00 0x00 ;; mov rax, 60
+       0xbf 0x2a 0x00 0x00 0x00 ;; mov rdi, 42
+       0x0f 0x05 ;; syscall
+       ))
+  (elf/write-program-header! elf (+ phdroff elf/64_PROGRAM_HEADER_SIZE)
+    :type elf/PROGRAM_HEADER_TYPE_LOAD
+    :offset toff
+    :virtual-addr entrypoint
+    :file-size 0x100
+    :mem-size 0x100
+    :flags (bitwise/or elf/PROGRAM_HEADER_FLAG_R elf/PROGRAM_HEADER_FLAG_X)
+    )
+  (elf/write-header! elf
+    :type elf/TYPE_EXEC
+    :machine elf/MACHINE_AMD64
+    :program-header-offset phdroff
+    :program-header-entry-size elf/64_PROGRAM_HEADER_SIZE
+    :program-header-entries 2
+    :section-header-offset 0
+    :section-header-entry-size elf/64_SECTION_HEADER_SIZE
+    :section-header-entries 0
+    :entry entrypoint
+    )
+  (elf/spit! "test.elf" elf))
diff --git a/asm/lisp/x86.pit b/asm/lisp/x86.pit
new file mode 100644
index 0000000..b06a9c2
--- /dev/null
+++ b/asm/lisp/x86.pit
@@ -0,0 +1,490 @@
+(defun! x86/split16le (w)
+  "Split the 16-bit W16 into a little-endian list of 8-bit integers."
+  (list
+    (bitwise/and 0xff w)
+    (bitwise/and 0xff (bitwise/rshift w 8))))
+
+(defun! x86/split32le (w)
+  "Split the 32-bit W32 into a little-endian list of 8-bit integers."
+  (list
+   (bitwise/and 0xff w)
+   (bitwise/and 0xff (bitwise/rshift w 8))
+   (bitwise/and 0xff (bitwise/rshift w 16))
+   (bitwise/and 0xff (bitwise/rshift w 24))))
+
+(defun! x86/register-1byte? (r)
+  "Return the register index for 1-byte register R."
+  (case r
+    (al 0) (cl 1) (dl 2) (bl 3)
+    (ah 4) (ch 5) (dh 6) (bh 7)
+    (r8b 8) (r9b 9) (r10b 10) (r11b 11)
+    (r12b 12) (r13b 13) (r14b 14) (r15b 15)))
+
+(defun! x86/register-2byte? (r)
+  "Return the register index for 2-byte register R."
+  (case r
+    (ax 0) (cx 1) (dx 2) (bx 3)
+    (sp 4) (bp 5) (si 6) (di 7)
+    (r8w 8) (r9w 9) (r10w 10) (r11w 11)
+    (r12w 12) (r13w 13) (r14w 14) (r15w 15)))
+
+(defun! x86/register-4byte? (r)
+  "Return the register index for 4-byte register R."
+  (case r
+    (eax 0) (ecx 1) (edx 2) (ebx 3)
+    (esp 4) (ebp 5) (esi 6) (edi 7)
+    (r8d 8) (r9d 9) (r10d 10) (r11d 11)
+    (r12d 12) (r13d 13) (r14d 14) (r15d 15)))
+
+(defun! x86/register-8byte? (r)
+  "Return the register index for 8-byte register R."
+  (case r
+    (rax 0) (rcx 1) (rdx 2) (rbx 3)
+    (rsp 4) (rbp 5) (rsi 6) (rdi 7)
+    (r8 8) (r9 9) (r10 10) (r11 11)
+    (r12 12) (r13 13) (r14 14) (r15 15)))
+
+(defun! x86/register? (r)
+  "Return the register index of R."
+  (or
+    (x86/register-1byte? r)
+    (x86/register-2byte? r)
+    (x86/register-4byte? r)
+    (x86/register-8byte? r)))
+
+(defun! x86/register-extended? (r)
+  "Return non-nil if R is an extended register."
+  (list/contains? r
+    '( r8b r9b r10b r11b r12b r13b r14b r15b
+       r8w r9w r10w r11w r12w r13w r14w r15w
+       r8d r9d r10d r11d r12d r13d r14d r15d
+       r8 r9 r10 r11 r12 r13 r14 r15)))
+
+(defun! x86/integer-fits-in-bits? (bits x)
+  "Determine if X fits in BITS."
+  (if (integer? x)
+    (let ((leftover (bitwise/rshift x bits)))
+      (eq? leftover 0))))
+(defun! x86/operand-immediate-fits? (sz x)
+  "Determine if immediate operand X fits in SZ."
+  (let
+    ((bits
+       (or
+         (case sz
+           ("b" 8) ("c" 16) ("d" 32) ("i" 16)
+           ("j" 32) ("q" 64) ("v" 64) ("w" 16)
+           ("y" 64) ("z" 32))
+         (error! "unknown operand pattern size"))))
+    (x86/integer-fits-in-bits? bits x)))
+
+(defun! x86/operand-register-fits? (sz r)
+  "Determine if register operand R fits in SZ."
+  (case sz
+    ("b" (x86/register-1byte? r))
+    ("c" (or (x86/register-1byte? r) (x86/register-2byte? r)))
+    ("d" (x86/register-4byte? r))
+    ("i" (x86/register-2byte? r))
+    ("j" (x86/register-4byte? r))
+    ("q" (x86/register-8byte? r))
+    ("v" (or (x86/register-2byte? r) (x86/register-4byte? r) (x86/register-8byte? r)))
+    ("w" (x86/register-2byte? r))
+    ("y" (or (x86/register-4byte? r) (x86/register-8byte? r)))
+    ("z" (or (x86/register-2byte? r) (x86/register-4byte? r)))))
+
+(defun! x86/memory-operand-base (m)
+  (and
+    (eq? (car m) 'mem)
+    (car (cdr m))))
+(defun! x86/memory-operand-off (m)
+  (and
+    (eq? (car m) 'mem)
+    (or (car (cdr (cdr m))) 0)))
+
+(defun! x86/operand-memory-location? (op)
+  "Return non-nil if OP represents a memory location."
+  (let ( (base (x86/memory-operand-base op))
+         (off (x86/memory-operand-off op)))
+    (and
+      (or (x86/register-4byte? base) (x86/register-8byte? base))
+      (integer? off))))
+
+(defun! x86/operand-match? (pat op)
+  "Determine if operand OP matches PAT."
+  (cond
+    ((symbol? pat) (eq? pat op))
+    ((cons? pat) (list/contains? op pat))
+    ((bytes? pat)
+      (let ( (loc (bytes/range 0 1 pat))
+             (sz (bytes/range 1 (bytes/len pat) pat)))
+        (cond
+          ((or (equal? loc "I") (equal? loc "J")) (x86/operand-immediate-fits? sz op))
+          ((or (equal? loc "G") (equal? loc "R")) (x86/operand-register-fits? sz op))
+          ((equal? loc "M") (x86/operand-memory-location? op))
+          ((equal? loc "E")
+            (or (x86/operand-register-fits? sz op) (x86/operand-memory-location? op)))
+          (t (error! "unknown operand pattern location")))))))
+
+(defun! x86/operand-size (op)
+  "Return the minimum power-of-2 size in bytes that contains OP."
+  (cond
+    ((symbol? op)
+      (cond
+        ((x86/register-1byte? op) 1)
+        ((x86/register-2byte? op) 2)
+        ((x86/register-4byte? op) 4)
+        ((x86/register-8byte? op) 8)
+        (t (error! "attempted to take size of unknown register"))))
+    ((integer? op)
+      (cond
+        ((x86/integer-fits-in-bits? 8 op) 1)
+        ((x86/integer-fits-in-bits? 16 op) 2)
+        ((x86/integer-fits-in-bits? 32 op) 4)
+        ((x86/integer-fits-in-bits? 64 op) 8)
+        (t (error! "attempted to take size of too-large immediate"))))
+    ((x86/operand-memory-location? op) 1)
+    (t (error! "attempted to take size of unknown operand"))))
+
+(defstruct! x86/ins
+  operand-size-prefix
+  address-size-prefix
+  rex-w
+  rex-r
+  rex-x
+  rex-b
+  opcode
+  modrm-mod
+  modrm-reg
+  modrm-rm
+  disp ;; pair of size and value
+  imm ;; pair of size and value
+  )
+
+(defun! x86/ins-bytes (ins)
+  "Return a list of bytes encoding INS."
+  (let ( (opcode (x86/ins/get-opcode ins))
+         (rex-w (x86/ins/get-rex-w ins))
+         (rex-r (x86/ins/get-rex-r ins))
+         (rex-x (x86/ins/get-rex-x ins))
+         (rex-b (x86/ins/get-rex-b ins))
+         (modrm-mod (x86/ins/get-modrm-mod ins))
+         (modrm-reg (x86/ins/get-modrm-reg ins))
+         (modrm-rm (x86/ins/get-modrm-rm ins))
+         (disp (x86/ins/get-disp ins))
+         (imm (x86/ins/get-imm ins)))
+    (list/append
+      (if (x86/ins/get-operand-size-prefix ins) '(0x66))
+      (if (x86/ins/get-address-size-prefix ins) '(0x67))
+      (if (or rex-w rex-r rex-x rex-b)
+        (list
+          (bitwise/or
+            0x40
+            (if rex-w 0b1000 0)
+            (if rex-r 0b0100 0)
+            (if rex-x 0b0010 0)
+            (if rex-b 0b0001 0))))
+      (cond
+        ((not opcode) (error! "no opcode for instruction"))
+        ((cons? opcode) opcode)
+        ((integer? opcode) (list opcode))
+        (t (error! "malformed opcode for instruction")))
+      (if (or modrm-mod modrm-reg modrm-rm)
+        (list
+          (bitwise/or
+            (bitwise/lshift (or modrm-mod 0) 6)
+            (bitwise/lshift (or modrm-reg 0) 3)
+            (or modrm-rm 0))))
+      (if disp
+        (cond
+          ((eq? (car disp) 1) (list (cdr disp)))
+          ((eq? (car disp) 4) (x86/split32le (cdr disp)))
+          (t (error! "malformed displacement for instruction"))))
+      (if imm
+        (cond
+          ((eq? (car imm) 1) (list (cdr imm)))
+          ((eq? (car imm) 2) (x86/split16le (cdr imm)))
+          ((eq? (car imm) 4) (x86/split32le (cdr imm)))
+          (t (error! "malformed immediate for instruction")))))))
+
+(defun! x86/instruction-update-sizes (ins ops default-size)
+  "Update INS to account for the sizes of OPS.
+DEFAULT-SIZE is the default operand size."
+  (let ((defsz (or default-size 4)))
+    (if (> (list/len ops) 0)
+      (let ((regs (list/uniq (list/map 'x86/operand-size (list/filter 'x86/register? ops)))))
+        (if (> (list/len regs) 1)
+          (error! "invalid mix of register sizes in operands"))
+        (let ((sz (if (eq? (list/len regs) 0) defsz (car regs))))
+          (cond
+            ((eq? sz 1) nil)
+            ((eq? defsz sz) nil)
+            ((and (not (eq? defsz 2)) (eq? sz 2)) (x86/ins/set-operand-size-prefix! ins t))
+            ((and (not (eq? defsz 8)) (eq? sz 8)) (x86/ins/set-rex-w! ins t))
+            (t (error! "unable to encode operands with default size")))
+          sz)))))
+
+(defun! x86/instruction-update-operand (esz ins pat op)
+  "Update INS to account for an operand OP according to PAT.
+The effective operand size is ESZ."
+  (cond
+    ((bytes? pat)
+      (let ((loc (bytes/range 0 1 pat)))
+        (cond
+          ((equal? loc "I")
+            (let ((immsz (if (>= esz 4) 4 esz)))
+              (if (not (x86/integer-fits-in-bits? (* 8 immsz) op))
+                (error! "Immediate too large" op))
+              (x86/ins/set-imm! ins (cons immsz op))))
+          ((equal? loc "J")
+            (let ((immsz (if (eq? esz 1) 1 4)))
+              (if (not (x86/integer-fits-in-bits? (* 8 immsz) op))
+                (error! "jump displacement too large"))
+              (x86/ins/set-disp! ins (cons immsz op))))
+          ((equal? loc "G")
+            (x86/ins/set-modrm-reg! ins
+              (or (x86/register? op) (error "Invalid register: %s" op))))
+          ((or (equal? loc "R") (and (equal? loc "E") (x86/register? op)))
+            (x86/ins/set-modrm-mod! ins 0b11)
+            (x86/ins/set-modrm-rm! ins
+              (or (x86/register? op) (error "Invalid register: %s" op))))
+          ((or (equal? loc "M") (and (equal? loc "E") (x86/operand-memory-location? op)))
+            (let ( (base (x86/memory-operand-base op))
+                   (off (x86/memory-operand-off op)))
+              (cond
+                ((eq? base 'eip)
+                  (x86/ins/set-modrm-rm! ins 0b101)
+                  (x86/ins/set-modrm-mod! ins 0b00)
+                  (x86/ins/set-disp! ins (cons 4 off))
+                  (x86/ins/set-address-size-prefix! ins t))
+                ((eq? base 'rip)
+                  (x86/ins/set-modrm-rm! ins 0b101)
+                  (x86/ins/set-modrm-mod! ins 0b00)
+                  (x86/ins/set-disp! ins (cons 4 off)))
+                (t
+                  (x86/ins/set-modrm-rm! ins
+                    (or
+                      (x86/register-4byte? base)
+                      (x86/register-8byte? base)
+                      (error! "invalid base register")))
+                  (if (x86/register-4byte? base)
+                    (x86/ins/set-address-size-prefix! ins t))
+                  (cond
+                    ((x86/integer-fits-in-bits? 8 off)
+                      (x86/ins/set-disp! ins (cons 1 off))
+                      (x86/ins/set-modrm-mod! ins 0b01))
+                    ((x86/integer-fits-in-bits? 32 off)
+                      (x86/ins/set-disp! ins (cons 4 off))
+                      (x86/ins/set-modrm-mod! ins 0b10))
+                    (t (error! "invalid offset")))))))
+          (t (error! "invalid operand location code")))))))
+
+(defun! x86/default-instruction-handler (opcode & kwargs)
+  "Return an instruction handler for OPCODE.
+The instruction handler will run POSTHOOK on the instruction at the end.
+DEFAULT-SIZE is the default operand size."
+  (let ( (posthook (plist/get :posthook kwargs))
+         (default-size (plist/get :default-size kwargs)))
+    (lambda (pats ops)
+      (let ((ret (x86/ins/new :opcode opcode)))
+        (let ((esz
+                (or (x86/instruction-update-sizes ret ops default-size)
+                  (error! "malformed size for operands"))))
+          (list/zip-with
+            (lambda (it other)
+              (x86/instruction-update-operand esz ret it other))
+            pats
+            ops))
+        (if posthook
+          (funcall posthook ret ops))
+        ret))))
+
+(defun! x86/instruction-handler-jcc (opcode immsz)
+  "Return an instruction handler for a Jcc instruction at OPCODE.
+IMMSZ is the size of the displacement from RIP."
+  (lambda (_pats ops)
+    (let ((ret (x86/ins/new :opcode opcode)))
+      (x86/ins/set-disp! ret (cons immsz (car ops)))
+      ret)))
+
+(defun! x86/generate-handlers-arith (opbase group1reg)
+  "Return handlers for an arithmetic mnemonic starting at OPBASE.
+The REG value in ModR/M is indicated by GROUP1REG."
+  (list
+    (cons '("Eb" "Gb") (x86/default-instruction-handler (+ opbase 0)))
+    (cons '("Ev" "Gv") (x86/default-instruction-handler (+ opbase 1)))
+    (cons '("Gb" "Eb") (x86/default-instruction-handler (+ opbase 2)))
+    (cons '("Gv" "Ev") (x86/default-instruction-handler (+ opbase 3)))
+    (cons '(al "Ib") (x86/default-instruction-handler (+ opbase 4)))
+    (cons '((ax eax rax) "Iz") (x86/default-instruction-handler (+ opbase 5)))
+    (cons '("Eb" "Ib")
+      (x86/default-instruction-handler 0x80
+        :posthook (lambda (ins _) (x86/ins/set-modrm-reg! ins group1reg))))
+    (cons '("Ev" "Iz")
+      (x86/default-instruction-handler 0x81
+        :posthook (lambda (ins _) (x86/ins/set-modrm-reg! ins group1reg))))
+    (cons '("Ev" "Ib")
+      (x86/default-instruction-handler 0x83
+        :posthook (lambda (ins _) (setf (x86/ins-modrm-reg ins) group1reg))))))
+
+(setq! x86/registers-+reg-base
+  '( (+rb . (al cl dl bl ah ch dh bh))
+     (+rw . (ax cx dx bx sp bp si di))
+     (+rd . (eax ecx edx ebx esp ebp esi edi))
+     (+rq . (rax rcx rdx rbx rsp rbp rsi rdi))))
+(setq! x86/registers-+reg-extended
+  '( (+rw . (r8b r9b r10b r11b r12b r13b r14b r15b))
+     (+rw . (r8w r9w r10w r11w r12w r13w r14w r15w))
+     (+rd . (r8d r9d r10d r11d r12d r13d r14d r15d))
+     (+rq . (r8 r9 r10 r11 r12 r13 r14 r15))))
+(defun! x86/generate-handlers-opcode-+reg (opbase extraops addends & args)
+  "Generate handlers for a family of opcodes that uses the +reg encoding.
+OPBASE is the base opcode.
+EXTRAOPS are additional operands after the register operand.
+ADDENDS is a list of symbols like +rw, +rq etc. that denote allowed registers.
+ARGS are passed verbatim to `u/x86/default-instruction-handler."
+  (list/map
+    (lambda (it)
+      (let ( (abase (list/map (lambda (a) (list/nth it (alist/get a x86/registers-+reg-base))) addends))
+             (aext (list/map (lambda (a) (list/nth it (alist/get a x86/registers-+reg-extended))) addends)))
+        (cons
+          (cons (list/append abase aext) extraops)
+          (apply 'x86/default-instruction-handler (cons (+ opbase it) args)))))
+    (list/iota 8)))
+
+(setq!
+  x86/mnemonic-table
+  (list
+    (cons 'add (x86/generate-handlers-arith 0x00 0))
+    (cons 'or  (x86/generate-handlers-arith 0x08 1))
+    (cons 'adc (x86/generate-handlers-arith 0x10 2))
+    (cons 'sbb (x86/generate-handlers-arith 0x18 3))
+    (cons 'and (x86/generate-handlers-arith 0x20 4))
+    (cons 'sub (x86/generate-handlers-arith 0x28 5))
+    (cons 'xor (x86/generate-handlers-arith 0x30 6))
+    (cons 'cmp (x86/generate-handlers-arith 0x38 7))
+    (cons 'push
+      (x86/generate-handlers-opcode-+reg 0x50 '() '(+rw +rq) 
+        :default-size 8
+        :posthook (lambda (ins ops) (x86/ins/set-rex-b! ins (x86/register-extended? (car ops))))))
+    (cons 'pop
+      (x86/generate-handlers-opcode-+reg 0x58 '() '(+rw +rq)
+        :default-size 8
+        :posthook (lambda (ins ops) (x86/ins/set-rex-b! ins (x86/register-extended? (car ops))))))
+    (list 'jo
+      (cons '("Jb") (x86/instruction-handler-jcc 0x70 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x80) 4)))
+    (list 'jno
+      (cons '("Jb") (x86/instruction-handler-jcc 0x71 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x81) 4)))
+    (list 'jb
+      (cons '("Jb") (x86/instruction-handler-jcc 0x72 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x82) 4)))
+    (list 'jnb
+      (cons '("Jb") (x86/instruction-handler-jcc 0x73 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x83) 4)))
+    (list 'jz
+      (cons '("Jb") (x86/instruction-handler-jcc 0x74 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x84) 4)))
+    (list 'jnz
+      (cons '("Jb") (x86/instruction-handler-jcc 0x75 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x85) 4)))
+    (list 'jbe
+      (cons '("Jb") (x86/instruction-handler-jcc 0x76 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x86) 4)))
+    (list 'jnbe
+      (cons '("Jb") (x86/instruction-handler-jcc 0x77 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x87) 4)))
+    (list 'js
+      (cons '("Jb") (x86/instruction-handler-jcc 0x78 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x88) 4)))
+    (list 'jns
+      (cons '("Jb") (x86/instruction-handler-jcc 0x79 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x89) 4)))
+    (list 'jp
+      (cons '("Jb") (x86/instruction-handler-jcc 0x7a 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x8a) 4)))
+    (list 'jnp
+      (cons '("Jb") (x86/instruction-handler-jcc 0x7b 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x8b) 4)))
+    (list 'jl
+      (cons '("Jb") (x86/instruction-handler-jcc 0x7c 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x8c) 4)))
+    (list 'jnl
+      (cons '("Jb") (x86/instruction-handler-jcc 0x7d 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x8d) 4)))
+    (list 'jle
+      (cons '("Jb") (x86/instruction-handler-jcc 0x7e 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x8e) 4)))
+    (list 'jnle
+      (cons '("Jb") (x86/instruction-handler-jcc 0x7f 1))
+      (cons '("Jz") (x86/instruction-handler-jcc '(0x0f 0x8f) 4)))
+    (cons 'mov
+      (list/append
+        (x86/generate-handlers-opcode-+reg 0xb0 '("Ib") '(+rb)
+          :posthook (lambda (ins ops) (x86/ins/set-rex-b! ins (x86/register-extended? (car ops)))))
+        (x86/generate-handlers-opcode-+reg 0xb8 '("Iv") '(+rw +rd +rq)
+          :posthook (lambda (ins ops) (x86/ins/set-rex-b! ins (x86/register-extended? (car ops)))))))
+    (list 'jmp
+      (cons '("Ev")
+        (x86/default-instruction-handler 0xff
+          :default-size 8
+          :posthook (lambda (ins _) (setf (u/x86/ins-modrm-reg ins) 4)))))
+    (list 'syscall
+      (cons '() (lambda (_ _) (x86/ins/new :opcode '(0x0f 0x05)))))
+    ))
+
+(defun! x86/asm (op)
+  "Assemble OP to an instruction."
+  (let ((mnem (car op)) (operands (cdr op)))
+    (let ((variants (or (alist/get mnem x86/mnemonic-table) (error! "unknown mnemonic"))))
+      (let ((v
+              (list/find
+                (lambda (it)
+                  (and (eq? (list/len (car it)) (list/len operands))
+                    (list/all? (lambda (x) x) (list/zip-with 'x86/operand-match? (car it) operands))))
+                variants)))
+        (if (and v (function? (cdr v)))
+          (funcall (cdr v) (car v) operands)
+          (error! "could not identify instruction"))))))
+
+(defun! x86/assemble (elf addr inss)
+  (print! inss)
+  (if inss
+    (let ((ins (x86/asm (car inss))))
+      (let ((bs (x86/ins-bytes ins)))
+        (elf/write-bytes! elf addr bs)
+        (x86/assemble elf (+ addr (list/len bs)) (cdr inss))))
+    addr))
+
+(let ( (elf (elf/new!))
+       (entrypoint 0x696000)
+       (toff 0x1000)
+       (phdroff 0x2000))
+  ;; (elf/write-bytes! elf toff
+  ;;   '( 0xb8 0x3c 0x00 0x00 0x00 ;; mov rax, 60
+  ;;      0xbf 0x2a 0x00 0x00 0x00 ;; mov rdi, 42
+  ;;      0x0f 0x05 ;; syscall
+  ;;      ))
+  (x86/assemble elf toff
+    '( (mov eax 60)
+       (mov edi 42)
+       (syscall)))
+  (elf/write-program-header! elf (+ phdroff elf/64_PROGRAM_HEADER_SIZE)
+    :type elf/PROGRAM_HEADER_TYPE_LOAD
+    :offset toff
+    :virtual-addr entrypoint
+    :file-size 0x100
+    :mem-size 0x100
+    :flags (bitwise/or elf/PROGRAM_HEADER_FLAG_R elf/PROGRAM_HEADER_FLAG_X)
+    )
+  (elf/write-header! elf
+    :type elf/TYPE_EXEC
+    :machine elf/MACHINE_AMD64
+    :program-header-offset phdroff
+    :program-header-entry-size elf/64_PROGRAM_HEADER_SIZE
+    :program-header-entries 2
+    :section-header-offset 0
+    :section-header-entry-size elf/64_SECTION_HEADER_SIZE
+    :section-header-entries 0
+    :entry entrypoint
+    )
+  (elf/spit! "test.elf" elf))
diff --git a/asm/packages.nix b/asm/packages.nix
new file mode 100644
index 0000000..75154ae
--- /dev/null
+++ b/asm/packages.nix
@@ -0,0 +1,16 @@
+pkgs: lcq: {
+  native = pkgs.pkgsMusl.stdenv.mkDerivation {
+    pname = "libcolonq-asm";
+    version = "git";
+    src = ./.;
+    hardeningDisable = ["all"];
+    buildInputs = [
+      lcq.prelude.native
+      lcq.pit.native
+      lcq.elf.native
+    ];
+    installPhase = ''
+      make prefix=$out install
+    '';
+  };
+}
diff --git a/asm/src/library.c b/asm/src/library.c
new file mode 100644
index 0000000..c1342f9
--- /dev/null
+++ b/asm/src/library.c
@@ -0,0 +1,302 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <lcq/pit.h>
+#include <lcq/elf.h>
+
+#include <lcq/asm/library.h>
+
+struct elf_builder {
+    i64 cap;
+    elf_ctx ctx;
+};
+
+static void builder_ensure_size(struct elf_builder *e, i64 sz) {
+    i64 cur = e->ctx.len;
+    i64 cap = e->cap;
+    if (sz <= cur) return;
+    while (cap < sz) cap <<= 1;
+    e->ctx.buf = realloc(e->ctx.buf, (size_t) cap);
+    memset(e->ctx.buf + e->cap, 0, (size_t) (cap - e->cap));
+    e->ctx.len = sz;
+    e->cap = cap;
+}
+
+static i64 get_kwargs_i64(pit_runtime *rt, i64 def, pit_value kwargs, char *kw) {
+    pit_value v = pit_value_list_plist_get(rt, pit_symtab_intern_cstr(rt, kw), kwargs);
+    if (v != PIT_NIL && pit_value_is_integer(rt, v)) {
+        return pit_value_as_integer(rt, v);
+    } else {
+        return def;
+    }
+}
+static pit_value impl_elf_new(pit_runtime *rt, pit_value kwargs, void *data) {
+    (void) data;
+    i64 vclass = get_kwargs_i64(rt, ELF_CLASS_64, kwargs, ":class");
+    i64 vendianness = get_kwargs_i64(rt, ELF_ENDIANNESS_LITTLE, kwargs, ":endianness");
+    struct elf_builder *ret = malloc(sizeof(struct elf_builder));
+    i64 len = 256;
+    u8 *buf = calloc((size_t) len, 1);
+    ret->cap = len;
+    ret->ctx = elf_ctx_new(buf, len, vclass, vendianness);
+    return pit_value_nativedata_new(rt, pit_symtab_intern_cstr(rt, "elf"), (void *) ret);
+}
+static pit_value impl_elf_write_header(pit_runtime *rt, pit_value args, void *data) {
+    (void) data;
+    pit_value velf = pit_value_cons_car(rt, args);
+    pit_value kwargs = pit_value_cons_cdr(rt, args);
+    struct elf_builder *e = pit_value_nativedata_get(rt, pit_symtab_intern_cstr(rt, "elf"), velf);
+    elf_header h = {0};
+    if (!e) return PIT_NIL;
+    builder_ensure_size(e, elf_header_size(&e->ctx));
+    h.type = get_kwargs_i64(rt, ELF_TYPE_EXEC, kwargs, ":type");
+    h.machine = get_kwargs_i64(rt, ELF_MACHINE_AMD64, kwargs, ":machine");
+    h.version = (u32) get_kwargs_i64(rt, 1, kwargs, ":version");
+    h.entry = (u64) get_kwargs_i64(rt, 0x401000, kwargs, ":entry");
+    h.program_header_offset = (u64) get_kwargs_i64(rt, 0, kwargs, ":program-header-offset");
+    h.program_header_entry_size = (u16) get_kwargs_i64(rt, elf_program_header_size(&e->ctx), kwargs, ":program-header-entry-size");
+    h.program_header_entries = (u16) get_kwargs_i64(rt, 1, kwargs, ":program-header-entries");
+    h.section_header_offset = (u64) get_kwargs_i64(rt, 0, kwargs, ":section-header-offset");
+    h.section_header_entry_size = (u16) get_kwargs_i64(rt, elf_section_header_size(&e->ctx), kwargs, ":section-header-entry-size");
+    h.section_header_entries = (u16) get_kwargs_i64(rt, 0, kwargs, ":section-header-entries");
+    h.section_name_table_index = (u16) get_kwargs_i64(rt, 1, kwargs, ":section-name-table-index");
+    elf_write_header(&h, &e->ctx);
+    return PIT_NIL;
+}
+static pit_value impl_elf_write_section_header(pit_runtime *rt, pit_value args, void *data) {
+    (void) data;
+    pit_value velf = pit_value_cons_car(rt, args);
+    pit_value voff = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    i64 off = pit_value_as_integer(rt, voff);
+    pit_value kwargs = pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args));
+    struct elf_builder *e = pit_value_nativedata_get(rt, pit_symtab_intern_cstr(rt, "elf"), velf);
+    elf_section_header h = {0};
+    if (!e) return PIT_NIL;
+    if (off < 0) { pit_error(rt, "negative offset: %d", off); return PIT_NIL; }
+    builder_ensure_size(e, off + elf_header_size(&e->ctx));
+    h.name_index = (u32) get_kwargs_i64(rt, 0, kwargs, ":name-index");
+    h.type = (u32) get_kwargs_i64(rt, ELF_SECTION_TYPE_NULL, kwargs, ":type");
+    h.flags = (u64) get_kwargs_i64(rt, 0, kwargs, ":flags");
+    h.addr = (u64) get_kwargs_i64(rt, 0, kwargs, ":addr");
+    h.offset = (u64) get_kwargs_i64(rt, 0, kwargs, ":offset");
+    h.size = (u64) get_kwargs_i64(rt, 0, kwargs, ":size");
+    h.link = (u32) get_kwargs_i64(rt, 0, kwargs, ":link");
+    h.info = (u32) get_kwargs_i64(rt, 0, kwargs, ":info");
+    h.addr_alignment = (u64) get_kwargs_i64(rt, 0, kwargs, ":addr-alignment");
+    h.entry_size = (u64) get_kwargs_i64(rt, 0, kwargs, ":entry-size");
+    elf_write_section_header(&h, &e->ctx, (u64) off);
+    return PIT_NIL;
+}
+static pit_value impl_elf_write_symbol(pit_runtime *rt, pit_value args, void *data) {
+    (void) data;
+    pit_value velf = pit_value_cons_car(rt, args);
+    pit_value voff = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    i64 off = pit_value_as_integer(rt, voff);
+    pit_value kwargs = pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args));
+    elf_symbol h = {0};
+    struct elf_builder *e = pit_value_nativedata_get(rt, pit_symtab_intern_cstr(rt, "elf"), velf);
+    if (!e) return PIT_NIL;
+    if (off < 0) { pit_error(rt, "negative offset: %d", off); return PIT_NIL; }
+    builder_ensure_size(e, off + elf_symbol_size(&e->ctx));
+    h.size = (u64) get_kwargs_i64(rt, 0, kwargs, ":size");
+    h.value = (u64) get_kwargs_i64(rt, 0, kwargs, ":value");
+    h.name_index = (u32) get_kwargs_i64(rt, 0, kwargs, ":name_index");
+    h.bind = get_kwargs_i64(rt, ELF_SYMBOL_BINDING_LOCAL, kwargs, ":bind");
+    h.type = get_kwargs_i64(rt, ELF_SYMBOL_TYPE_NOTYPE, kwargs, ":type");
+    h.visibility = get_kwargs_i64(rt, ELF_SYMBOL_VISIBILITY_DEFAULT, kwargs, ":visibility");
+    h.section_header_index = (u16) get_kwargs_i64(rt, 0, kwargs, ":section-header-index");
+    elf_write_symbol(&h, &e->ctx, (u64) off);
+    return PIT_NIL;
+}
+static pit_value impl_elf_write_program_header(pit_runtime *rt, pit_value args, void *data) {
+    (void) data;
+    pit_value velf = pit_value_cons_car(rt, args);
+    pit_value voff = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    i64 off = pit_value_as_integer(rt, voff);
+    pit_value kwargs = pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args));
+    elf_program_header h = {0};
+    struct elf_builder *e = pit_value_nativedata_get(rt, pit_symtab_intern_cstr(rt, "elf"), velf);
+    if (!e) return PIT_NIL;
+    if (off < 0) { pit_error(rt, "negative offset: %d", off); return PIT_NIL; }
+    builder_ensure_size(e, off + elf_program_header_size(&e->ctx));
+    h.type = (u32) get_kwargs_i64(rt, ELF_PROGRAM_HEADER_TYPE_NULL, kwargs, ":type");
+    h.offset = (u64) get_kwargs_i64(rt, 0, kwargs, ":offset");
+    h.virtual_addr = (u64) get_kwargs_i64(rt, 0, kwargs, ":virtual-addr");
+    h.physical_addr = (u64) get_kwargs_i64(rt, 0, kwargs, ":physical-addr");
+    h.file_size = (u64) get_kwargs_i64(rt, 0, kwargs, ":file-size");
+    h.mem_size = (u64) get_kwargs_i64(rt, 0, kwargs, ":mem-size");
+    h.flags = (u32) get_kwargs_i64(rt, 0, kwargs, ":flags");
+    h.align = (u64) get_kwargs_i64(rt, 0, kwargs, ":align");
+    elf_write_program_header(&h, &e->ctx, (u64) off);
+    return PIT_NIL;
+}
+static pit_value impl_elf_write_bytes(pit_runtime *rt, pit_value args, void *data) {
+    (void) data;
+    pit_value velf = pit_value_cons_car(rt, args);
+    pit_value voff = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    pit_value vbytes = pit_value_cons_car(rt, pit_value_cons_cdr(rt, pit_value_cons_cdr(rt, args)));
+    pit_value_heavy *hbytes = NULL;
+    i64 off = 0;
+    struct elf_builder *e = pit_value_nativedata_get(rt, pit_symtab_intern_cstr(rt, "elf"), velf);
+    if (!e) return PIT_NIL;
+    if (!pit_value_is_integer(rt, voff)) {
+        pit_error(rt, "offset is not integer");
+        return PIT_NIL;
+    }
+    off = pit_value_as_integer(rt, voff);
+    if (off < 0) {
+        pit_error(rt, "negative offset");
+        return PIT_NIL;
+    }
+    if (pit_value_is_bytes(rt, vbytes)) {
+        if (pit_value_sort(vbytes) != PIT_VALUE_SORT_REF) {
+            pit_error(rt, "bytes are not a reference");
+            return PIT_NIL;
+        }
+        hbytes = pit_value_ref_deref(rt, pit_value_as_ref(rt, vbytes));
+        if (!hbytes) { pit_error(rt, "bad ref"); return PIT_NIL; }
+        if (hbytes->hsort != PIT_VALUE_HEAVY_SORT_BYTES) {
+            pit_error(rt, "invalid use of value as bytes");
+            return PIT_NIL;
+        }
+        builder_ensure_size(e, off + hbytes->in.bytes.len);
+        elf_write_bytes(&e->ctx, (u64 *) &off, hbytes->in.bytes.data, hbytes->in.bytes.len);
+    } else if (pit_value_is_cons(rt, vbytes)) {
+        while (vbytes != PIT_NIL) {
+            pit_value x = pit_value_cons_car(rt, vbytes);
+            i64 v = 0;
+            u8 byte = 0;
+            if (!pit_value_is_integer(rt, x)) {
+                pit_error(rt, "byte is not integer");
+                return PIT_NIL;
+            }
+            v = pit_value_as_integer(rt, x);
+            if (v < 0 || v > 255) {
+                pit_error(rt, "byte out of range");
+                return PIT_NIL;
+            }
+            byte = (u8) v;
+            builder_ensure_size(e, off + 1);
+            if (elf_write_bytes(&e->ctx, (u64 *) &off, (u8 *) &byte, 1) < 0) {
+                pit_error(rt, "failed to write byte at offset: %ld\n", off);
+                return PIT_NIL;
+            }
+            vbytes = pit_value_cons_cdr(rt, vbytes);
+        }
+    }
+    return PIT_T;
+}
+static pit_value impl_elf_spit(pit_runtime *rt, pit_value args, void *data) {
+    (void) data;
+    char pathbuf[1024] = {0};
+    i64 len = 0, actual = 0;
+    FILE *f = NULL;
+    struct elf_builder *e = NULL;
+    pit_value path = pit_value_cons_car(rt, args);
+    pit_value velf = pit_value_cons_car(rt, pit_value_cons_cdr(rt, args));
+    len = pit_value_bytes_copy(rt, path, (u8 *) pathbuf, sizeof(pathbuf) - 1);
+    if (len < 0) { pit_error(rt, "path was not a string"); return PIT_NIL; }
+    pathbuf[len] = 0;
+    e = pit_value_nativedata_get(rt, pit_symtab_intern_cstr(rt, "elf"), velf);
+    if (!e) return PIT_NIL;
+    f = fopen(pathbuf, "w+");
+    if (!f) {
+        pit_error(rt, "failed to open file: %s", pathbuf);
+        return PIT_NIL;
+    }
+    actual = (i64) fwrite(e->ctx.buf, 1, (size_t) e->ctx.len, f);
+    fclose(f);
+    if (e->ctx.len != actual) {
+        pit_error(rt, "failed to write ELF file");
+        return PIT_NIL;
+    }
+    return velf;
+}
+
+void asm_install_library_elf(pit_runtime *rt) {
+    /* sizes */
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/HEADER_IDENT_SIZE"), pit_value_integer_new(rt, ELF_HEADER_IDENT_SIZE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/32_HEADER_SIZE"), pit_value_integer_new(rt, ELF32_HEADER_SIZE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/64_HEADER_SIZE"), pit_value_integer_new(rt, ELF64_HEADER_SIZE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/32_SECTION_HEADER_SIZE"), pit_value_integer_new(rt, ELF32_SECTION_HEADER_SIZE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/64_SECTION_HEADER_SIZE"), pit_value_integer_new(rt, ELF64_SECTION_HEADER_SIZE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/32_PROGRAM_HEADER_SIZE"), pit_value_integer_new(rt, ELF32_PROGRAM_HEADER_SIZE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/64_PROGRAM_HEADER_SIZE"), pit_value_integer_new(rt, ELF64_PROGRAM_HEADER_SIZE));
+    /* enums */
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/CLASS_INVALID"), pit_value_integer_new(rt, ELF_CLASS_INVALID));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/CLASS_32"), pit_value_integer_new(rt, ELF_CLASS_32));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/CLASS_64"), pit_value_integer_new(rt, ELF_CLASS_64));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/ENDIANNESS_INVALID"), pit_value_integer_new(rt, ELF_ENDIANNESS_INVALID));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/ENDIANNESS_LITTLE"), pit_value_integer_new(rt, ELF_ENDIANNESS_LITTLE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/ENDIANNESS_BIG"), pit_value_integer_new(rt, ELF_ENDIANNESS_BIG));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/TYPE_NONE"), pit_value_integer_new(rt, ELF_TYPE_NONE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/TYPE_REL"), pit_value_integer_new(rt, ELF_TYPE_REL));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/TYPE_EXEC"), pit_value_integer_new(rt, ELF_TYPE_EXEC));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/TYPE_DYN"), pit_value_integer_new(rt, ELF_TYPE_DYN));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/TYPE_CORE"), pit_value_integer_new(rt, ELF_TYPE_CORE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/MACHINE_NONE"), pit_value_integer_new(rt, ELF_MACHINE_NONE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/MACHINE_X86"), pit_value_integer_new(rt, ELF_MACHINE_X86));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/MACHINE_AMD64"), pit_value_integer_new(rt, ELF_MACHINE_AMD64));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_NULL"), pit_value_integer_new(rt, ELF_SECTION_TYPE_NULL));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_PROGBITS"), pit_value_integer_new(rt, ELF_SECTION_TYPE_PROGBITS));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_SYMTAB"), pit_value_integer_new(rt, ELF_SECTION_TYPE_SYMTAB));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_STRTAB"), pit_value_integer_new(rt, ELF_SECTION_TYPE_STRTAB));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_RELA"), pit_value_integer_new(rt, ELF_SECTION_TYPE_RELA));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_HASH"), pit_value_integer_new(rt, ELF_SECTION_TYPE_HASH));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_DYNAMIC"), pit_value_integer_new(rt, ELF_SECTION_TYPE_DYNAMIC));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_NOTE"), pit_value_integer_new(rt, ELF_SECTION_TYPE_NOTE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_NOBITS"), pit_value_integer_new(rt, ELF_SECTION_TYPE_NOBITS));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_REL"), pit_value_integer_new(rt, ELF_SECTION_TYPE_REL));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_SHLIB"), pit_value_integer_new(rt, ELF_SECTION_TYPE_SHLIB));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_DYNSYM"), pit_value_integer_new(rt, ELF_SECTION_TYPE_DYNSYM));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_INIT_ARRAY"), pit_value_integer_new(rt, ELF_SECTION_TYPE_INIT_ARRAY));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_FINI_ARRAY"), pit_value_integer_new(rt, ELF_SECTION_TYPE_FINI_ARRAY));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_PREINIT_ARRAY"), pit_value_integer_new(rt, ELF_SECTION_TYPE_PREINIT_ARRAY));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_GROUP"), pit_value_integer_new(rt, ELF_SECTION_TYPE_GROUP));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_TYPE_SYMTAB_SHNDX"), pit_value_integer_new(rt, ELF_SECTION_TYPE_SYMTAB_SHNDX));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_WRITE"), pit_value_integer_new(rt, ELF_SECTION_FLAG_WRITE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_ALLOC"), pit_value_integer_new(rt, ELF_SECTION_FLAG_ALLOC));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_EXECINSTR"), pit_value_integer_new(rt, ELF_SECTION_FLAG_EXECINSTR));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_MERGE"), pit_value_integer_new(rt, ELF_SECTION_FLAG_MERGE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_STRINGS"), pit_value_integer_new(rt, ELF_SECTION_FLAG_STRINGS));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_INFO_LINK"), pit_value_integer_new(rt, ELF_SECTION_FLAG_INFO_LINK));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_LINK_ORDER"), pit_value_integer_new(rt, ELF_SECTION_FLAG_LINK_ORDER));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_OS_NONCOMFORMING"), pit_value_integer_new(rt, ELF_SECTION_FLAG_OS_NONCOMFORMING));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_GROUP"), pit_value_integer_new(rt, ELF_SECTION_FLAG_GROUP));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_TLS"), pit_value_integer_new(rt, ELF_SECTION_FLAG_TLS));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SECTION_FLAG_COMPRESSED"), pit_value_integer_new(rt, ELF_SECTION_FLAG_COMPRESSED));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_BINDING_LOCAL"), pit_value_integer_new(rt, ELF_SYMBOL_BINDING_LOCAL));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_BINDING_GLOBAL"), pit_value_integer_new(rt, ELF_SYMBOL_BINDING_GLOBAL));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_BINDING_WEAK"), pit_value_integer_new(rt, ELF_SYMBOL_BINDING_WEAK));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_TYPE_NOTYPE"), pit_value_integer_new(rt, ELF_SYMBOL_TYPE_NOTYPE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_TYPE_OBJECT"), pit_value_integer_new(rt, ELF_SYMBOL_TYPE_OBJECT));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_TYPE_FUNC"), pit_value_integer_new(rt, ELF_SYMBOL_TYPE_FUNC));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_TYPE_SECTION"), pit_value_integer_new(rt, ELF_SYMBOL_TYPE_SECTION));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_TYPE_FILE"), pit_value_integer_new(rt, ELF_SYMBOL_TYPE_FILE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_TYPE_COMMON"), pit_value_integer_new(rt, ELF_SYMBOL_TYPE_COMMON));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_TYPE_TLS"), pit_value_integer_new(rt, ELF_SYMBOL_TYPE_TLS));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_VISIBILITY_DEFAULT"), pit_value_integer_new(rt, ELF_SYMBOL_VISIBILITY_DEFAULT));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_VISIBILITY_INTERNAL"), pit_value_integer_new(rt, ELF_SYMBOL_VISIBILITY_INTERNAL));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_VISIBILITY_HIDDEN"), pit_value_integer_new(rt, ELF_SYMBOL_VISIBILITY_HIDDEN));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/SYMBOL_VISIBILITY_PROTECTED"), pit_value_integer_new(rt, ELF_SYMBOL_VISIBILITY_PROTECTED));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_TYPE_NULL"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_TYPE_NULL));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_TYPE_LOAD"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_TYPE_LOAD));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_TYPE_DYNAMIC"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_TYPE_DYNAMIC));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_TYPE_INTERP"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_TYPE_INTERP));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_TYPE_NOTE"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_TYPE_NOTE));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_TYPE_SHLIB"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_TYPE_SHLIB));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_TYPE_PHDR"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_TYPE_PHDR));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_TYPE_TLS"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_TYPE_TLS));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_FLAG_X"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_FLAG_X));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_FLAG_W"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_FLAG_W));
+    pit_symtab_set(rt, pit_symtab_intern_cstr(rt, "elf/PROGRAM_HEADER_FLAG_R"), pit_value_integer_new(rt, ELF_PROGRAM_HEADER_FLAG_R));
+
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "elf/new!"), pit_value_nativefunc_new(rt, impl_elf_new));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "elf/write-header!"), pit_value_nativefunc_new(rt, impl_elf_write_header));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "elf/write-section-header!"), pit_value_nativefunc_new(rt, impl_elf_write_section_header));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "elf/write-symbol!"), pit_value_nativefunc_new(rt, impl_elf_write_symbol));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "elf/write-program-header!"), pit_value_nativefunc_new(rt, impl_elf_write_program_header));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "elf/write-bytes!"), pit_value_nativefunc_new(rt, impl_elf_write_bytes));
+    pit_symtab_fset(rt, pit_symtab_intern_cstr(rt, "elf/spit!"), pit_value_nativefunc_new(rt, impl_elf_spit));
+}
diff --git a/asm/src/main.c b/asm/src/main.c
new file mode 100644
index 0000000..2d25274
--- /dev/null
+++ b/asm/src/main.c
@@ -0,0 +1,24 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <lcq/pit.h>
+
+#include <lcq/asm/library.h>
+
+int main(int argc, char **argv) {
+    i64 sz = 256 * 1024 * 1024;
+    u8 *buf = malloc((size_t) sz);
+    pit_runtime *rt = pit_runtime_new(buf, sz);
+    rt->fuel = 10000000;
+    pit_install_library_essential(rt);
+    pit_install_library_io(rt);
+    pit_install_library_plist(rt);
+    pit_install_library_alist(rt);
+    pit_install_library_bytestring(rt);
+    asm_install_library_elf(rt);
+    if (argc < 2) {
+        pit_repl(rt);
+    } else {
+        pit_load_file(rt, argv[1]);
+    }
+}
diff --git a/asm/x86_64.pdf b/asm/x86_64.pdf
new file mode 100644
index 0000000..24fa420
--- /dev/null
+++ b/asm/x86_64.pdf