Write a compiler from Scrapscript to C (#120)

Emit straight C, no IR. Includes a GC and small runtime.

Has immediate small integers (no bignum), small strings and heap
strings, and immediate empty list.

.clang-format

···
+BasedOnStyle: Google
+AlignEscapedNewlinesLeft: false
+DerivePointerAlignment: false
+PointerAlignment: Left
+IncludeBlocks: Regroup
+IncludeCategories:
+  # C system headers
+  - Regex:           '^<.*\.h?>'
+    Priority:        1
+  # Scrapscript headers
+  - Regex:           '.*'
+    Priority:        2

.clang-tidy

···
+Checks: >
+  -*,
+  bugprone-argument-comment,
+  google-readability-casting,
+  google-readability-todo,
+  modernize-use-nullptr,
+  readability-braces-around-statements,
+  readability-else-after-return,
+  readability-identifier-naming,
+  readability-inconsistent-declaration-parameter-name,
+  readability-static-accessed-through-instance,
+FormatStyle: file
+CheckOptions:
+  - { key: readability-identifier-naming.ClassCase, value: CamelCase }
+  - { key: readability-identifier-naming.ClassMemberCase, value: lower_case }
+  - { key: readability-identifier-naming.ClassMemberSuffix, value: '_' }
+  - { key: readability-identifier-naming.GlobalConstantCase, value: CamelCase }
+  - { key: readability-identifier-naming.GlobalConstantPrefix, value: 'k' }
+  - { key: readability-identifier-naming.LocalVariableCase, value: lower_case }
+  - { key: readability-identifier-naming.MethodCase, value: camelBack }
+  - { key: readability-identifier-naming.NamespaceCase, value: lower_case }
+  - { key: readability-identifier-naming.ParameterCase, value: lower_case }
+  - { key: readability-braces-around-statements.ShortStatementLines, value: 1 }

.github/workflows/ci.yml

···
       run: sudo apt update
     - name: Install Python
       run: sudo apt install --yes ${{matrix.PYTHON}}
-    - name: Run tests
+    - name: Run interpreter tests
       run: ${{matrix.PYTHON}} scrapscript.py test
+    - name: Run compiler tests
+      run: ${{matrix.PYTHON}} compiler_tests.py
   build_docker_image:
     runs-on: ubuntu-latest
     permissions:

README.md

···
 docker run -i -t ghcr.io/tekknolagi/scrapscript:trunk repl
 ```
 
+### The experimental compiler:
+
+#### Normal ELF
+
+```bash
+./compiler.py some.scrap  # produces output.c
+./compiler.py some.scrap --compile  # produces a.out
+```
+
+#### Cosmopolitan
+
+```bash
+CC=~/Downloads/cosmos/bin/cosmocc ./compiler.py some.scrap  --compile # produces a.out
+```
+
+#### Wasm
+
+```bash
+CC=/opt/wasi-sdk/bin/clang \
+CFLAGS=-D_WASI_EMULATED_MMAN \
+LDFLAGS=-lwasi-emulated-mman \
+./compiler.py some.scrap --compile  # produces a.out
+```
+
 ## Running Tests
 
 ```bash

compiler.py

···
+#!/usr/bin/env python3
+import dataclasses
+import io
+import itertools
+import json
+import os
+import typing
+
+from typing import Dict, Optional
+
+from scrapscript import (
+    Access,
+    Apply,
+    Assign,
+    Binop,
+    BinopKind,
+    Function,
+    Hole,
+    Int,
+    List,
+    MatchFunction,
+    Object,
+    Record,
+    Spread,
+    String,
+    Var,
+    Variant,
+    Where,
+    free_in,
+    parse,
+    tokenize,
+)
+
+Env = Dict[str, str]
+
+
+fn_counter = itertools.count()
+
+
[e-mail]
+class CompiledFunction:
+    id: int = dataclasses.field(default=0, init=False, compare=False, hash=False)
+    name: str
+    params: typing.List[str]
+    fields: typing.List[str] = dataclasses.field(default_factory=list)
+    code: typing.List[str] = dataclasses.field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        self.id = next(fn_counter)
+        self.code.append("HANDLES();")
+        for param in self.params:
+            # The parameters are raw pointers and must be updated on GC
+            self.code.append(f"GC_PROTECT({param});")
+
+    def decl(self) -> str:
+        args = ", ".join(f"struct object* {arg}" for arg in self.params)
+        return f"struct object* {self.name}({args})"
+
+
+class Compiler:
+    def __init__(self, main_fn: CompiledFunction) -> None:
+        self.gensym_counter: int = 0
+        self.functions: typing.List[CompiledFunction] = [main_fn]
+        self.function: CompiledFunction = main_fn
+        self.record_keys: Dict[str, int] = {}
+        self.variant_tags: Dict[str, int] = {}
+        self.debug: bool = False
+        self.used_runtime_functions: set[str] = set()
+
+    def record_key(self, key: str) -> int:
+        result = self.record_keys.get(key)
+        if result is not None:
+            return result
+        result = self.record_keys[key] = len(self.record_keys)
+        return result
+
+    def variant_tag(self, key: str) -> int:
+        result = self.variant_tags.get(key)
+        if result is not None:
+            return result
+        result = self.variant_tags[key] = len(self.variant_tags)
+        return result
+
+    def gensym(self, stem: str = "tmp") -> str:
+        self.gensym_counter += 1
+        return f"{stem}_{self.gensym_counter-1}"
+
+    def _emit(self, line: str) -> None:
+        self.function.code.append(line)
+
+    def _debug(self, line: str) -> None:
+        if not self.debug:
+            return
+        self._emit("#ifndef NDEBUG")
+        self._emit(line)
+        self._emit("#endif")
+
+    def _handle(self, name: str, exp: str) -> str:
+        # TODO(max): Liveness analysis to avoid unnecessary handles
+        self._emit(f"OBJECT_HANDLE({name}, {exp});")
+        return name
+
+    def _guard(self, cond: str, msg: Optional[str] = None) -> None:
+        if msg is None:
+            msg = f"assertion {cond!s} failed"
+        self._emit(f"if (!({cond})) {{")
+        self._emit(f'fprintf(stderr, "{msg}\\n");')
+        self._emit("abort();")
+        self._emit("}")
+
+    def _mktemp(self, exp: str) -> str:
+        temp = self.gensym()
+        return self._handle(temp, exp)
+
+    def compile_assign(self, env: Env, exp: Assign) -> Env:
+        assert isinstance(exp.name, Var)
+        name = exp.name.name
+        if isinstance(exp.value, Function):
+            # Named function
+            value = self.compile_function(env, exp.value, name)
+            return {**env, name: value}
+        if isinstance(exp.value, MatchFunction):
+            # Named match function
+            value = self.compile_match_function(env, exp.value, name)
+            return {**env, name: value}
+        value = self.compile(env, exp.value)
+        return {**env, name: value}
+
+    def make_compiled_function(self, arg: str, exp: Object, name: Optional[str]) -> CompiledFunction:
+        assert isinstance(exp, (Function, MatchFunction))
+        free = free_in(exp)
+        if name is not None and name in free:
+            free.remove(name)
+        fields = sorted(free)
+        fn_name = self.gensym(name if name else "fn")  # must be globally unique
+        return CompiledFunction(fn_name, params=["this", arg], fields=fields)
+
+    def compile_function_env(self, fn: CompiledFunction, name: Optional[str]) -> Env:
+        result = {param: param for param in fn.params}
+        if name is not None:
+            result[name] = "this"
+        for i, field in enumerate(fn.fields):
+            result[field] = self._mktemp(f"closure_get(this, {i})")
+        return result
+
+    def compile_function(self, env: Env, exp: Function, name: Optional[str]) -> str:
+        assert isinstance(exp.arg, Var)
+        fn = self.make_compiled_function(exp.arg.name, exp, name)
+        self.functions.append(fn)
+        cur = self.function
+        self.function = fn
+        funcenv = self.compile_function_env(fn, name)
+        val = self.compile(funcenv, exp.body)
+        fn.code.append(f"return {val};")
+        self.function = cur
+        return self.make_closure(env, fn)
+
+    def try_match(self, env: Env, arg: str, pattern: Object, fallthrough: str) -> Env:
+        if isinstance(pattern, Int):
+            self._emit(f"if (!is_num({arg})) {{ goto {fallthrough}; }}")
+            self._emit(f"if (num_value({arg}) != {pattern.value}) {{ goto {fallthrough}; }}")
+            return {}
+        if isinstance(pattern, Variant):
+            self.variant_tag(pattern.tag)  # register it for the big enum
+            self._emit(f"if (!is_variant({arg})) {{ goto {fallthrough}; }}")
+            self._emit(f"if (variant_tag({arg}) != Tag_{pattern.tag}) {{ goto {fallthrough}; }}")
+            return self.try_match(env, self._mktemp(f"variant_value({arg})"), pattern.value, fallthrough)
+
+        if isinstance(pattern, String):
+            self._emit(f"if (!is_string({arg})) {{ goto {fallthrough}; }}")
+            value = pattern.value
+            self._emit(
+                f"if (!string_equal_cstr_len({arg}, {json.dumps(value)}, {len(value)})) {{ goto {fallthrough}; }}"
+            )
+            return {}
+        if isinstance(pattern, Var):
+            return {pattern.name: arg}
+        if isinstance(pattern, List):
+            self._emit(f"if (!is_list({arg})) {{ goto {fallthrough}; }}")
+            updates = {}
+            the_list = arg
+            use_spread = False
+            for i, pattern_item in enumerate(pattern.items):
+                if isinstance(pattern_item, Spread):
+                    use_spread = True
+                    if pattern_item.name:
+                        updates[pattern_item.name] = the_list
+                    break
+                # Not enough elements
+                self._emit(f"if (is_empty_list({the_list})) {{ goto {fallthrough}; }}")
+                list_item = self._mktemp(f"list_first({the_list})")
+                updates.update(self.try_match(env, list_item, pattern_item, fallthrough))
+                the_list = self._mktemp(f"list_rest({the_list})")
+            if not use_spread:
+                # Too many elements
+                self._emit(f"if (!is_empty_list({the_list})) {{ goto {fallthrough}; }}")
+            return updates
+        raise NotImplementedError("try_match", pattern)
+
+    def compile_match_function(self, env: Env, exp: MatchFunction, name: Optional[str]) -> str:
+        arg = self.gensym()
+        fn = self.make_compiled_function(arg, exp, name)
+        self.functions.append(fn)
+        cur = self.function
+        self.function = fn
+        funcenv = self.compile_function_env(fn, name)
+        for i, case in enumerate(exp.cases):
+            fallthrough = f"case_{i+1}" if i < len(exp.cases) - 1 else "no_match"
+            env_updates = self.try_match(funcenv, arg, case.pattern, fallthrough)
+            case_result = self.compile({**funcenv, **env_updates}, case.body)
+            self._emit(f"return {case_result};")
+            self._emit(f"{fallthrough}:;")
+        # TODO(max): (non-fatal?) exceptions
+        self._emit(r'fprintf(stderr, "no matching cases\n");')
+        self._emit("abort();")
+        self.function = cur
+        return self.make_closure(env, fn)
+
+    def make_closure(self, env: Env, fn: CompiledFunction) -> str:
+        name = self._mktemp(f"mkclosure(heap, {fn.name}, {len(fn.fields)})")
+        for i, field in enumerate(fn.fields):
+            self._emit(f"closure_set({name}, {i}, {env[field]});")
+        self._debug("collect(heap);")
+        return name
+
+    def compile(self, env: Env, exp: Object) -> str:
+        if isinstance(exp, Int):
+            # TODO(max): Bignum
+            self._debug("collect(heap);")
+            return self._mktemp(f"mknum(heap, {exp.value})")
+        if isinstance(exp, Hole):
+            return self._mktemp("hole()")
+        if isinstance(exp, Variant):
+            self._debug("collect(heap);")
+            self.variant_tag(exp.tag)
+            value = self.compile(env, exp.value)
+            result = self._mktemp(f"mkvariant(heap, Tag_{exp.tag})")
+            self._emit(f"variant_set({result}, {value});")
+            return result
+        if isinstance(exp, String):
+            self._debug("collect(heap);")
+            string_repr = json.dumps(exp.value)
+            return self._mktemp(f"mkstring(heap, {string_repr}, {len(exp.value)});")
+        if isinstance(exp, Binop):
+            left = self.compile(env, exp.left)
+            right = self.compile(env, exp.right)
+            if exp.op == BinopKind.ADD:
+                self._debug("collect(heap);")
+                self._guard(f"is_num({left})")
+                self._guard(f"is_num({right})")
+                return self._mktemp(f"num_add({left}, {right})")
+            if exp.op == BinopKind.MUL:
+                self._debug("collect(heap);")
+                self._guard(f"is_num({left})")
+                self._guard(f"is_num({right})")
+                return self._mktemp(f"num_mul({left}, {right})")
+            if exp.op == BinopKind.SUB:
+                self._debug("collect(heap);")
+                self._guard(f"is_num({left})")
+                self._guard(f"is_num({right})")
+                return self._mktemp(f"num_sub({left}, {right})")
+            if exp.op == BinopKind.LIST_CONS:
+                self._debug("collect(heap);")
+                return self._mktemp(f"list_cons({left}, {right})")
+            if exp.op == BinopKind.STRING_CONCAT:
+                self._debug("collect(heap);")
+                self._guard(f"is_string({left})")
+                self._guard(f"is_string({right})")
+                return self._mktemp(f"string_concat({left}, {right})")
+            raise NotImplementedError(f"binop {exp.op}")
+        if isinstance(exp, Where):
+            assert isinstance(exp.binding, Assign)
+            res_env = self.compile_assign(env, exp.binding)
+            new_env = {**env, **res_env}
+            return self.compile(new_env, exp.body)
+        if isinstance(exp, Var):
+            var_value = env.get(exp.name)
+            if var_value is None:
+                raise NameError(f"name '{exp.name}' is not defined")
+            return var_value
+        if isinstance(exp, Apply):
+            if isinstance(exp.func, Var):
+                if exp.func.name == "runtime":
+                    assert isinstance(exp.arg, String)
+                    self.used_runtime_functions.add(exp.arg.value)
+                    return f"builtin_{exp.arg.value}"
+            callee = self.compile(env, exp.func)
+            arg = self.compile(env, exp.arg)
+            return self._mktemp(f"closure_call({callee}, {arg})")
+        if isinstance(exp, List):
+            items = [self.compile(env, item) for item in exp.items]
+            result = self._mktemp("empty_list()")
+            for item in reversed(items):
+                result = self._mktemp(f"list_cons({item}, {result})")
+            self._debug("collect(heap);")
+            return result
+        if isinstance(exp, Record):
+            values: Dict[str, str] = {}
+            for key, value_exp in exp.data.items():
+                values[key] = self.compile(env, value_exp)
+            result = self._mktemp(f"mkrecord(heap, {len(values)})")
+            for i, (key, value) in enumerate(values.items()):
+                key_idx = self.record_key(key)
+                self._emit(
+                    f"record_set({result}, /*index=*/{i}, (struct record_field){{.key={key_idx}, .value={value}}});"
+                )
+            self._debug("collect(heap);")
+            return result
+        if isinstance(exp, Access):
+            assert isinstance(exp.at, Var), f"only Var access is supported, got {type(exp.at)}"
+            record = self.compile(env, exp.obj)
+            key_idx = self.record_key(exp.at.name)
+            # Check if the record is a record
+            self._guard(f"is_record({record})", "not a record")
+            value = self._mktemp(f"record_get({record}, {key_idx})")
+            self._guard(f"{value} != NULL", f"missing key {exp.at.name!s}")
+            return value
+        if isinstance(exp, Function):
+            # Anonymous function
+            return self.compile_function(env, exp, name=None)
+        if isinstance(exp, MatchFunction):
+            # Anonymous match function
+            return self.compile_match_function(env, exp, name=None)
+        raise NotImplementedError(f"exp {type(exp)} {exp}")
+
+
+# TODO(max): Emit constants into the const heap
+# The const heap must only point within the const heap
+# The const heap will never be scanned
+# The const heap can be serialized to disk and mmap'd
+
+BUILTINS = [
+    "print",
+    "println",
+]
+
+
+def env_get_split(key: str, default: Optional[typing.List[str]] = None) -> typing.List[str]:
+    import shlex
+
+    cflags = os.environ.get(key)
+    if cflags:
+        return shlex.split(cflags)
+    if default:
+        return default
+    return []
+
+
+def compile_to_string(source: str, memory: int, debug: bool) -> str:
+    program = parse(tokenize(source))
+
+    main_fn = CompiledFunction("scrap_main", params=[])
+    compiler = Compiler(main_fn)
+    compiler.debug = debug
+    result = compiler.compile({}, program)
+    main_fn.code.append(f"return {result};")
+
+    builtins = [builtin for builtin in BUILTINS if builtin in compiler.used_runtime_functions]
+    for builtin in builtins:
+        fn = CompiledFunction(f"builtin_{builtin}_wrapper", params=["this", "arg"])
+        fn.code.append(f"return {builtin}(arg);")
+        compiler.functions.append(fn)
+
+    f = io.StringIO()
+    print('#include "runtime.c"', file=f)
+    print("#define OBJECT_HANDLE(name, exp) GC_HANDLE(struct object*, name, exp)", file=f)
+    # Declare all functions
+    print("const char* record_keys[] = {", file=f)
+    for key in compiler.record_keys:
+        print(f'"{key}",', file=f)
+    print("};", file=f)
+    if compiler.variant_tags:
+        print("const char* variant_names[] = {", file=f)
+        for key in compiler.variant_tags:
+            print(f'"{key}",', file=f)
+        print("};", file=f)
+        print("enum {", file=f)
+        for key, idx in compiler.variant_tags.items():
+            print(f"Tag_{key} = {idx},", file=f)
+        print("};", file=f)
+    for function in compiler.functions:
+        print(function.decl() + ";", file=f)
+    for builtin in builtins:
+        print(f"struct object* builtin_{builtin} = NULL;", file=f)
+    for function in compiler.functions:
+        print(f"{function.decl()} {{", file=f)
+        for line in function.code:
+            print(line, file=f)
+        print("}", file=f)
+    print("int main() {", file=f)
+    print(f"heap = make_heap({memory});", file=f)
+    print("HANDLES();", file=f)
+    for builtin in builtins:
+        print(f"builtin_{builtin} = mkclosure(heap, builtin_{builtin}_wrapper, 0);", file=f)
+        print(f"GC_PROTECT(builtin_{builtin});", file=f)
+    print(f"struct object* result = {main_fn.name}();", file=f)
+    print("println(result);", file=f)
+    print("destroy_heap(heap);", file=f)
+    print("}", file=f)
+    return f.getvalue()
+
+
+def discover_cflags(cc: typing.List[str], debug: bool = True) -> typing.List[str]:
+    default_cflags = ["-Wall", "-Wextra", "-fno-strict-aliasing"]
+    if debug:
+        default_cflags += ["-O0", "-ggdb"]
+    else:
+        default_cflags += ["-O2", "-DNDEBUG"]
+        if "cosmo" not in cc[0]:
+            # cosmocc does not support LTO
+            default_cflags.append("-flto")
+    return env_get_split("CFLAGS", default_cflags)
+
+
+def compile_to_binary(source: str, memory: int, debug: bool) -> str:
+    import shlex
+    import shutil
+    import subprocess
+    import sysconfig
+    import tempfile
+
+    cc = env_get_split("CC", shlex.split(sysconfig.get_config_var("CC")))
+    cflags = discover_cflags(cc, debug)
+    c_code = compile_to_string(source, memory, debug)
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".c", delete=False) as c_file:
+        outdir = os.path.dirname(c_file.name)
+        shutil.copy("runtime.c", outdir)
+        c_file.write(c_code)
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".out", delete=False) as out_file:
+        subprocess.run([*cc, *cflags, "-o", out_file.name, c_file.name], check=True)
+    return out_file.name
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(prog="scrapscript")
+    parser.add_argument("file")
+    parser.add_argument("-o", "--output", default="output.c")
+    parser.add_argument("--format", action="store_true")
+    parser.add_argument("--compile", action="store_true")
+    parser.add_argument("--memory", type=int, default=1024)
+    parser.add_argument("--run", action="store_true")
+    parser.add_argument("--debug", action="store_true", default=False)
+    args = parser.parse_args()
+
+    with open(args.file, "r") as f:
+        source = f.read()
+
+    c_program = compile_to_string(source, args.memory, args.debug)
+
+    with open(args.output, "w") as f:
+        f.write(c_program)
+
+    if args.format:
+        import subprocess
+
+        subprocess.run(["clang-format-15", "-i", args.output], check=True)
+
+    if args.compile:
+        import subprocess
+
+        cc = env_get_split("CC", ["clang"])
+        cflags = discover_cflags(cc, args.debug)
+        ldflags = env_get_split("LDFLAGS")
+        subprocess.run([*cc, "-o", "a.out", *cflags, args.output, *ldflags], check=True)
+
+    if args.run:
+        import subprocess
+
+        subprocess.run(["sh", "-c", "./a.out"], check=True)
+
+
+if __name__ == "__main__":
+    main()

compiler_tests.py

···
+import unittest
+import subprocess
+
+from compiler import compile_to_binary
+
+
+class CompilerEndToEndTests(unittest.TestCase):
+    def _run(self, code: str) -> str:
+        binary = compile_to_binary(code, memory=1024, debug=False)
+        result = subprocess.run(binary, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True)
+        return result.stdout
+
+    def test_int(self) -> None:
+        self.assertEqual(self._run("1"), "1\n")
+
+    def test_add(self) -> None:
+        self.assertEqual(self._run("1 + 2"), "3\n")
+
+    def test_sub(self) -> None:
+        self.assertEqual(self._run("1 - 2"), "-1\n")
+
+    def test_mul(self) -> None:
+        self.assertEqual(self._run("2 * 3"), "6\n")
+
+    def test_list(self) -> None:
+        self.assertEqual(self._run("[1, 2, 3]"), "[1, 2, 3]\n")
+
+    def test_var(self) -> None:
+        self.assertEqual(self._run("a . a = 1"), "1\n")
+
+    def test_record(self) -> None:
+        self.assertEqual(self._run("{a = 1, b = 2}"), "{a = 1, b = 2}\n")
+
+    def test_record_access(self) -> None:
+        self.assertEqual(self._run("rec@a . rec = {a = 1, b = 2}"), "1\n")
+
+    def test_hole(self) -> None:
+        self.assertEqual(self._run("()"), "()\n")
+
+    def test_variant(self) -> None:
+        self.assertEqual(self._run("# foo 123"), "#foo 123\n")
+
+    def test_function(self) -> None:
+        self.assertEqual(self._run("f 1 . f = x -> x + 1"), "2\n")
+
+    def test_match_int(self) -> None:
+        self.assertEqual(self._run("f 3 . f = | 1 -> 2 | 3 -> 4"), "4\n")
+
+    def test_match_list(self) -> None:
+        self.assertEqual(self._run("f [4, 5] . f = | [1, 2] -> 3 | [4, 5] -> 6"), "6\n")
+
+    @unittest.skip("TODO")
+    def test_match_record(self) -> None:
+        self.assertEqual(self._run("f {a = 4, b = 5} . f = | {a = 1, b = 2} -> 3 | {a = 4, b = 5} -> 6"), "6\n")
+
+
+if __name__ == "__main__":
+    unittest.main()

hooks/pre-commit

···
 # cat always has error code 0
 # ignore deleted files (can't be formatted)
 filenames=$(git diff --cached --name-only --diff-filter=d $against | grep '\.py$' | cat)
+# If changed files include scrapscript.py, run tests
+if echo $filenames | grep scrapscript.py
+then
+  ./scrapscript.py test
+fi
+
+# If there are any other changed Python files, make sure they lint
 if [ -n "$filenames" ]
 then
-  ./scrapscript.py test
   ruff format --check $filenames
+  ruff check $filenames
   mypy --strict $filenames
 fi

runtime.c

···
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#define ALWAYS_INLINE inline __attribute__((always_inline))
+#define NEVER_INLINE __attribute__((noinline))
+
+const int kPointerSize = sizeof(void*);
+typedef intptr_t word;
+typedef uintptr_t uword;
+
+// Garbage collector core by Andy Wingo <[e-mail]>.
+
+struct gc_obj {
+  uintptr_t tag;  // low bit is 0 if forwarding ptr
+  uintptr_t payload[0];
+};
+
+// The low bit of the pointer is 1 if it's a heap object and 0 if it's an
+// immediate integer
+struct object {};
+
+// Up to the five least significant bits are used to tag the object's layout.
+// The three low bits make up a primary tag, used to differentiate gc_obj
+// from immediate objects. All even tags map to SmallInt, which is
+// optimized by checking only the lowest bit for parity.
+static const uword kSmallIntTagBits = 1;
+static const uword kPrimaryTagBits = 3;
+static const uword kImmediateTagBits = 5;
+static const uword kSmallIntTagMask = (1 << kSmallIntTagBits) - 1;
+static const uword kPrimaryTagMask = (1 << kPrimaryTagBits) - 1;
+static const uword kImmediateTagMask = (1 << kImmediateTagBits) - 1;
+
+const int kWordSize = sizeof(word);
+static const word kMaxSmallStringLength = kWordSize - 1;
+const int kBitsPerByte = 8;
+
+static const uword kSmallIntTag = 0;      // 0b****0
+static const uword kHeapObjectTag = 1;    // 0b**001
+static const uword kEmptyListTag = 5;     // 0b00101
+static const uword kHoleTag = 7;          // 0b00111
+static const uword kSmallStringTag = 13;  // 0b01101
+
+bool is_small_int(struct object* obj) {
+  return (((uword)obj) & kSmallIntTagMask) == kSmallIntTag;
+}
+bool is_immediate_not_small_int(struct object* obj) {
+  return (((uword)obj) & (kPrimaryTagMask & ~kSmallIntTagMask)) != 0;
+}
+bool is_heap_object(struct object* obj) {
+  return (((uword)obj) & kPrimaryTagMask) == kHeapObjectTag;
+}
+struct object* empty_list() { return (struct object*)kEmptyListTag; }
+bool is_empty_list(struct object* obj) { return obj == empty_list(); }
+struct object* hole() { return (struct object*)kHoleTag; }
+bool is_hole(struct object* obj) {
+  return (((uword)obj) & kImmediateTagMask) == kHoleTag;
+}
+static ALWAYS_INLINE bool is_small_string(struct object* obj) {
+  return (((uword)obj) & kImmediateTagMask) == kSmallStringTag;
+}
+static ALWAYS_INLINE uword small_string_length(struct object* obj) {
+  assert(is_small_string(obj));
+  return (((uword)obj) >> kImmediateTagBits) & kMaxSmallStringLength;
+}
+static ALWAYS_INLINE struct object* mksmallstring(const char* data,
+                                                  uword length) {
+  assert(length >= 0);
+  assert(length <= kMaxSmallStringLength);
+  uword result = 0;
+  for (word i = length - 1; i >= 0; i--) {
+    result = (result << kBitsPerByte) | data[i];
+  }
+  struct object* result_obj =
+      (struct object*)((result << kBitsPerByte) |
+                       (length << kImmediateTagBits) | kSmallStringTag);
+  assert(!is_heap_object(result_obj));
+  assert(is_small_string(result_obj));
+  assert(small_string_length(result_obj) == length);
+  return result_obj;
+}
+static ALWAYS_INLINE char small_string_at(struct object* obj, uword index) {
+  assert(is_small_string(obj));
+  assert(index >= 0);
+  assert(index < small_string_length(obj));
+  // +1 for (length | tag) byte
+  return ((uword)obj >> ((index + 1) * kBitsPerByte)) & 0xFF;
+}
+struct gc_obj* as_heap_object(struct object* obj) {
+  assert(is_heap_object(obj));
+  assert(kHeapObjectTag == 1);
+  return (struct gc_obj*)((uword)obj - 1);
+}
+
+static const uintptr_t kNotForwardedBit = 1ULL;
+int is_forwarded(struct gc_obj* obj) {
+  return (obj->tag & kNotForwardedBit) == 0;
+}
+struct gc_obj* forwarded(struct gc_obj* obj) {
+  assert(is_forwarded(obj));
+  return (struct gc_obj*)obj->tag;
+}
+void forward(struct gc_obj* from, struct gc_obj* to) {
+  assert(!is_forwarded(from));
+  assert((((uintptr_t)to) & kNotForwardedBit) == 0);
+  from->tag = (uintptr_t)to;
+}
+
+struct gc_heap;
+
+typedef void (*VisitFn)(struct object**, struct gc_heap*);
+
+// To implement by the user:
+size_t heap_object_size(struct gc_obj* obj);
+size_t trace_heap_object(struct gc_obj* obj, struct gc_heap* heap,
+                         VisitFn visit);
+void trace_roots(struct gc_heap* heap, VisitFn visit);
+
+struct gc_heap {
+  uintptr_t hp;
+  uintptr_t limit;
+  uintptr_t from_space;
+  uintptr_t to_space;
+  size_t size;
+};
+
+static uintptr_t align(uintptr_t val, uintptr_t alignment) {
+  return (val + alignment - 1) & ~(alignment - 1);
+}
+static uintptr_t align_size(uintptr_t size) {
+  return align(size, sizeof(uintptr_t));
+}
+
+static struct gc_heap* make_heap(size_t size) {
+  size = align(size, getpagesize());
+  struct gc_heap* heap = malloc(sizeof(struct gc_heap));
+  void* mem = mmap(NULL, size, PROT_READ | PROT_WRITE,
+                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  heap->to_space = heap->hp = (uintptr_t)mem;
+  heap->from_space = heap->limit = heap->hp + size / 2;
+  heap->size = size;
+  return heap;
+}
+
+void destroy_heap(struct gc_heap* heap) {
+  munmap((void*)heap->to_space, heap->size);
+  free(heap);
+}
+
+struct gc_obj* copy(struct gc_heap* heap, struct gc_obj* obj) {
+  size_t size = heap_object_size(obj);
+  struct gc_obj* new_obj = (struct gc_obj*)heap->hp;
+  memcpy(new_obj, obj, size);
+  forward(obj, new_obj);
+  heap->hp += align_size(size);
+  return new_obj;
+}
+
+void flip(struct gc_heap* heap) {
+  heap->hp = heap->from_space;
+  heap->from_space = heap->to_space;
+  heap->to_space = heap->hp;
+  heap->limit = heap->hp + heap->size / 2;
+}
+
+struct object* heap_tag(uintptr_t addr) {
+  return (struct object*)(addr | (uword)1ULL);
+}
+
+void visit_field(struct object** pointer, struct gc_heap* heap) {
+  if (!is_heap_object(*pointer)) {
+    return;
+  }
+  struct gc_obj* from = as_heap_object(*pointer);
+  struct gc_obj* to = is_forwarded(from) ? forwarded(from) : copy(heap, from);
+  *pointer = heap_tag((uintptr_t)to);
+}
+
+void collect(struct gc_heap* heap) {
+  flip(heap);
+  uintptr_t scan = heap->hp;
+  trace_roots(heap, visit_field);
+  while (scan < heap->hp) {
+    struct gc_obj* obj = (struct gc_obj*)scan;
+    scan += align_size(trace_heap_object(obj, heap, visit_field));
+  }
+#ifndef NDEBUG
+  // Zero out the rest of the heap for debugging
+  memset((void*)scan, 0, heap->limit - scan);
+#endif
+}
+
+#define LIKELY(x) __builtin_expect(!!(x), 1)
+#define UNLIKELY(x) __builtin_expect(!!(x), 0)
+#define ALLOCATOR __attribute__((__malloc__))
+
+static NEVER_INLINE ALLOCATOR struct object* allocate_slow_path(
+    struct gc_heap* heap, size_t size) {
+  // size is already aligned
+  collect(heap);
+  if (UNLIKELY(heap->limit - heap->hp < size)) {
+    fprintf(stderr, "out of memory\n");
+    abort();
+  }
+  uintptr_t addr = heap->hp;
+  uintptr_t new_hp = align_size(addr + size);
+  heap->hp = new_hp;
+  return heap_tag(addr);
+}
+
+static ALWAYS_INLINE ALLOCATOR struct object* allocate(struct gc_heap* heap,
+                                                       size_t size) {
+  uintptr_t addr = heap->hp;
+  uintptr_t new_hp = align_size(addr + size);
+  if (UNLIKELY(heap->limit < new_hp)) {
+    return allocate_slow_path(heap, size);
+  }
+  heap->hp = new_hp;
+  return heap_tag(addr);
+}
+
+// Application
+
+#define FOREACH_TAG(TAG)                                                       \
+  TAG(TAG_LIST)                                                                \
+  TAG(TAG_CLOSURE)                                                             \
+  TAG(TAG_RECORD)                                                              \
+  TAG(TAG_STRING)                                                              \
+  TAG(TAG_VARIANT)
+
+enum {
+// All odd becase of the kNotForwardedBit
+#define ENUM_TAG(TAG) TAG = __COUNTER__ * 2 + 1,
+  FOREACH_TAG(ENUM_TAG)
+#undef ENUM_TAG
+};
+
+struct list {
+  struct gc_obj HEAD;
+  struct object* first;
+  struct object* rest;
+};
+
+typedef struct object* (*ClosureFn)(struct object*, struct object*);
+
+// TODO(max): Figure out if there is a way to do a PyObject_HEAD version of
+// this where each closure actually has its own struct with named members
+struct closure {
+  struct gc_obj HEAD;
+  ClosureFn fn;
+  size_t size;
+  struct object* env[];
+};
+
+struct record_field {
+  size_t key;
+  struct object* value;
+};
+
+struct record {
+  struct gc_obj HEAD;
+  size_t size;
+  struct record_field fields[];
+};
+
+struct heap_string {
+  struct gc_obj HEAD;
+  size_t size;
+  char data[];
+};
+
+struct variant {
+  struct gc_obj HEAD;
+  size_t tag;
+  struct object* value;
+};
+
+size_t variable_size(size_t base, size_t count) {
+  return base + count * kPointerSize;
+}
+
+size_t record_size(size_t count) {
+  return sizeof(struct record) + count * sizeof(struct record_field);
+}
+
+size_t heap_string_size(size_t count) {
+  return sizeof(struct heap_string) + count;
+}
+
+size_t heap_object_size(struct gc_obj* obj) {
+  switch (obj->tag) {
+    case TAG_LIST:
+      return sizeof(struct list);
+    case TAG_CLOSURE:
+      return variable_size(sizeof(struct closure),
+                           ((struct closure*)obj)->size);
+    case TAG_RECORD:
+      return record_size(((struct record*)obj)->size);
+    case TAG_STRING:
+      return heap_string_size(((struct heap_string*)obj)->size);
+    case TAG_VARIANT:
+      return sizeof(struct variant);
+    default:
+      fprintf(stderr, "unknown tag: %lu\n", obj->tag);
+      abort();
+  }
+}
+
+size_t trace_heap_object(struct gc_obj* obj, struct gc_heap* heap,
+                         VisitFn visit) {
+  switch (obj->tag) {
+    case TAG_LIST:
+      visit(&((struct list*)obj)->first, heap);
+      visit(&((struct list*)obj)->rest, heap);
+      break;
+    case TAG_CLOSURE:
+      for (size_t i = 0; i < ((struct closure*)obj)->size; i++) {
+        visit(&((struct closure*)obj)->env[i], heap);
+      }
+      break;
+    case TAG_RECORD:
+      for (size_t i = 0; i < ((struct record*)obj)->size; i++) {
+        visit(&((struct record*)obj)->fields[i].value, heap);
+      }
+      break;
+    case TAG_STRING:
+      break;
+    case TAG_VARIANT:
+      visit(&((struct variant*)obj)->value, heap);
+      break;
+    default:
+      fprintf(stderr, "unknown tag: %lu\n", obj->tag);
+      abort();
+  }
+  return heap_object_size(obj);
+}
+
+const int kBitsPerPointer = kBitsPerByte * kWordSize;
+static const word kSmallIntBits = kBitsPerPointer - kSmallIntTagBits;
+static const word kSmallIntMinValue = -(((word)1) << (kSmallIntBits - 1));
+static const word kSmallIntMaxValue = (((word)1) << (kSmallIntBits - 1)) - 1;
+
+bool smallint_is_valid(word value) {
+  return (value >= kSmallIntMinValue) && (value <= kSmallIntMaxValue);
+}
+
+struct object* mknum(struct gc_heap* heap, word value) {
+  (void)heap;
+  assert(smallint_is_valid(value));
+  return (struct object*)(((uword)value << kSmallIntTagBits));
+}
+
+bool is_num(struct object* obj) { return is_small_int(obj); }
+
+word num_value(struct object* obj) {
+  assert(is_num(obj));
+  return ((word)obj) >> 1;  // sign extend
+}
+
+bool is_list(struct object* obj) {
+  if (is_empty_list(obj)) {
+    return true;
+  }
+  return is_heap_object(obj) && as_heap_object(obj)->tag == TAG_LIST;
+}
+
+struct list* as_list(struct object* obj) {
+  assert(is_list(obj));
+  return (struct list*)as_heap_object(obj);
+}
+
+struct object* list_first(struct object* obj) {
+  assert(!is_empty_list(obj));
+  return as_list(obj)->first;
+}
+
+struct object* list_rest(struct object* list) {
+  assert(!is_empty_list(list));
+  return as_list(list)->rest;
+}
+
+struct object* mklist(struct gc_heap* heap) {
+  struct object* result = allocate(heap, sizeof(struct list));
+  as_heap_object(result)->tag = TAG_LIST;
+  as_list(result)->first = empty_list();
+  as_list(result)->rest = empty_list();
+  return result;
+}
+
+bool is_closure(struct object* obj) {
+  return is_heap_object(obj) && as_heap_object(obj)->tag == TAG_CLOSURE;
+}
+
+struct closure* as_closure(struct object* obj) {
+  assert(is_closure(obj));
+  return (struct closure*)as_heap_object(obj);
+}
+
+struct object* mkclosure(struct gc_heap* heap, ClosureFn fn, size_t size) {
+  struct object* result =
+      allocate(heap, variable_size(sizeof(struct closure), size));
+  as_heap_object(result)->tag = TAG_CLOSURE;
+  as_closure(result)->fn = fn;
+  as_closure(result)->size = size;
+  // Assumes the items will be filled in immediately after calling mkclosure so
+  // they are not initialized
+  return result;
+}
+
+ClosureFn closure_fn(struct object* obj) { return as_closure(obj)->fn; }
+
+void closure_set(struct object* closure, size_t i, struct object* item) {
+  struct closure* c = as_closure(closure);
+  assert(i < c->size);
+  c->env[i] = item;
+}
+
+struct object* closure_get(struct object* closure, size_t i) {
+  struct closure* c = as_closure(closure);
+  assert(i < c->size);
+  return c->env[i];
+}
+
+struct object* closure_call(struct object* closure, struct object* arg) {
+  ClosureFn fn = closure_fn(closure);
+  return fn(closure, arg);
+}
+
+bool is_record(struct object* obj) {
+  return is_heap_object(obj) && as_heap_object(obj)->tag == TAG_RECORD;
+}
+
+struct record* as_record(struct object* obj) {
+  assert(is_record(obj));
+  return (struct record*)as_heap_object(obj);
+}
+
+struct object* mkrecord(struct gc_heap* heap, size_t size) {
+  // size is the number of fields, each of which has an index and a value
+  // (object)
+  struct object* result = allocate(heap, record_size(size));
+  as_heap_object(result)->tag = TAG_RECORD;
+  as_record(result)->size = size;
+  // Assumes the items will be filled in immediately after calling mkrecord so
+  // they are not initialized
+  return result;
+}
+
+void record_set(struct object* record, size_t index,
+                struct record_field field) {
+  struct record* r = as_record(record);
+  assert(index < r->size);
+  r->fields[index] = field;
+}
+
+struct object* record_get(struct object* record, size_t key) {
+  struct record* r = as_record(record);
+  struct record_field* fields = r->fields;
+  for (size_t i = 0; i < r->size; i++) {
+    struct record_field field = fields[i];
+    if (field.key == key) {
+      return field.value;
+    }
+  }
+  return NULL;
+}
+
+bool is_string(struct object* obj) {
+  if (is_small_string(obj)) {
+    return true;
+  }
+  return is_heap_object(obj) && as_heap_object(obj)->tag == TAG_STRING;
+}
+
+struct heap_string* as_heap_string(struct object* obj) {
+  assert(is_string(obj));
+  return (struct heap_string*)as_heap_object(obj);
+}
+
+struct object* mkstring_uninit_private(struct gc_heap* heap, size_t size) {
+  assert(size > kMaxSmallStringLength);  // can't fill in small string later
+  struct object* result = allocate(heap, heap_string_size(size));
+  as_heap_object(result)->tag = TAG_STRING;
+  as_heap_string(result)->size = size;
+  return result;
+}
+
+struct object* mkstring(struct gc_heap* heap, const char* data, uword length) {
+  if (length <= kMaxSmallStringLength) {
+    return mksmallstring(data, length);
+  }
+  struct object* result = mkstring_uninit_private(heap, length);
+  memcpy(as_heap_string(result)->data, data, length);
+  return result;
+}
+
+static ALWAYS_INLINE uword string_length(struct object* obj) {
+  if (is_small_string(obj)) {
+    return small_string_length(obj);
+  }
+  return as_heap_string(obj)->size;
+}
+
+char string_at(struct object* obj, uword index) {
+  if (is_small_string(obj)) {
+    return small_string_at(obj, index);
+  }
+  return as_heap_string(obj)->data[index];
+}
+
+bool is_variant(struct object* obj) {
+  return is_heap_object(obj) && as_heap_object(obj)->tag == TAG_VARIANT;
+}
+
+struct variant* as_variant(struct object* obj) {
+  assert(is_variant(obj));
+  return (struct variant*)as_heap_object(obj);
+}
+
+struct object* mkvariant(struct gc_heap* heap, size_t tag) {
+  struct object* result = allocate(heap, sizeof(struct variant));
+  as_heap_object(result)->tag = TAG_VARIANT;
+  as_variant(result)->tag = tag;
+  return result;
+}
+
+size_t variant_tag(struct object* obj) { return as_variant(obj)->tag; }
+
+struct object* variant_value(struct object* obj) {
+  return as_variant(obj)->value;
+}
+
+void variant_set(struct object* variant, struct object* value) {
+  as_variant(variant)->value = value;
+}
+
+#define MAX_HANDLES 20
+
+struct handles {
+  // TODO(max): Figure out how to make this a flat linked list with whole
+  // chunks popped off at function return
+  struct object** stack[MAX_HANDLES];
+  size_t stack_pointer;
+  struct handles* next;
+};
+
+static struct handles* handles = NULL;
+
+void pop_handles(void* local_handles) {
+  (void)local_handles;
+  handles = handles->next;
+}
+
+#define HANDLES()                                                              \
+  struct handles local_handles                                                 \
+      __attribute__((__cleanup__(pop_handles))) = {.next = handles};           \
+  handles = &local_handles
+#define GC_PROTECT(x)                                                          \
+  assert(local_handles.stack_pointer < MAX_HANDLES);                           \
+  local_handles.stack[local_handles.stack_pointer++] = (struct object**)(&x)
+#define END_HANDLES() handles = local_handles.next
+#define GC_HANDLE(type, name, val)                                             \
+  type name = val;                                                             \
+  GC_PROTECT(name)
+
+void trace_roots(struct gc_heap* heap, VisitFn visit) {
+  for (struct handles* h = handles; h; h = h->next) {
+    for (size_t i = 0; i < h->stack_pointer; i++) {
+      visit(h->stack[i], heap);
+    }
+  }
+}
+
+static struct gc_heap* heap = NULL;
+
+struct object* num_add(struct object* a, struct object* b) {
+  // NB: doesn't use pointers after allocating
+  return mknum(heap, num_value(a) + num_value(b));
+}
+
+struct object* num_sub(struct object* a, struct object* b) {
+  // NB: doesn't use pointers after allocating
+  return mknum(heap, num_value(a) - num_value(b));
+}
+
+struct object* num_mul(struct object* a, struct object* b) {
+  // NB: doesn't use pointers after allocating
+  return mknum(heap, num_value(a) * num_value(b));
+}
+
+struct object* list_cons(struct object* item, struct object* list) {
+  HANDLES();
+  GC_PROTECT(item);
+  GC_PROTECT(list);
+  struct object* result = mklist(heap);
+  as_list(result)->first = item;
+  as_list(result)->rest = list;
+  return result;
+}
+
+struct object* heap_string_concat(struct object* a, struct object* b) {
+  uword a_size = string_length(a);
+  uword b_size = string_length(b);
+  assert(a_size + b_size > kMaxSmallStringLength);
+  HANDLES();
+  GC_PROTECT(a);
+  GC_PROTECT(b);
+  struct object* result = mkstring_uninit_private(heap, a_size + b_size);
+  for (uword i = 0; i < a_size; i++) {
+    as_heap_string(result)->data[i] = string_at(a, i);
+  }
+  for (uword i = 0; i < b_size; i++) {
+    as_heap_string(result)->data[a_size + i] = string_at(b, i);
+  }
+  return result;
+}
+
+static ALWAYS_INLINE struct object* small_string_concat(struct object* a,
+                                                        struct object* b) {
+  uword a_size = string_length(a);
+  uword b_size = string_length(b);
+  assert(a_size + b_size <= kMaxSmallStringLength);
+  char data[kMaxSmallStringLength];
+  for (uword i = 0; i < a_size; i++) {
+    data[i] = small_string_at(a, i);
+  }
+  for (uword i = 0; i < b_size; i++) {
+    data[a_size + i] = small_string_at(b, i);
+  }
+  return mksmallstring(data, a_size + b_size);
+}
+
+struct object* string_concat(struct object* a, struct object* b) {
+  uword a_size = string_length(a);
+  if (a_size == 0) {
+    return b;
+  }
+  uword b_size = string_length(b);
+  if (b_size == 0) {
+    return a;
+  }
+  if (a_size + b_size <= kMaxSmallStringLength) {
+    return small_string_concat(a, b);
+  }
+  return heap_string_concat(a, b);
+}
+
+bool string_equal_cstr_len(struct object* string, const char* cstr, uword len) {
+  assert(is_string(string));
+  if (string_length(string) != len) {
+    return false;
+  }
+  for (uword i = 0; i < len; i++) {
+    if (string_at(string, i) != cstr[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+const char* record_keys[];
+const char* variant_names[];
+
+struct object* print(struct object* obj) {
+  if (is_num(obj)) {
+    printf("%ld", num_value(obj));
+  } else if (is_list(obj)) {
+    putchar('[');
+    while (!is_empty_list(obj)) {
+      print(list_first(obj));
+      obj = list_rest(obj);
+      if (!is_empty_list(obj)) {
+        putchar(',');
+        putchar(' ');
+      }
+    }
+    putchar(']');
+  } else if (is_record(obj)) {
+    struct record* record = as_record(obj);
+    putchar('{');
+    for (size_t i = 0; i < record->size; i++) {
+      printf("%s = ", record_keys[record->fields[i].key]);
+      print(record->fields[i].value);
+      if (i + 1 < record->size) {
+        fputs(", ", stdout);
+      }
+    }
+    putchar('}');
+  } else if (is_closure(obj)) {
+    fputs("<closure>", stdout);
+  } else if (is_string(obj)) {
+    putchar('"');
+    for (uword i = 0; i < string_length(obj); i++) {
+      putchar(string_at(obj, i));
+    }
+    putchar('"');
+  } else if (is_variant(obj)) {
+    putchar('#');
+    printf("%s ", variant_names[variant_tag(obj)]);
+    print(variant_value(obj));
+  } else if (is_hole(obj)) {
+    fputs("()", stdout);
+  } else {
+    assert(is_heap_object(obj));
+    fprintf(stderr, "unknown tag: %lu\n", as_heap_object(obj)->tag);
+    abort();
+  }
+  return obj;
+}
+
+struct object* println(struct object* obj) {
+  print(obj);
+  putchar('\n');
+  return obj;
+}