Implemented code pointers on arm64

docs/readme.md

@@ -1,35 +1,67 @@
 # q
 
-A programming language that compiles down to machine code.
+A programming language that quickly compiles to machine code.
 
-## Features
+## Goals
 
 - Fast compilation
 - High performance
 - Small executables
+- Zero dependencies
 
 ## Installation
 
 ```shell
-git clone https://git.akyoto.dev/cli/q
+git clone https://git.urbach.dev/cli/q
 cd q
 go build
 ```
 
+Either use `./q` from the build directory or get access to the shorter `q` in any directory with `ln -s $PWD/q ~/.local/bin/q`.
+
 ## Usage
 
 ```shell
-./q run examples/hello
+q run examples/hello
 ```
 
-Builds an executable from `examples/hello` and runs it.
+You can take a look at the [examples](../examples).
 
-## Links
+## Tests
 
-- [Chat](https://matrix.to/#/#community:akyoto.dev)
-- [Donate](https://buy.stripe.com/4gw7vf5Jxflf83m7st)
-- [License](https://akyoto.dev/license)
-- [Todo](todo.md)
+```shell
+go run gotest.tools/gotestsum@latest
+```
+
+This will run over 400 [tests](../tests) in various categories.
+
+## Platforms
+
+You can cross-compile executables for Linux, Mac and Windows.
+
+```shell
+q build examples/hello --os linux
+q build examples/hello --os mac
+q build examples/hello --os windows
+```
+
+Or with different architectures:
+
+```shell
+q build examples/hello --arch x86
+q build examples/hello --arch arm
+```
+
+## Status
+
+`q` is under heavy development and not ready for production yet.
+Feel free to [get in touch](https://urbach.dev/contact) if you are interested in helping out.
+
+The biggest obstacle right now is the lack of funding. You can help by donating via [Kofi](https://ko-fi.com/akyoto) or [Open Collective](https://opencollective.com/qlang).
+
+## License
+
+Please see the [license documentation](https://urbach.dev/license).
 
 ## Copyright
 

docs/todo.md

@@ -17,20 +17,28 @@
 - [x] Hexadecimal, octal and binary literals
 - [x] Escape sequences
 - [x] Multiple return values
-- [ ] Type system
+- [x] Data structures
+- [x] Type system
+- [ ] Dynamic libraries: Linux Mac ~~Windows~~
+- [ ] Unsigned types
 - [ ] Type operator `?`
-- [ ] Data structures
 - [ ] Slices
 - [ ] Floating-point arithmetic
-- [ ] Error handling
-- [ ] Threading library
 - [ ] Self-hosted compiler
 
+### Library
+
+- [ ] Efficient memory allocator
+- [ ] Error handling
+- [ ] Multithreading: ~~Linux~~ Mac ~~Windows~~
+
 ### Keywords
 
 - [x] `assert`
+- [x] `const`
 - [x] `else`
-- [ ] `for`
+- [x] `extern`
+- [x] `for`
 - [x] `if`
 - [x] `import`
 - [x] `loop`
@@ -41,6 +49,7 @@
 
 - [x] Exclude unused functions
 - [x] Constant folding
+- [ ] SSA form
 - [ ] Constant propagation
 - [ ] Function call inlining
 - [ ] Loop unrolls
@@ -69,12 +78,12 @@
 
 ### Architecture
 
-- [ ] arm64
+- [ ] arm
 - [ ] riscv
-- [x] x64
+- [x] x86
 
 ### Platform
 
 - [x] Linux
 - [x] Mac
-- [ ] Windows
+- [x] Windows

examples/array/array.q

@@ -1,14 +1,13 @@
+import io
 import mem
-import sys
 
 main() {
-	length := 5
-	address := mem.alloc(length)
-	address[0] = 'H'
-	address[1] = 'e'
-	address[2] = 'l'
-	address[3] = 'l'
-	address[4] = 'o'
-	sys.write(1, address, length)
-	mem.free(address, length)
+	buffer := mem.alloc(5)
+	buffer[0] = 'H'
+	buffer[1] = 'e'
+	buffer[2] = 'l'
+	buffer[3] = 'l'
+	buffer[4] = 'o'
+	io.write(buffer)
+	mem.free(buffer)
 }

examples/collatz/collatz.q

@@ -1,11 +1,11 @@
-import log
-import sys
+import fmt
+import io
 
 main() {
 	collatz(12)
 }
 
-collatz(x Int) {
+collatz(x int) {
 	loop {
 		if x & 1 == 0 {
 			x /= 2
@@ -13,12 +13,12 @@ collatz(x Int) {
 			x = 3 * x + 1
 		}
 
-		log.number(x)
+		fmt.decimal(x)
 
 		if x == 1 {
 			return
 		}
 
-		sys.write(1, " ", 1)
+		io.write(" ")
 	}
 }

examples/echo/echo.q

@@ -9,7 +9,7 @@ main() {
 		n := sys.read(0, address, length)
 
 		if n <= 0 {
-			mem.free(address, length)
+			mem.free(address)
 			return
 		}
 

examples/factorial/factorial.q

@@ -1,10 +1,10 @@
-import log
+import fmt
 
 main() {
-	log.number(factorial(5))
+	fmt.decimal(factorial(5))
 }
 
-factorial(x Int) -> Int {
+factorial(x int) -> int {
 	if x <= 1 {
 		return 1
 	}

examples/fibonacci/fibonacci.q

@@ -1,10 +1,10 @@
-import log
+import fmt
 
 main() {
-	log.number(fibonacci(10))
+	fmt.decimal(fibonacci(10))
 }
 
-fibonacci(x Int) -> Int {
+fibonacci(x int) -> int {
 	if x <= 1 {
 		return x
 	}

examples/fizzbuzz/fizzbuzz.q

@@ -1,19 +1,19 @@
-import log
-import sys
+import fmt
+import io
 
 main() {
 	fizzbuzz(15)
 }
 
-fizzbuzz(n Int) {
+fizzbuzz(n int) {
 	x := 1
 
 	loop {
 		switch {
-			x % 15 == 0 { print("FizzBuzz", 8) }
-			x % 5 == 0  { print("Buzz", 4) }
-			x % 3 == 0  { print("Fizz", 4) }
-			_           { log.number(x) }
+			x % 15 == 0 { io.write("FizzBuzz") }
+			x % 5 == 0  { io.write("Buzz") }
+			x % 3 == 0  { io.write("Fizz") }
+			_           { fmt.decimal(x) }
 		}
 
 		x += 1
@@ -22,10 +22,6 @@ fizzbuzz(n Int) {
 			return
 		}
 
-		print(" ", 1)
+		io.write(" ")
 	}
-}
-
-print(address Pointer, length Int) {
-	sys.write(1, address, length)
 }

examples/gcd/gcd.q

@@ -1,10 +1,10 @@
-import log
+import fmt
 
 main() {
-	log.number(gcd(1071, 462))
+	fmt.decimal(gcd(1071, 462))
 }
 
-gcd(a Int, b Int) -> Int {
+gcd(a int, b int) -> int {
 	loop {
 		switch {
 			a == b { return a }

examples/hello/hello.q

@@ -1,9 +1,5 @@
-import sys
+import io
 
 main() {
-	print("Hello\n", 6)
-}
-
-print(address Pointer, length Int) {
-	sys.write(1, address, length)
+	io.write("Hello\n")
 }

examples/itoa/itoa.q

@@ -1,5 +1,5 @@
-import log
+import fmt
 
 main() {
-	log.number(9223372036854775807)
+	fmt.decimal(9223372036854775807)
 }

examples/point/point.q

@@ -1,9 +1,9 @@
+import io
 import mem
-import sys
 
-struct Point {
-	x Int
-	y Int
+Point {
+	x int
+	y int
 }
 
 main() {
@@ -12,7 +12,7 @@ main() {
 	delete(p)
 }
 
-construct(x Int, y Int) -> *Point {
+construct(x int, y int) -> *Point {
 	p := new(Point)
 	p.x = x
 	p.y = y
@@ -29,6 +29,6 @@ print(p *Point) {
 	out[5] = ' '
 	out[6] = '0' + p.y
 	out[7] = '\n'
-	sys.write(1, out, 8)
-	mem.free(out, 8)
+	io.write(out)
+	mem.free(out)
 }

examples/prime/prime.q

@@ -1,5 +1,5 @@
-import log
-import sys
+import fmt
+import io
 
 main() {
 	n := 100
@@ -10,36 +10,36 @@ main() {
 			return
 		}
 
-		if isPrime(i) == 1 {
+		if isPrime(i) {
 			if i != 2 {
-				sys.write(1, " ", 1)
+				io.write(" ")
 			}
 
-			log.number(i)
+			fmt.decimal(i)
 		}
 
 		i += 1
 	}
 }
 
-isPrime(x Int) -> Int {
+isPrime(x int) -> bool {
 	if x == 2 {
-		return 1
+		return true
 	}
 
 	if x % 2 == 0 {
-		return 0
+		return false
 	}
 
 	i := 3
 
 	loop {
 		if i * i > x {
-			return 1
+			return true
 		}
 
 		if x % i == 0 {
-			return 0
+			return false
 		}
 
 		i += 2

examples/readfile/readfile.q

@@ -0,0 +1,13 @@
+import fs
+import sys
+
+main() {
+	show("/proc/sys/kernel/ostype")
+	show("/proc/sys/kernel/osrelease")
+	show("/proc/sys/kernel/arch")
+}
+
+show(path []byte) {
+	contents, length := fs.readFile(path)
+	sys.write(1, contents, length)
+}

examples/server/server.q

@@ -0,0 +1,35 @@
+import io
+import net
+import sys
+
+main() {
+	socket := sys.socket(2, 1, 0)
+
+	if socket < 0 {
+		io.write("socket error\n")
+		sys.exit(1)
+	}
+
+	if net.bind(socket, 8080) != 0 {
+		io.write("bind error\n")
+		sys.exit(1)
+	}
+
+	if sys.listen(socket, 128) != 0 {
+		io.write("listen error\n")
+		sys.exit(1)
+	}
+
+	io.write("listening...\n")
+
+	loop {
+		conn := sys.accept(socket, 0, 0)
+
+		if conn >= 0 {
+			io.writeTo(conn, "HTTP/1.0 200 OK\r\nContent-Length: 6\r\n\r\nHello\n")
+			sys.close(conn)
+		} else {
+			io.write("accept error\n")
+		}
+	}
+}

examples/shell/const.q

@@ -0,0 +1,13 @@
+const {
+	idtype {
+		pid 1
+	}
+
+	sig {
+		chld 17
+	}
+
+	state {
+		exited 0x4
+	}
+}

examples/shell/shell.q

@@ -1,29 +1,27 @@
+import io
 import mem
 import sys
 
 main() {
 	length := 256
 	command := mem.alloc(length)
-	argv := mem.alloc(1)
-	envp := mem.alloc(1)
-	info := mem.alloc(24)
 
 	loop {
-		sys.write(1, "$ ", 2)
-		n := sys.read(0, command, length)
+		io.write("λ ")
+		n := io.read(command)
 
 		if n <= 0 {
 			return
 		}
 
-		command[n-1] = '\0'
-		pid := sys.fork()
+		command[n-1] = 0
+		pid := sys.clone(sig.chld, 0, 0, 0, 0)
 
 		if pid == 0 {
-			sys.execve(command, argv, envp)
+			sys.execve(command, 0, 0)
 			return
 		}
 
-		sys.waitid(0, pid, info, 4)
+		sys.waitid(idtype.pid, pid, 0, state.exited)
 	}
 }

examples/thread/thread.q

@@ -1,17 +1,15 @@
-import sys
+import io
 import thread
-import time
 
 main() {
-	thread.create(work)
-	thread.create(work)
-	thread.create(work)
+	for 0..3 {
+		thread.create(work)
+	}
+
 	work()
 }
 
 work() {
-	sys.write(1, "[ ] start\n", 10)
-	time.sleep(10 * 1000 * 1000)
-	sys.write(1, "[x] end\n", 8)
-	sys.exit(0)
+	io.write("[ ] start\n")
+	io.write("[x] end\n")
 }

examples/winapi/winapi.q

@@ -1,10 +1,11 @@
-import mem
-
 main() {
-	text := mem.alloc(4)
-	text[0] = 'H'
-	text[1] = 'i'
-	text[2] = '!'
-	user32.MessageBoxA(0, text, text, 0x00240040)
-	mem.free(text, 4)
+	title := "Title."
+	text := "Hi!"
+	user32.MessageBoxA(0, text, title, 0x240040)
+}
+
+extern {
+	user32 {
+		MessageBoxA(window *any, text *byte, title *byte, flags uint) -> int
+	}
 }

go.mod

@@ -1,10 +1,10 @@
-module git.akyoto.dev/cli/q
+module git.urbach.dev/cli/q
 
-go 1.23
+go 1.24
 
 require (
-	git.akyoto.dev/go/assert v0.1.3
-	git.akyoto.dev/go/color v0.1.1
+	git.urbach.dev/go/assert v0.0.0-20250225153414-fc1f84f19edf
+	git.urbach.dev/go/color v0.0.0-20250311132441-f75ff8da5a12
 )
 
-require golang.org/x/sys v0.29.0 // indirect
+require golang.org/x/sys v0.32.0 // indirect

go.sum

@@ -1,6 +1,6 @@
-git.akyoto.dev/go/assert v0.1.3 h1:QwCUbmG4aZYsNk/OuRBz1zWVKmGlDUHhOnnDBfn8Qw8=
-git.akyoto.dev/go/assert v0.1.3/go.mod h1:0GzMaM0eURuDwtGkJJkCsI7r2aUKr+5GmWNTFPgDocM=
-git.akyoto.dev/go/color v0.1.1 h1:mMAoMIwLBPNy7ocRSxdsCFs7onPC3GfDEiJErCneqRE=
-git.akyoto.dev/go/color v0.1.1/go.mod h1:ywOjoD0O0sk6bIn92uAJf7mErlEFCuQInL84y4Lqi3Q=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+git.urbach.dev/go/assert v0.0.0-20250225153414-fc1f84f19edf h1:BQWa5GKNUsA5CSUa/+UlFWYCEVe3IDDKRbVqBLK0mAE=
+git.urbach.dev/go/assert v0.0.0-20250225153414-fc1f84f19edf/go.mod h1:y9jGII9JFiF1HNIju0u87OyPCt82xKCtqnAFyEreCDo=
+git.urbach.dev/go/color v0.0.0-20250311132441-f75ff8da5a12 h1:DML0/oUE0lzX8wq/b2+JizZs/iYxeqxPCwT97LFhW+A=
+git.urbach.dev/go/color v0.0.0-20250311132441-f75ff8da5a12/go.mod h1:s6wrC+nGE0YMz9K3BBjHoGCKkDZTUKnGbL0BqgzZkC4=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

lib/core/core_linux_arm.q

@@ -0,0 +1,12 @@
+init() {
+	main.main()
+	exit()
+}
+
+exit() {
+	syscall(93, 0)
+}
+
+crash() {
+	syscall(93, 1)
+}

lib/core/core_linux_x86.q

@@ -0,0 +1,12 @@
+init() {
+	main.main()
+	exit()
+}
+
+exit() {
+	syscall(60, 0)
+}
+
+crash() {
+	syscall(60, 1)
+}

lib/core/core_mac.q

@@ -0,0 +1,12 @@
+init() {
+	main.main()
+	exit()
+}
+
+exit() {
+	syscall(0x2000001, 0)
+}
+
+crash() {
+	syscall(0x2000001, 1)
+}

lib/core/core_windows.q

@@ -0,0 +1,28 @@
+init() {
+	kernel32.SetConsoleCP(cp.utf8)
+	kernel32.SetConsoleOutputCP(cp.utf8)
+	main.main()
+	exit()
+}
+
+exit() {
+	kernel32.ExitProcess(0)
+}
+
+crash() {
+	kernel32.ExitProcess(1)
+}
+
+const {
+	cp {
+		utf8 65001
+	}
+}
+
+extern {
+	kernel32 {
+		SetConsoleCP(cp uint)
+		SetConsoleOutputCP(cp uint)
+		ExitProcess(code uint)
+	}
+}

lib/fmt/fmt.q

@@ -0,0 +1,25 @@
+import mem
+import sys
+
+decimal(x int) {
+	buffer := mem.alloc(20)
+	address, count := itoa(x, buffer)
+	sys.write(1, address, count)
+	mem.free(buffer)
+}
+
+itoa(x int, buffer []byte) -> (*byte, int) {
+	end := buffer + len(buffer)
+	tmp := end
+	digit := 0
+
+	loop {
+		x, digit = x / 10
+		tmp -= 1
+		tmp[0] = '0' + digit
+
+		if x == 0 {
+			return tmp, end - tmp
+		}
+	}
+}

lib/fs/fs.q

@@ -0,0 +1,27 @@
+import mem
+import sys
+
+readFile(path []byte) -> (*byte, int) {
+	stat := new(sys.file_stat)
+
+	if sys.stat(path, stat) < 0 {
+		return 0, 0
+	}
+
+	size := stat.st_size
+
+	if size < 512 {
+		size = 512
+	}
+
+	file := sys.open(path, 0, 0)
+
+	if file < 0 {
+		return 0, 0
+	}
+
+	contents := mem.alloc(size)
+	length := sys.read(file, contents, size)
+	sys.close(file)
+	return contents, length
+}

lib/io/io.q

@@ -0,0 +1,7 @@
+const {
+	std {
+		in 0
+		out 1
+		err 2
+	}
+}

lib/io/read.q

@@ -0,0 +1,9 @@
+import sys
+
+read(buffer []byte) -> int {
+	return sys.read(std.in, buffer, len(buffer))
+}
+
+readFrom(fd int, buffer []byte) -> int {
+	return sys.read(fd, buffer, len(buffer))
+}

lib/io/write.q

@@ -0,0 +1,9 @@
+import sys
+
+write(buffer []byte) -> int {
+	return sys.write(std.out, buffer, len(buffer))
+}
+
+writeTo(fd int, buffer []byte) -> int {
+	return sys.write(fd, buffer, len(buffer))
+}

lib/log/number.q

@@ -1,26 +0,0 @@
-import mem
-import sys
-
-number(x Int) {
-	length := 20
-	buffer := mem.alloc(length)
-	address, count := itoa(x, buffer, length)
-	sys.write(1, address, count)
-	mem.free(buffer, length)
-}
-
-itoa(x Int, buffer Pointer, length Int) -> (Pointer, Int) {
-	end := buffer + length
-	tmp := end
-	digit := 0
-
-	loop {
-		x, digit = x / 10
-		tmp -= 1
-		tmp[0] = '0' + digit
-
-		if x == 0 {
-			return tmp, end - tmp
-		}
-	}
-}

lib/math/math.q

@@ -0,0 +1,11 @@
+align2(x uint64) -> uint64 {
+	x -= 1
+	x |= x >> 1
+	x |= x >> 2
+	x |= x >> 4
+	x |= x >> 8
+	x |= x >> 16
+	x |= x >> 32
+	x += 1
+	return x
+}

lib/mem/alloc_linux.q

@@ -1,5 +0,0 @@
-import sys
-
-alloc(length Int) -> Pointer {
-	return sys.mmap(0, length, 0x1|0x2, 0x02|0x20)
-}

lib/mem/alloc_mac.q

@@ -1,5 +0,0 @@
-import sys
-
-alloc(length Int) -> Pointer {
-	return sys.mmap(0, length, 0x1|0x2, 0x02|0x1000)
-}

lib/mem/alloc_unix.q

@@ -0,0 +1,12 @@
+import sys
+
+alloc(length int) -> []byte {
+	x := sys.mmap(0, length+8, prot.read|prot.write, map.private|map.anonymous)
+
+	if x < 0x1000 {
+		return x
+	}
+
+	[x] = length
+	return x + 8
+}

lib/mem/alloc_windows.q

@@ -1,5 +1,16 @@
-import sys
+alloc(length int) -> []byte {
+	x := kernel32.VirtualAlloc(0, length+8, mem.commit|mem.reserve, page.readwrite)
 
-alloc(length Int) -> Pointer {
-	return sys.mmap(0, length, 0x0004, 0x3000)
+	if x < 0x1000 {
+		return x
+	}
+
+	[x] = length
+	return x + 8
+}
+
+extern {
+	kernel32 {
+		VirtualAlloc(address int, size uint, flags uint32, protection uint32) -> *any
+	}
 }

lib/mem/const_linux.q

@@ -0,0 +1,11 @@
+const {
+	prot {
+		read 0x1
+		write 0x2
+	}
+
+	map {
+		private 0x02
+		anonymous 0x20
+	}
+}

lib/mem/const_mac.q

@@ -0,0 +1,11 @@
+const {
+	prot {
+		read 0x1
+		write 0x2
+	}
+
+	map {
+		private 0x02
+		anonymous 0x1000
+	}
+}

lib/mem/const_windows.q

@@ -0,0 +1,11 @@
+const {
+	page {
+		readwrite 0x0004
+	}
+
+	mem {
+		commit 0x1000
+		reserve 0x2000
+		decommit 0x4000
+	}
+}

lib/mem/free.q

@@ -1,5 +0,0 @@
-import sys
-
-free(address Pointer, length Int) -> Int {
-	return sys.munmap(address, length)
-}

lib/mem/free_unix.q

@@ -0,0 +1,5 @@
+import sys
+
+free(address []any) {
+	sys.munmap(address-8, len(address)+8)
+}

lib/mem/free_windows.q

@@ -0,0 +1,9 @@
+free(address []any) {
+	kernel32.VirtualFree(address-8, len(address)+8, mem.decommit)
+}
+
+extern {
+	kernel32 {
+		VirtualFree(address *any, size uint, type uint32) -> bool
+	}
+}

lib/net/htons.q

@@ -0,0 +1,3 @@
+htons(num uint16) -> uint16 {
+	return ((num & 0xFF) << 8) | (num >> 8)
+}

lib/net/net_linux.q

@@ -0,0 +1,10 @@
+import sys
+
+bind(socket int, port uint16) -> int {
+	addr := new(sys.sockaddr_in)
+	addr.sin_family = 2
+	addr.sin_port = htons(port)
+	err := sys.bind(socket, addr, 20)
+	delete(addr)
+	return err
+}

lib/net/net_mac.q

@@ -0,0 +1,10 @@
+import sys
+
+bind(socket int, port uint16) -> int {
+	addr := new(sys.sockaddr_in_bsd)
+	addr.sin_family = 2
+	addr.sin_port = htons(port)
+	err := sys.bind(socket, addr, 16)
+	delete(addr)
+	return err
+}

lib/sys/struct_linux.q

@@ -0,0 +1,34 @@
+sockaddr_in {
+	sin_family int16
+	sin_port uint16
+	sin_addr int64
+	sin_zero int64
+}
+
+file_stat {
+	st_dev uint64
+	st_ino uint64
+	st_nlink uint64
+	st_mode uint32
+	st_uid uint32
+	st_gid uint32
+	_ uint32
+	st_rdev uint64
+	st_size int64
+	st_blksize int64
+	st_blocks int64
+	st_atime int64
+	st_atime_nsec int64
+	st_mtime int64
+	st_mtime_nsec int64
+	st_ctime int64
+	st_ctime_nsec int64
+	_ int64
+	_ int64
+	_ int64
+}
+
+timespec {
+	seconds int64
+	nanoseconds int64
+}

lib/sys/struct_mac.q

@@ -0,0 +1,7 @@
+sockaddr_in_bsd {
+	sin_len int8
+	sin_family int8
+	sin_port uint16
+	sin_addr int64
+	sin_zero int64
+}

lib/sys/sys_linux.q

@@ -1,87 +1,91 @@
-read(fd Int, address Pointer, length Int) -> Int {
-	return syscall(0, fd, address, length)
+read(fd int, buffer *byte, length int) -> int {
+	return syscall(n.read, fd, buffer, length)
 }
 
-write(fd Int, address Pointer, length Int) -> Int {
-	return syscall(1, fd, address, length)
+write(fd int, buffer *byte, length int) -> int {
+	return syscall(n.write, fd, buffer, length)
 }
 
-open(file Pointer, flags Int, mode Int) -> Int {
-	return syscall(2, file, flags, mode)
+mmap(address int, length uint, protection int, flags int) -> *any {
+	return syscall(n.mmap, address, length, protection, flags)
 }
 
-close(fd Int) -> Int {
-	return syscall(3, fd)
+munmap(address *any, length uint) -> int {
+	return syscall(n.munmap, address, length)
 }
 
-mmap(address Int, length Int, protection Int, flags Int) -> Pointer {
-	return syscall(9, address, length, protection, flags)
+open(path *any, flags int, mode int) -> int {
+	return syscall(n.openat, -100, path, flags, mode)
 }
 
-munmap(address Pointer, length Int) -> Int {
-	return syscall(11, address, length)
+close(fd int) -> int {
+	return syscall(n.close, fd)
 }
 
-nanosleep(duration Pointer) -> Int {
-	return syscall(35, duration, 0)
+stat(path *any, stat *file_stat) -> int {
+	return syscall(n.newfstatat, -100, path, stat, 0)
 }
 
-clone(flags Int, stack Pointer) -> Int {
-	return syscall(56, flags, stack)
+clone(flags uint, stack *any, parent *int, child *int, tls uint) -> int {
+	return syscall(n.clone, flags, stack, parent, child, tls)
 }
 
-fork() -> Int {
-	return syscall(57)
+execve(path *any, argv *any, envp *any) -> int {
+	return syscall(n.execve, path, argv, envp)
 }
 
-execve(path Pointer, argv Pointer, envp Pointer) -> Int {
-	return syscall(59, path, argv, envp)
+exit(status int) {
+	syscall(n.exit, status)
 }
 
-exit(status Int) {
-	syscall(60, status)
+waitid(type int, id int, info *any, options int) -> int {
+	return syscall(n.waitid, type, id, info, options)
 }
 
-socket(family Int, type Int, protocol Int) -> Int {
-	return syscall(41, family, type, protocol)
+socket(family int, type int, protocol int) -> int {
+	return syscall(n.socket, family, type, protocol)
 }
 
-accept(fd Int, address Pointer, length Int) -> Int {
-	return syscall(43, fd, address, length)
+accept(fd int, address *any, length int) -> int {
+	return syscall(n.accept, fd, address, length)
 }
 
-bind(fd Int, address Pointer, length Int) -> Int {
-	return syscall(49, fd, address, length)
+bind(fd int, address *sockaddr_in, length int) -> int {
+	return syscall(n.bind, fd, address, length)
 }
 
-listen(fd Int, backlog Int) -> Int {
-	return syscall(50, fd, backlog)
+listen(fd int, backlog int) -> int {
+	return syscall(n.listen, fd, backlog)
 }
 
-getcwd(buffer Pointer, length Int) -> Int {
-	return syscall(79, buffer, length)
+setsockopt(fd int, level int, optname int, optval *any, optlen int) -> int {
+	return syscall(n.setsockopt, fd, level, optname, optval, optlen)
 }
 
-chdir(path Pointer) -> Int {
-	return syscall(80, path)
+getcwd(buffer *any, length int) -> int {
+	return syscall(n.getcwd, buffer, length)
 }
 
-rename(old Pointer, new Pointer) -> Int {
-	return syscall(82, old, new)
+chdir(path *any) -> int {
+	return syscall(n.chdir, path)
 }
 
-mkdir(path Pointer, mode Int) -> Int {
-	return syscall(83, path, mode)
+rename(old *any, new *any) -> int {
+	return syscall(n.renameat, -100, old, -100, new)
 }
 
-rmdir(path Pointer) -> Int {
-	return syscall(84, path)
+mkdir(path *any, mode int) -> int {
+	return syscall(n.mkdirat, -100, path, mode)
 }
 
-unlink(file Pointer) -> Int {
-	return syscall(87, file)
+rmdir(path *any) -> int {
+	return syscall(n.unlinkat, -100, path, 0x200)
 }
 
-waitid(type Int, id Int, info Pointer, options Int) -> Int {
-	return syscall(247, type, id, info, options)
+unlink(file *any) -> int {
+	return syscall(n.unlinkat, -100, file, 0)
 }
+
+nanosleep(duration *timespec) -> int {
+	return syscall(n.nanosleep, duration, 0)
+}

lib/sys/sys_linux_arm.q

@@ -0,0 +1,26 @@
+const {
+	n {
+		read 63
+		write 64
+		mmap 222
+		munmap 215
+		openat 56
+		close 57
+		newfstatat 79
+		clone 220
+		execve 221
+		exit 93
+		waitid 95
+		socket 198
+		accept 202
+		bind 200
+		listen 201
+		setsockopt 208
+		getcwd 17
+		chdir 49
+		mkdirat 34
+		unlinkat 35
+		renameat 38
+		nanosleep 101
+	}
+}

lib/sys/sys_linux_x86.q

@@ -0,0 +1,27 @@
+const {
+	n {
+		read 0
+		write 1
+		mmap 9
+		munmap 11
+		openat 257
+		close 3
+		newfstatat 262
+		clone 56
+		execve 59
+		exit 60
+		waitid 247
+		socket 41
+		accept 43
+		bind 49
+		listen 50
+		setsockopt 54
+		getcwd 79
+		chdir 80
+		mkdirat 258
+		unlinkat 263
+		renameat 264
+		nanosleep 35
+	}
+}
+

lib/sys/sys_mac.q

@@ -1,39 +1,55 @@
-exit(status Int) {
-	syscall(0x2000001, status)
+read(fd int, buffer *byte, length int) -> int {
+	return syscall(0x2000003, fd, buffer, length)
 }
 
-fork() -> Int {
-	return syscall(0x2000002)
+write(fd int, buffer *byte, length int) -> int {
+	return syscall(0x2000004, fd, buffer, length)
 }
 
-read(fd Int, address Pointer, length Int) -> Int {
-	return syscall(0x2000003, fd, address, length)
+open(path *any, flags int, mode int) -> int {
+	return syscall(0x2000005, path, flags, mode)
 }
 
-write(fd Int, address Pointer, length Int) -> Int {
-	return syscall(0x2000004, fd, address, length)
-}
-
-open(file Pointer, flags Int, mode Int) -> Int {
-	return syscall(0x2000005, file, flags, mode)
-}
-
-close(fd Int) -> Int {
+close(fd int) -> int {
 	return syscall(0x2000006, fd)
 }
 
-mmap(address Int, length Int, protection Int, flags Int) -> Pointer {
+mmap(address int, length int, protection int, flags int) -> *any {
 	return syscall(0x20000C5, address, length, protection, flags)
 }
 
-munmap(address Pointer, length Int) -> Int {
+munmap(address *any, length int) -> int {
 	return syscall(0x2000049, address, length)
 }
 
-execve(path Pointer, argv Pointer, envp Pointer) -> Int {
+exit(status int) {
+	syscall(0x2000001, status)
+}
+
+fork() -> int {
+	return syscall(0x2000002)
+}
+
+execve(path *any, argv *any, envp *any) -> int {
 	return syscall(0x200003B, path, argv, envp)
 }
 
-waitid(type Int, id Int, info Pointer, options Int) -> Int {
+waitid(type int, id int, info *any, options int) -> int {
 	return syscall(0x20000AD, type, id, info, options)
+}
+
+socket(family int, type int, protocol int) -> int {
+	return syscall(0x2000061, family, type, protocol)
+}
+
+accept(fd int, address *any, length int) -> int {
+	return syscall(0x200001E, fd, address, length)
+}
+
+bind(fd int, address *sockaddr_in_bsd, length int) -> int {
+	return syscall(0x2000068, fd, address, length)
+}
+
+listen(fd int, backlog int) -> int {
+	return syscall(0x200006A, fd, backlog)
 }

lib/sys/sys_windows.q

@@ -1,17 +1,19 @@
-write(fd Int, address Pointer, length Int) -> Int {
-	// out numberOfBytesWritten
-	// out overlapped
-	return kernel32.WriteFile(fd, address, length)
+read(fd int, buffer *byte, length int) -> int {
+	fd = kernel32.GetStdHandle(-10 - fd)
+	kernel32.ReadConsole(fd, buffer, uint32(length), 0)
+	return length
 }
 
-mmap(address Int, length Int, protection Int, flags Int) -> Pointer {
-	return kernel32.VirtualAlloc(address, length, flags, protection)
+write(fd int, buffer *byte, length int) -> int {
+	fd = kernel32.GetStdHandle(-10 - fd)
+	kernel32.WriteConsoleA(fd, buffer, uint32(length), 0)
+	return length
 }
 
-munmap(address Pointer, length Int) -> Int {
-	return kernel32.VirtualFree(address, length, 0x4000)
-}
-
-exit(code Int) {
-	kernel32.ExitProcess(code)
+extern {
+	kernel32 {
+		GetStdHandle(handle int64) -> int64
+		ReadConsole(fd int64, buffer *byte, length uint32, written *uint32) -> bool
+		WriteConsoleA(fd int64, buffer *byte, length uint32, written *uint32) -> bool
+	}
 }

lib/thread/thread_linux.q

@@ -1,9 +1,23 @@
+import core
 import sys
 
-create(func Pointer) -> Int {
-	size := 4096
-	stack := sys.mmap(0, size, 0x1|0x2, 0x02|0x20|0x100|0x20000)
-	rip := stack + size - 8
-	store(rip, 8, func)
-	return sys.clone(0x100|0x200|0x400|0x800|0x8000|0x10000|0x80000000, rip)
+create(func *any) -> int {
+	stack := sys.mmap(0, 4096, 0x1|0x2, 0x02|0x20|0x100)
+	stack += 4096 - 8
+	[stack] = core.exit
+	stack -= 8
+	[stack] = func
+	return sys.clone(clone.vm|clone.fs|clone.files|clone.sighand|clone.parent|clone.thread|clone.io, stack, 0, 0, 0)
+}
+
+const {
+	clone {
+		vm 0x100
+		fs 0x200
+		files 0x400
+		sighand 0x800
+		parent 0x8000
+		thread 0x10000
+		io 0x80000000
+	}
 }

lib/thread/thread_windows.q

@@ -0,0 +1,9 @@
+create(func *any) -> int {
+	return kernel32.CreateThread(0, 4096, func, 0)
+}
+
+extern {
+	kernel32 {
+		CreateThread(attributes int, stackSize int, address *any, parameter int) -> int
+	}
+}

lib/time/time.q

@@ -1,13 +1,13 @@
 import sys
 
-sleep(nanoseconds Int) {
+sleep(nanoseconds int) {
 	seconds := 0
 
 	if nanoseconds >= 1000000000 {
 		seconds, nanoseconds = nanoseconds / 1000000000
 	}
 
-	duration := new(timespec)
+	duration := new(sys.timespec)
 	duration.seconds = seconds
 	duration.nanoseconds = nanoseconds
 	sys.nanosleep(duration)

lib/time/timespec.q

@@ -1,4 +0,0 @@
-struct timespec {
-	seconds Int
-	nanoseconds Int
-}

main.go

@@ -3,7 +3,7 @@ package main
 import (
 	"os"
 
-	"git.akyoto.dev/cli/q/src/cli"
+	"git.urbach.dev/cli/q/src/cli"
 )
 
 func main() {

src/arm/Add.go

@@ -0,0 +1,38 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// AddRegisterNumber adds a number to a register.
+func AddRegisterNumber(destination cpu.Register, source cpu.Register, number int) (code uint32, encodable bool) {
+	return addRegisterNumber(destination, source, number, 0)
+}
+
+// AddRegisterRegister adds a register to a register.
+func AddRegisterRegister(destination cpu.Register, source cpu.Register, operand cpu.Register) uint32 {
+	return addRegisterRegister(destination, source, operand, 0)
+}
+
+// addRegisterNumber adds the register and optionally updates the condition flags based on the result.
+func addRegisterNumber(destination cpu.Register, source cpu.Register, number int, flags uint32) (code uint32, encodable bool) {
+	shift := uint32(0)
+
+	if number > mask12 {
+		if number&mask12 != 0 {
+			return 0, false
+		}
+
+		shift = 1
+		number >>= 12
+
+		if number > mask12 {
+			return 0, false
+		}
+	}
+
+	return flags<<29 | 0b100100010<<23 | shift<<22 | reg2Imm(destination, source, number), true
+}
+
+// addRegisterRegister adds the registers and optionally updates the condition flags based on the result.
+func addRegisterRegister(destination cpu.Register, source cpu.Register, operand cpu.Register, flags uint32) uint32 {
+	return flags<<29 | 0b10001011000<<21 | reg3(destination, source, operand)
+}

src/arm/Add_test.go

@@ -0,0 +1,45 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestAddRegisterNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Number      int
+		Code        uint32
+	}{
+		{arm.X0, arm.X0, 1, 0x91000400},
+		{arm.X0, arm.X0, 0x1000, 0x91400400},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("add %s, %s, %d", pattern.Destination, pattern.Source, pattern.Number)
+		code, encodable := arm.AddRegisterNumber(pattern.Destination, pattern.Source, pattern.Number)
+		assert.True(t, encodable)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestAddRegisterRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Operand     cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, arm.X2, 0x8B020020},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("add %s, %s, %s", pattern.Destination, pattern.Source, pattern.Operand)
+		code := arm.AddRegisterRegister(pattern.Destination, pattern.Source, pattern.Operand)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/And.go

@@ -0,0 +1,16 @@
+package arm
+
+import (
+	"git.urbach.dev/cli/q/src/cpu"
+)
+
+// AndRegisterNumber performs a bitwise AND using a register and a number.
+func AndRegisterNumber(destination cpu.Register, source cpu.Register, number int) (uint32, bool) {
+	n, immr, imms, encodable := encodeLogicalImmediate(uint(number))
+	return 0b100100100<<23 | reg2BitmaskImm(destination, source, n, immr, imms), encodable
+}
+
+// AndRegisterRegister performs a bitwise AND using two registers.
+func AndRegisterRegister(destination cpu.Register, source cpu.Register, operand cpu.Register) uint32 {
+	return 0b10001010<<24 | reg3Imm(destination, source, operand, 0)
+}

src/arm/And_test.go

@@ -0,0 +1,49 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestAndRegisterNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Number      int
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, 1, 0x92400020},
+		{arm.X0, arm.X1, 2, 0x927F0020},
+		{arm.X0, arm.X1, 3, 0x92400420},
+		{arm.X0, arm.X1, 7, 0x92400820},
+		{arm.X0, arm.X1, 16, 0x927C0020},
+		{arm.X0, arm.X1, 255, 0x92401C20},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("and %s, %s, %d", pattern.Destination, pattern.Source, pattern.Number)
+		code, encodable := arm.AndRegisterNumber(pattern.Destination, pattern.Source, pattern.Number)
+		assert.True(t, encodable)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestAndRegisterRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Operand     cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, arm.X2, 0x8A020020},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("and %s, %s, %s", pattern.Destination, pattern.Source, pattern.Operand)
+		code := arm.AndRegisterRegister(pattern.Destination, pattern.Source, pattern.Operand)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Call.go

@@ -0,0 +1,8 @@
+package arm
+
+// Call branches to a PC-relative offset, setting the register X30 to PC+4.
+// The offset starts from the address of this instruction and is encoded as "imm26" times 4.
+// This instruction is also known as BL (branch with link).
+func Call(offset int) uint32 {
+	return uint32(0b100101<<26) | uint32(offset&mask26)
+}

src/arm/Call_test.go

@@ -0,0 +1,25 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/go/assert"
+)
+
+func TestCall(t *testing.T) {
+	usagePatterns := []struct {
+		Offset int
+		Code   uint32
+	}{
+		{0, 0x94000000},
+		{1, 0x94000001},
+		{-1, 0x97FFFFFF},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("bl %d", pattern.Offset)
+		code := arm.Call(pattern.Offset)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Compare.go

@@ -0,0 +1,17 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// CompareRegisterNumber is an alias for a subtraction that updates the conditional flags and discards the result.
+func CompareRegisterNumber(register cpu.Register, number int) (code uint32, encodable bool) {
+	if number < 0 {
+		return addRegisterNumber(ZR, register, -number, 1)
+	}
+
+	return subRegisterNumber(ZR, register, number, 1)
+}
+
+// CompareRegisterRegister is an alias for a subtraction that updates the conditional flags and discards the result.
+func CompareRegisterRegister(reg1 cpu.Register, reg2 cpu.Register) uint32 {
+	return subRegisterRegister(ZR, reg1, reg2, 1)
+}

src/arm/Compare_test.go

@@ -0,0 +1,45 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestCompareRegisterNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Source cpu.Register
+		Number int
+		Code   uint32
+	}{
+		{arm.X0, 0, 0xF100001F},
+		{arm.X0, 1, 0xF100041F},
+		{arm.X0, -1, 0xB100041F},
+		{arm.X0, 0x1000, 0xF140041F},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("cmp %s, %d", pattern.Source, pattern.Number)
+		code, encodable := arm.CompareRegisterNumber(pattern.Source, pattern.Number)
+		assert.True(t, encodable)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestCompareRegisterRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Left  cpu.Register
+		Right cpu.Register
+		Code  uint32
+	}{
+		{arm.X0, arm.X1, 0xEB01001F},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("cmp %s, %s", pattern.Left, pattern.Right)
+		code := arm.CompareRegisterRegister(pattern.Left, pattern.Right)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Div.go

@@ -0,0 +1,8 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// DivSigned divides source by operand and stores the value in the destination.
+func DivSigned(destination cpu.Register, source cpu.Register, operand cpu.Register) uint32 {
+	return 0b10011010110<<21 | 0b000011<<10 | reg3(destination, source, operand)
+}

src/arm/Div_test.go

@@ -0,0 +1,26 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestDivSigned(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Operand     cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, arm.X2, 0x9AC20C20},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("sdiv %s, %s, %s", pattern.Destination, pattern.Source, pattern.Operand)
+		code := arm.DivSigned(pattern.Destination, pattern.Source, pattern.Operand)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Jump.go

@@ -0,0 +1,41 @@
+package arm
+
+// Jump continues program flow at the new offset.
+func Jump(offset int) uint32 {
+	return 0b000101<<26 | uint32(offset&mask26)
+}
+
+// JumpIfEqual jumps if the result was equal.
+func JumpIfEqual(offset int) uint32 {
+	return branchCond(EQ, offset)
+}
+
+// JumpIfNotEqual jumps if the result was not equal.
+func JumpIfNotEqual(offset int) uint32 {
+	return branchCond(NE, offset)
+}
+
+// JumpIfGreater jumps if the result was greater.
+func JumpIfGreater(offset int) uint32 {
+	return branchCond(GT, offset)
+}
+
+// JumpIfGreaterOrEqual jumps if the result was greater or equal.
+func JumpIfGreaterOrEqual(offset int) uint32 {
+	return branchCond(GE, offset)
+}
+
+// JumpIfLess jumps if the result was less.
+func JumpIfLess(offset int) uint32 {
+	return branchCond(LS, offset)
+}
+
+// JumpIfLessOrEqual jumps if the result was less or equal.
+func JumpIfLessOrEqual(offset int) uint32 {
+	return branchCond(LE, offset)
+}
+
+// branchCond performs a conditional branch to a PC-relative offset.
+func branchCond(cond condition, imm19 int) uint32 {
+	return 0b01010100<<24 | uint32(imm19&mask19)<<5 | uint32(cond)
+}

src/arm/Jump_test.go

@@ -0,0 +1,68 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/go/assert"
+)
+
+func TestJump(t *testing.T) {
+	usagePatterns := []struct {
+		Type   byte
+		Offset int
+		Code   uint32
+	}{
+		{0, 0, 0x14000000},
+		{0, 1, 0x14000001},
+		{0, -1, 0x17FFFFFF},
+
+		{1, 0, 0x54000000},
+		{1, 1, 0x54000020},
+		{1, -1, 0x54FFFFE0},
+
+		{2, 0, 0x54000001},
+		{2, 1, 0x54000021},
+		{2, -1, 0x54FFFFE1},
+
+		{3, 0, 0x5400000C},
+		{3, 1, 0x5400002C},
+		{3, -1, 0x54FFFFEC},
+
+		{4, 0, 0x5400000A},
+		{4, 1, 0x5400002A},
+		{4, -1, 0x54FFFFEA},
+
+		{5, 0, 0x54000009},
+		{5, 1, 0x54000029},
+		{5, -1, 0x54FFFFE9},
+
+		{6, 0, 0x5400000D},
+		{6, 1, 0x5400002D},
+		{6, -1, 0x54FFFFED},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("b %d", pattern.Offset)
+		var code uint32
+
+		switch pattern.Type {
+		case 0:
+			code = arm.Jump(pattern.Offset)
+		case 1:
+			code = arm.JumpIfEqual(pattern.Offset)
+		case 2:
+			code = arm.JumpIfNotEqual(pattern.Offset)
+		case 3:
+			code = arm.JumpIfGreater(pattern.Offset)
+		case 4:
+			code = arm.JumpIfGreaterOrEqual(pattern.Offset)
+		case 5:
+			code = arm.JumpIfLess(pattern.Offset)
+		case 6:
+			code = arm.JumpIfLessOrEqual(pattern.Offset)
+		}
+
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Load.go

@@ -0,0 +1,19 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// LoadRegister loads from memory into a register.
+func LoadRegister(destination cpu.Register, base cpu.Register, offset int, length byte) uint32 {
+	common := 1<<22 | memory(destination, base, offset)
+
+	switch length {
+	case 1:
+		return 0b00111<<27 | common
+	case 2:
+		return 0b01111<<27 | common
+	case 4:
+		return 0b10111<<27 | common
+	default:
+		return 0b11111<<27 | common
+	}
+}

src/arm/LoadAddress.go

@@ -0,0 +1,10 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// LoadAddress calculates the address with the PC-relative offset and writes the result to the destination register.
+func LoadAddress(destination cpu.Register, offset int) uint32 {
+	hi := uint32(offset) >> 2
+	lo := uint32(offset) & 0b11
+	return lo<<29 | 0b10000<<24 | hi<<5 | uint32(destination)
+}

src/arm/LoadAddress_test.go

@@ -0,0 +1,26 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestLoadAddress(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Number      int
+		Code        uint32
+	}{
+		{arm.X0, 56, 0x100001C0},
+		{arm.X1, 80, 0x10000281},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("adr %s, %d", pattern.Destination, pattern.Number)
+		code := arm.LoadAddress(pattern.Destination, pattern.Number)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/LoadPair.go

@@ -0,0 +1,10 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// LoadPair calculates an address from a base register value and an immediate offset,
+// loads two 64-bit doublewords from memory, and writes them to two registers.
+// This is the post-index version of the instruction so the offset is applied to the base register after the memory access.
+func LoadPair(reg1 cpu.Register, reg2 cpu.Register, base cpu.Register, offset int) uint32 {
+	return 0b1010100011<<22 | pair(reg1, reg2, base, offset/8)
+}

src/arm/LoadPair_test.go

@@ -0,0 +1,28 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestLoadPair(t *testing.T) {
+	usagePatterns := []struct {
+		Reg1   cpu.Register
+		Reg2   cpu.Register
+		Base   cpu.Register
+		Offset int
+		Code   uint32
+	}{
+		{arm.FP, arm.LR, arm.SP, 32, 0xA8C27BFD},
+		{arm.FP, arm.LR, arm.SP, 16, 0xA8C17BFD},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("ldp %s, %s, [%s], #%d", pattern.Reg1, pattern.Reg2, pattern.Base, pattern.Offset)
+		code := arm.LoadPair(pattern.Reg1, pattern.Reg2, pattern.Base, pattern.Offset)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Load_test.go

@@ -0,0 +1,39 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestLoadRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Base        cpu.Register
+		Offset      int
+		Length      byte
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, -8, 1, 0x385F8020},
+		{arm.X1, arm.X0, -8, 1, 0x385F8001},
+		{arm.X0, arm.X1, -8, 2, 0x785F8020},
+		{arm.X1, arm.X0, -8, 2, 0x785F8001},
+		{arm.X0, arm.X1, -8, 4, 0xB85F8020},
+		{arm.X1, arm.X0, -8, 4, 0xB85F8001},
+		{arm.X0, arm.X1, -8, 8, 0xF85F8020},
+		{arm.X1, arm.X0, -8, 8, 0xF85F8001},
+		{arm.X2, arm.X1, -8, 8, 0xF85F8022},
+		{arm.X2, arm.X1, 0, 8, 0xF8400022},
+		{arm.X2, arm.X1, 8, 8, 0xF8408022},
+		{arm.X2, arm.X1, -256, 8, 0xF8500022},
+		{arm.X2, arm.X1, 255, 8, 0xF84FF022},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("ldur %s, [%s, %d] %db", pattern.Destination, pattern.Base, pattern.Offset, pattern.Length)
+		code := arm.LoadRegister(pattern.Destination, pattern.Base, pattern.Offset, pattern.Length)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Move.go

@@ -0,0 +1,100 @@
+package arm
+
+import (
+	"encoding/binary"
+
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/cli/q/src/sizeof"
+)
+
+// MoveRegisterNumber moves a number into the given register.
+func MoveRegisterNumber(code []byte, destination cpu.Register, number int) []byte {
+	instruction, encodable := MoveRegisterNumberSI(destination, number)
+
+	if encodable {
+		return binary.LittleEndian.AppendUint32(code, instruction)
+	}
+
+	return MoveRegisterNumberMI(code, destination, number)
+}
+
+// MoveRegisterNumberMI moves a number into the given register using movz and a series of movk instructions.
+func MoveRegisterNumberMI(code []byte, destination cpu.Register, number int) []byte {
+	movz := MoveZero(destination, 0, uint16(number))
+	code = binary.LittleEndian.AppendUint32(code, movz)
+	num := uint64(number)
+	halfword := 1
+
+	for {
+		num >>= 16
+
+		if num == 0 {
+			return code
+		}
+
+		movk := MoveKeep(destination, halfword, uint16(num))
+		code = binary.LittleEndian.AppendUint32(code, movk)
+		halfword++
+	}
+}
+
+// MoveRegisterNumberSI moves a number into the given register using a single instruction.
+func MoveRegisterNumberSI(destination cpu.Register, number int) (uint32, bool) {
+	if sizeof.Signed(number) <= 2 {
+		if number < 0 {
+			return MoveInvertedNumber(destination, uint16(^number), 0), true
+		}
+
+		return MoveZero(destination, 0, uint16(number)), true
+	}
+
+	if (number&0xFFFFFFFFFFFF == 0xFFFFFFFFFFFF) && sizeof.Signed(number>>48) <= 2 {
+		return MoveInvertedNumber(destination, uint16((^number)>>48), 3), true
+	}
+
+	code, encodable := MoveBitmaskNumber(destination, number)
+
+	if encodable {
+		return code, true
+	}
+
+	if (number&0xFFFFFFFF == 0xFFFFFFFF) && sizeof.Signed(number>>32) <= 2 {
+		return MoveInvertedNumber(destination, uint16((^number)>>32), 2), true
+	}
+
+	if (number&0xFFFF == 0xFFFF) && sizeof.Signed(number>>16) <= 2 {
+		return MoveInvertedNumber(destination, uint16((^number)>>16), 1), true
+	}
+
+	return 0, false
+}
+
+// MoveRegisterRegister copies a register to another register.
+func MoveRegisterRegister(destination cpu.Register, source cpu.Register) uint32 {
+	if source == SP || destination == SP {
+		code, _ := AddRegisterNumber(destination, source, 0)
+		return code
+	}
+
+	return OrRegisterRegister(destination, ZR, source)
+}
+
+// MoveBitmaskNumber moves a bitmask immediate value to a register.
+func MoveBitmaskNumber(destination cpu.Register, number int) (uint32, bool) {
+	return OrRegisterNumber(destination, ZR, number)
+}
+
+// MoveInvertedNumber moves an inverted 16-bit immediate value to a register.
+func MoveInvertedNumber(destination cpu.Register, number uint16, shift uint32) uint32 {
+	return 0b100100101<<23 | shift<<21 | regImm(destination, number)
+}
+
+// MoveKeep moves a 16-bit integer into the given register and keeps all other bits.
+func MoveKeep(destination cpu.Register, halfword int, number uint16) uint32 {
+	return 0b111100101<<23 | regImmHw(destination, halfword, number)
+}
+
+// MoveZero moves a 16-bit integer into the given register and clears all other bits to zero.
+func MoveZero(destination cpu.Register, halfword int, number uint16) uint32 {
+	return 0b110100101<<23 | regImmHw(destination, halfword, number)
+}

src/arm/Move_test.go

@@ -0,0 +1,121 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestMoveRegisterRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, 0xAA0103E0},
+		{arm.X1, arm.X0, 0xAA0003E1},
+		{arm.FP, arm.SP, 0x910003FD},
+		{arm.SP, arm.FP, 0x910003BF},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("mov %s, %s", pattern.Destination, pattern.Source)
+		code := arm.MoveRegisterRegister(pattern.Destination, pattern.Source)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestMoveRegisterNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Register cpu.Register
+		Number   uint64
+		Code     []byte
+	}{
+		{arm.X0, 0, []byte{0x00, 0x00, 0x80, 0xD2}},
+		{arm.X0, 0xCAFEBABE, []byte{0xC0, 0x57, 0x97, 0xD2, 0xC0, 0x5F, 0xB9, 0xF2}},
+		{arm.X0, 0xDEADC0DE, []byte{0xC0, 0x1B, 0x98, 0xD2, 0xA0, 0xD5, 0xBB, 0xF2}},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("mov %s, 0x%X", pattern.Register, pattern.Number)
+		code := arm.MoveRegisterNumber(nil, pattern.Register, int(pattern.Number))
+		assert.DeepEqual(t, code, pattern.Code)
+	}
+}
+
+func TestMoveRegisterNumberSI(t *testing.T) {
+	usagePatterns := []struct {
+		Register cpu.Register
+		Number   uint64
+		Code     uint32
+	}{
+		// MOVZ
+		{arm.X0, 0x0, 0xD2800000},
+		{arm.X0, 0x1, 0xD2800020},
+		{arm.X0, 0x1000, 0xD2820000},
+
+		// MOV (bitmask immediate)
+		{arm.X0, 0x1FFFF, 0xB24043E0},
+		{arm.X0, 0x7FFFFFFF, 0xB2407BE0},
+		{arm.X0, 0xFFFFFFFF, 0xB2407FE0},
+		{arm.X0, 0xC3FFFFFFC3FFFFFF, 0xB2026FE0},
+
+		// MOV (inverted wide immediate)
+		{arm.X0, 0xFFFFFFFFFFFFFFFF, 0x92800000},
+		{arm.X0, 0x7FFFFFFFFFFFFFFF, 0x92F00000},
+		{arm.X0, 0x2FFFFFFFF, 0x92DFFFA0}, // not encodable in the GNU assembler
+		{arm.X0, 0x2FFFF, 0x92BFFFA0},     // not encodable in the GNU assembler
+
+		// Not encodable
+		{arm.X0, 0xCAFEBABE, 0},
+		{arm.X0, 0xDEADC0DE, 0},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("mov %s, %d", pattern.Register, pattern.Number)
+		code, encodable := arm.MoveRegisterNumberSI(pattern.Register, int(pattern.Number))
+
+		if pattern.Code != 0 {
+			assert.True(t, encodable)
+			assert.Equal(t, code, pattern.Code)
+		} else {
+			assert.False(t, encodable)
+		}
+	}
+}
+
+func TestMoveKeep(t *testing.T) {
+	usagePatterns := []struct {
+		Register cpu.Register
+		Number   uint16
+		Code     uint32
+	}{
+		{arm.X0, 0, 0xF2800000},
+		{arm.X0, 1, 0xF2800020},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("movk %s, %d", pattern.Register, pattern.Number)
+		code := arm.MoveKeep(pattern.Register, 0, pattern.Number)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestMoveZero(t *testing.T) {
+	usagePatterns := []struct {
+		Register cpu.Register
+		Number   uint16
+		Code     uint32
+	}{
+		{arm.X0, 0, 0xD2800000},
+		{arm.X0, 1, 0xD2800020},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("movz %s, %d", pattern.Register, pattern.Number)
+		code := arm.MoveZero(pattern.Register, 0, pattern.Number)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Mul.go

@@ -0,0 +1,13 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// MulRegisterRegister multiplies `multiplicand` with `multiplier` and saves the result in `destination`
+func MulRegisterRegister(destination cpu.Register, multiplicand cpu.Register, multiplier cpu.Register) uint32 {
+	return 0b10011011000<<21 | reg4(destination, multiplicand, multiplier, ZR)
+}
+
+// MultiplySubtract multiplies `multiplicand` with `multiplier`, subtracts the product from `minuend` and saves the result in `destination`.
+func MultiplySubtract(destination cpu.Register, multiplicand cpu.Register, multiplier cpu.Register, minuend cpu.Register) uint32 {
+	return 0b10011011000<<21 | 1<<15 | reg4(destination, multiplicand, multiplier, minuend)
+}

src/arm/Mul_test.go

@@ -0,0 +1,45 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestMulRegisterRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Operand     cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, arm.X2, 0x9B027C20},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("mul %s, %s, %s", pattern.Destination, pattern.Source, pattern.Operand)
+		code := arm.MulRegisterRegister(pattern.Destination, pattern.Source, pattern.Operand)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestMultiplySubtract(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Operand     cpu.Register
+		Extra       cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, arm.X2, arm.X3, 0x9B028C20},
+		{arm.X3, arm.X0, arm.X2, arm.X1, 0x9B028403},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("msub %s, %s, %s, %s", pattern.Destination, pattern.Source, pattern.Operand, pattern.Extra)
+		code := arm.MultiplySubtract(pattern.Destination, pattern.Source, pattern.Operand, pattern.Extra)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Negate.go

@@ -0,0 +1,8 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// NegateRegister negates the value in the source register and writes it to the destination register.
+func NegateRegister(destination cpu.Register, source cpu.Register) uint32 {
+	return 0b11001011<<24 | reg3Imm(destination, ZR, source, 0)
+}

src/arm/Negate_test.go

@@ -0,0 +1,26 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestNegateRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X0, 0xCB0003E0},
+		{arm.X1, arm.X1, 0xCB0103E1},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("neg %s, %s", pattern.Destination, pattern.Source)
+		code := arm.NegateRegister(pattern.Destination, pattern.Source)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Nop.go

@@ -0,0 +1,6 @@
+package arm
+
+// Nop does nothing. This can be used for alignment purposes.
+func Nop() uint32 {
+	return 0xD503201F
+}

src/arm/Or.go

@@ -0,0 +1,14 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// OrRegisterNumber performs a bitwise OR using a register and a number.
+func OrRegisterNumber(destination cpu.Register, source cpu.Register, number int) (uint32, bool) {
+	n, immr, imms, encodable := encodeLogicalImmediate(uint(number))
+	return 0b101100100<<23 | reg2BitmaskImm(destination, source, n, immr, imms), encodable
+}
+
+// OrRegisterRegister performs a bitwise OR using two registers.
+func OrRegisterRegister(destination cpu.Register, source cpu.Register, operand cpu.Register) uint32 {
+	return 0b10101010<<24 | reg3(destination, source, operand)
+}

src/arm/Or_test.go

@@ -0,0 +1,49 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestOrRegisterNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Number      int
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, 1, 0xB2400020},
+		{arm.X0, arm.X1, 2, 0xB27F0020},
+		{arm.X0, arm.X1, 3, 0xB2400420},
+		{arm.X0, arm.X1, 7, 0xB2400820},
+		{arm.X0, arm.X1, 16, 0xB27C0020},
+		{arm.X0, arm.X1, 255, 0xB2401C20},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("orr %s, %s, %d", pattern.Destination, pattern.Source, pattern.Number)
+		code, encodable := arm.OrRegisterNumber(pattern.Destination, pattern.Source, pattern.Number)
+		assert.True(t, encodable)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestOrRegisterRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Operand     cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, arm.X2, 0xAA020020},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("orr %s, %s, %s", pattern.Destination, pattern.Source, pattern.Operand)
+		code := arm.OrRegisterRegister(pattern.Destination, pattern.Source, pattern.Operand)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Registers.go

@@ -0,0 +1,59 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+const (
+	X0 cpu.Register = iota // Function arguments and return values [0-7]
+	X1
+	X2
+	X3
+	X4
+	X5
+	X6
+	X7
+	X8 // Indirect result location register (used to pass a pointer to a structure return value)
+	X9 // Temporary registers (caller-saved, used for general computation) [9-15]
+	X10
+	X11
+	X12
+	X13
+	X14
+	X15
+	X16 // Intra-procedure call scratch registers [16-17]
+	X17
+	X18 // Platform register (reserved by the platform ABI for thread-local storage)
+	X19 // Callee-saved registers (must be preserved across function calls) [19-28]
+	X20
+	X21
+	X22
+	X23
+	X24
+	X25
+	X26
+	X27
+	X28
+	FP // Frame pointer
+	LR // Link register
+	SP // Stack pointer
+)
+
+const (
+	ZR   = SP  // Zero register uses the same numerical value as SP
+	TMP  = X27 // Temporary register for the assembler
+	TMP2 = X28 // Temporary register for the assembler
+)
+
+var (
+	InputRegisters         = []cpu.Register{X0, X1, X2, X3, X4, X5}
+	WindowsInputRegisters  = []cpu.Register{X0, X1, X2, X3, X4, X5, X6, X7}
+	WindowsOutputRegisters = []cpu.Register{X0, X1}
+
+	CPU = cpu.CPU{
+		General:       []cpu.Register{X9, X10, X11, X12, X13, X14, X15, X16, X17, X19, X20, X21, X22, X23, X24, X25, X26},
+		Input:         InputRegisters,
+		Output:        InputRegisters,
+		SyscallInput:  []cpu.Register{X8, X0, X1, X2, X3, X4, X5},
+		SyscallOutput: []cpu.Register{X0, X1},
+		NumRegisters:  32,
+	}
+)

src/arm/Registers_test.go

@@ -0,0 +1,12 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/go/assert"
+)
+
+func TestRegisters(t *testing.T) {
+	assert.NotContains(t, arm.CPU.General, arm.SP)
+}

src/arm/Return.go

@@ -0,0 +1,6 @@
+package arm
+
+// Return transfers program control to the caller.
+func Return() uint32 {
+	return 0xD65F03C0
+}

src/arm/Shift.go

@@ -0,0 +1,15 @@
+package arm
+
+import (
+	"git.urbach.dev/cli/q/src/cpu"
+)
+
+// ShiftLeftNumber shifts the register value a specified amount of bits to the left.
+func ShiftLeftNumber(destination cpu.Register, source cpu.Register, bits int) uint32 {
+	return 0b110100110<<23 | reg2BitmaskImm(destination, source, 1, 64-bits, (^bits)&mask6)
+}
+
+// ShiftRightSignedNumber shifts the signed register value a specified amount of bits to the right.
+func ShiftRightSignedNumber(destination cpu.Register, source cpu.Register, bits int) uint32 {
+	return 0b100100110<<23 | reg2BitmaskImm(destination, source, 1, bits&mask6, 0b111111)
+}

src/arm/Shift_test.go

@@ -0,0 +1,52 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestShiftLeftNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Bits        int
+		Code        uint32
+	}{
+		{arm.X0, arm.X0, 0, 0xD340FC00},
+		{arm.X0, arm.X0, 1, 0xD37FF800},
+		{arm.X0, arm.X0, 8, 0xD378DC00},
+		{arm.X0, arm.X0, 16, 0xD370BC00},
+		{arm.X0, arm.X0, 63, 0xD3410000},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("%b", pattern.Code)
+		t.Logf("lsl %s, %s, %x", pattern.Destination, pattern.Source, pattern.Bits)
+		code := arm.ShiftLeftNumber(pattern.Destination, pattern.Source, pattern.Bits)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestShiftRightSignedNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Bits        int
+		Code        uint32
+	}{
+		{arm.X0, arm.X0, 0, 0x9340FC00},
+		{arm.X0, arm.X0, 1, 0x9341FC00},
+		{arm.X0, arm.X0, 8, 0x9348FC00},
+		{arm.X0, arm.X0, 16, 0x9350FC00},
+		{arm.X0, arm.X0, 63, 0x937FFC00},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("asr %s, %s, %x", pattern.Destination, pattern.Source, pattern.Bits)
+		code := arm.ShiftRightSignedNumber(pattern.Destination, pattern.Source, pattern.Bits)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Store.go

@@ -0,0 +1,21 @@
+package arm
+
+import (
+	"git.urbach.dev/cli/q/src/cpu"
+)
+
+// StoreRegister writes the contents of the register to a memory address.
+func StoreRegister(source cpu.Register, base cpu.Register, offset int, length byte) uint32 {
+	common := memory(source, base, offset)
+
+	switch length {
+	case 1:
+		return 0b00111<<27 | common
+	case 2:
+		return 0b01111<<27 | common
+	case 4:
+		return 0b10111<<27 | common
+	default:
+		return 0b11111<<27 | common
+	}
+}

src/arm/StorePair.go

@@ -0,0 +1,12 @@
+package arm
+
+import (
+	"git.urbach.dev/cli/q/src/cpu"
+)
+
+// StorePair calculates an address from a base register value and an immediate offset multiplied by 8,
+// and stores the values of two registers to the calculated address.
+// This is the pre-index version of the instruction so the offset is applied to the base register before the memory access.
+func StorePair(reg1 cpu.Register, reg2 cpu.Register, base cpu.Register, offset int) uint32 {
+	return 0b1010100110<<22 | pair(reg1, reg2, base, offset/8)
+}

src/arm/StorePair_test.go

@@ -0,0 +1,28 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestStorePair(t *testing.T) {
+	usagePatterns := []struct {
+		Reg1   cpu.Register
+		Reg2   cpu.Register
+		Base   cpu.Register
+		Offset int
+		Code   uint32
+	}{
+		{arm.FP, arm.LR, arm.SP, -32, 0xA9BE7BFD},
+		{arm.FP, arm.LR, arm.SP, -16, 0xA9BF7BFD},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("stp %s, %s, [%s, #%d]!", pattern.Reg1, pattern.Reg2, pattern.Base, pattern.Offset)
+		code := arm.StorePair(pattern.Reg1, pattern.Reg2, pattern.Base, pattern.Offset)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Store_test.go

@@ -0,0 +1,34 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestStoreRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Source cpu.Register
+		Base   cpu.Register
+		Offset int
+		Length byte
+		Code   uint32
+	}{
+		{arm.X0, arm.X1, -8, 1, 0x381F8020},
+		{arm.X1, arm.X0, -8, 1, 0x381F8001},
+		{arm.X0, arm.X1, -8, 2, 0x781F8020},
+		{arm.X1, arm.X0, -8, 2, 0x781F8001},
+		{arm.X0, arm.X1, -8, 4, 0xB81F8020},
+		{arm.X1, arm.X0, -8, 4, 0xB81F8001},
+		{arm.X0, arm.X1, -8, 8, 0xF81F8020},
+		{arm.X1, arm.X0, -8, 8, 0xF81F8001},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("stur %s, [%s, #%d] %db", pattern.Source, pattern.Base, pattern.Offset, pattern.Length)
+		code := arm.StoreRegister(pattern.Source, pattern.Base, pattern.Offset, pattern.Length)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Sub.go

@@ -0,0 +1,38 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// SubRegisterNumber subtracts a number from the given register.
+func SubRegisterNumber(destination cpu.Register, source cpu.Register, number int) (code uint32, encodable bool) {
+	return subRegisterNumber(destination, source, number, 0)
+}
+
+// SubRegisterRegister subtracts a register from a register.
+func SubRegisterRegister(destination cpu.Register, source cpu.Register, operand cpu.Register) uint32 {
+	return subRegisterRegister(destination, source, operand, 0)
+}
+
+// subRegisterNumber subtracts the register and optionally updates the condition flags based on the result.
+func subRegisterNumber(destination cpu.Register, source cpu.Register, number int, flags uint32) (code uint32, encodable bool) {
+	shift := uint32(0)
+
+	if number > mask12 {
+		if number&mask12 != 0 {
+			return 0, false
+		}
+
+		shift = 1
+		number >>= 12
+
+		if number > mask12 {
+			return 0, false
+		}
+	}
+
+	return flags<<29 | 0b110100010<<23 | shift<<22 | reg2Imm(destination, source, number), true
+}
+
+// subRegisterRegister subtracts the registers and optionally updates the condition flags based on the result.
+func subRegisterRegister(destination cpu.Register, source cpu.Register, operand cpu.Register, flags uint32) uint32 {
+	return flags<<29 | 0b11001011000<<21 | reg3(destination, source, operand)
+}

src/arm/Sub_test.go

@@ -0,0 +1,46 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestSubRegisterNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Number      int
+		Code        uint32
+	}{
+		{arm.X0, arm.X0, 1, 0xD1000400},
+		{arm.X0, arm.X0, 0x1000, 0xD1400400},
+		{arm.SP, arm.SP, 16, 0xD10043FF},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("sub %s, %s, %d", pattern.Destination, pattern.Source, pattern.Number)
+		code, encodable := arm.SubRegisterNumber(pattern.Destination, pattern.Source, pattern.Number)
+		assert.True(t, encodable)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestSubRegisterRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Operand     cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, arm.X2, 0xCB020020},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("sub %s, %s, %s", pattern.Destination, pattern.Source, pattern.Operand)
+		code := arm.SubRegisterRegister(pattern.Destination, pattern.Source, pattern.Operand)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/Syscall.go

@@ -0,0 +1,6 @@
+package arm
+
+// Syscall is the primary way to communicate with the OS kernel.
+func Syscall() uint32 {
+	return 0xD4000001
+}

src/arm/Xor.go

@@ -0,0 +1,14 @@
+package arm
+
+import "git.urbach.dev/cli/q/src/cpu"
+
+// XorRegisterNumber performs a bitwise XOR using a register and a number.
+func XorRegisterNumber(destination cpu.Register, source cpu.Register, number int) (uint32, bool) {
+	n, immr, imms, encodable := encodeLogicalImmediate(uint(number))
+	return 0b110100100<<23 | reg2BitmaskImm(destination, source, n, immr, imms), encodable
+}
+
+// XorRegisterRegister performs a bitwise XOR using two registers.
+func XorRegisterRegister(destination cpu.Register, source cpu.Register, operand cpu.Register) uint32 {
+	return 0b11001010<<24 | reg3(destination, source, operand)
+}

src/arm/Xor_test.go

@@ -0,0 +1,49 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/go/assert"
+)
+
+func TestXorRegisterNumber(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Number      int
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, 1, 0xD2400020},
+		{arm.X0, arm.X1, 2, 0xD27F0020},
+		{arm.X0, arm.X1, 3, 0xD2400420},
+		{arm.X0, arm.X1, 7, 0xD2400820},
+		{arm.X0, arm.X1, 16, 0xD27C0020},
+		{arm.X0, arm.X1, 255, 0xD2401C20},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("eor %s, %s, %d", pattern.Destination, pattern.Source, pattern.Number)
+		code, encodable := arm.XorRegisterNumber(pattern.Destination, pattern.Source, pattern.Number)
+		assert.True(t, encodable)
+		assert.Equal(t, code, pattern.Code)
+	}
+}
+
+func TestXorRegisterRegister(t *testing.T) {
+	usagePatterns := []struct {
+		Destination cpu.Register
+		Source      cpu.Register
+		Operand     cpu.Register
+		Code        uint32
+	}{
+		{arm.X0, arm.X1, arm.X2, 0xCA020020},
+	}
+
+	for _, pattern := range usagePatterns {
+		t.Logf("eor %s, %s, %s", pattern.Destination, pattern.Source, pattern.Operand)
+		code := arm.XorRegisterRegister(pattern.Destination, pattern.Source, pattern.Operand)
+		assert.Equal(t, code, pattern.Code)
+	}
+}

src/arm/arm_test.go

@@ -0,0 +1,37 @@
+package arm_test
+
+import (
+	"testing"
+
+	"git.urbach.dev/cli/q/src/arm"
+	"git.urbach.dev/go/assert"
+)
+
+func TestConstants(t *testing.T) {
+	assert.DeepEqual(t, arm.Nop(), 0xD503201F)
+	assert.DeepEqual(t, arm.Return(), 0xD65F03C0)
+	assert.DeepEqual(t, arm.Syscall(), 0xD4000001)
+}
+
+func TestNotEncodable(t *testing.T) {
+	_, encodable := arm.AndRegisterNumber(arm.X0, arm.X0, 0)
+	assert.False(t, encodable)
+	_, encodable = arm.OrRegisterNumber(arm.X0, arm.X0, 0)
+	assert.False(t, encodable)
+	_, encodable = arm.XorRegisterNumber(arm.X0, arm.X0, 0)
+	assert.False(t, encodable)
+	_, encodable = arm.AndRegisterNumber(arm.X0, arm.X0, -1)
+	assert.False(t, encodable)
+	_, encodable = arm.OrRegisterNumber(arm.X0, arm.X0, -1)
+	assert.False(t, encodable)
+	_, encodable = arm.XorRegisterNumber(arm.X0, arm.X0, -1)
+	assert.False(t, encodable)
+	_, encodable = arm.AddRegisterNumber(arm.X0, arm.X0, 0xFFFF)
+	assert.False(t, encodable)
+	_, encodable = arm.AddRegisterNumber(arm.X0, arm.X0, 0xF0000000)
+	assert.False(t, encodable)
+	_, encodable = arm.SubRegisterNumber(arm.X0, arm.X0, 0xFFFF)
+	assert.False(t, encodable)
+	_, encodable = arm.SubRegisterNumber(arm.X0, arm.X0, 0xF0000000)
+	assert.False(t, encodable)
+}

src/arm/bitmask.go

@@ -0,0 +1,33 @@
+package arm
+
+import "math/bits"
+
+// encodeLogicalImmediate encodes a bitmask immediate.
+// The algorithm used here was made by Dougall Johnson.
+func encodeLogicalImmediate(val uint) (N int, immr int, imms int, encodable bool) {
+	if val == 0 || ^val == 0 {
+		return 0, 0, 0, false
+	}
+
+	rotation := bits.TrailingZeros(clearTrailingOnes(val))
+	normalized := bits.RotateLeft(val, -(rotation & 63))
+
+	zeroes := bits.LeadingZeros(normalized)
+	ones := bits.TrailingZeros(^normalized)
+	size := zeroes + ones
+
+	immr = -rotation & (size - 1)
+	imms = -(size << 1) | (ones - 1)
+	N = (size >> 6)
+
+	if bits.RotateLeft(val, -(size&63)) != val {
+		return 0, 0, 0, false
+	}
+
+	return N, immr, (imms & 0x3F), true
+}
+
+// clearTrailingOnes clears trailing one bits.
+func clearTrailingOnes(x uint) uint {
+	return x & (x + 1)
+}