Allocate a separate const heap (#159)

Allocate the memory in a separate section, `const_heap`, and don't visit
it during GC.

Output constant objects at the top level for `[1,2,3]` look like:

```c
CONST_HEAP struct list const_list_0 = {
.HEAD.tag = TAG_LIST,
.first = (struct object*)(((uword)3 << kSmallIntTagBits)),
.rest = ((struct object*)kEmptyListTag)};
CONST_HEAP struct list const_list_1 = {
.HEAD.tag = TAG_LIST,
.first = (struct object*)(((uword)2 << kSmallIntTagBits)),
.rest = ptrto(const_list_0)};
CONST_HEAP struct list const_list_2 = {
.HEAD.tag = TAG_LIST,
.first = (struct object*)(((uword)1 << kSmallIntTagBits)),
.rest = ptrto(const_list_1)};
```

Fix #157.

compiler.py

···
         self.record_builders: Dict[Tuple[str, ...], CompiledFunction] = {}
         self.variant_tags: Dict[str, int] = {}
         self.debug: bool = False
+        self.const_heap: typing.List[str] = []
 
     def record_key(self, key: str) -> str:
         if key not in self.record_keys:
···
         val = self.compile(funcenv, exp.body)
         fn.code.append(f"return {val};")
         self.function = cur
+        if not fn.fields:
+            # TODO(max): Closure over freevars but only consts
+            return self._const_closure(fn)
         return self.make_closure(env, fn)
 
     def try_match(self, env: Env, arg: str, pattern: Object, fallthrough: str) -> Env:
···
         # Pacify the C compiler
         self._emit("return NULL;")
         self.function = cur
+        if not fn.fields:
+            # TODO(max): Closure over freevars but only consts
+            return self._const_closure(fn)
         return self.make_closure(env, fn)
 
     def make_closure(self, env: Env, fn: CompiledFunction) -> str:
···
         self._debug("collect(heap);")
         return name
 
+    def _is_const(self, exp: Object) -> bool:
+        if isinstance(exp, Int):
+            return True
+        if isinstance(exp, String):
+            return True
+        if isinstance(exp, Variant):
+            return self._is_const(exp.value)
+        if isinstance(exp, Record):
+            return all(self._is_const(value) for value in exp.data.values())
+        if isinstance(exp, List):
+            return all(self._is_const(item) for item in exp.items)
+        if isinstance(exp, Hole):
+            return True
+        if isinstance(exp, Function) and len(free_in(exp)) == 0:
+            return True
+        return False
+
+    def _const_obj(self, type: str, tag: str, contents: str) -> str:
+        result = self.gensym(f"const_{type}")
+        self.const_heap.append(f"CONST_HEAP struct {type} {result} = {{.HEAD.tag={tag}, {contents} }};")
+        return f"ptrto({result})"
+
+    def _const_cons(self, first: str, rest: str) -> str:
+        return self._const_obj("list", "TAG_LIST", f".first={first}, .rest={rest}")
+
+    def _const_closure(self, fn: CompiledFunction) -> str:
+        assert len(fn.fields) == 0
+        return self._const_obj("closure", "TAG_CLOSURE", f".fn={fn.name}, .size=0")
+
+    def _emit_const(self, exp: Object) -> str:
+        assert self._is_const(exp), f"not a constant {exp}"
+        if isinstance(exp, Hole):
+            return "((struct object*)kHoleTag)"
+        if isinstance(exp, Int):
+            # TODO(max): Bignum
+            return f"(struct object*)(((uword){exp.value} << kSmallIntTagBits))"
+        if isinstance(exp, List):
+            items = [self._emit_const(item) for item in exp.items]
+            result = "((struct object*)kEmptyListTag)"
+            for item in reversed(items):
+                result = self._const_cons(item, result)
+            return result
+        if isinstance(exp, String):
+            if len(exp.value) < 8:
+                raise NotImplementedError("small strings")
+            return self._const_obj(
+                "heap_string", "TAG_STRING", f".size={len(exp.value)}, .data={json.dumps(exp.value)}"
+            )
+        if isinstance(exp, Variant):
+            self.variant_tag(exp.tag)
+            value = self._emit_const(exp.value)
+            return self._const_obj("variant", "TAG_VARIANT", f".tag=Tag_{exp.tag}, .value={value}")
+        if isinstance(exp, Record):
+            values = {self.record_key(key): self._emit_const(value) for key, value in exp.data.items()}
+            fields = ",\n".join(f"{{.key={key}, .value={value} }}" for key, value in values.items())
+            return self._const_obj("record", "TAG_RECORD", f".size={len(values)}, .fields={{ {fields} }}")
+        if isinstance(exp, Function):
+            assert len(free_in(exp)) == 0, "only constant functions can be constified"
+            return self.compile_function({}, exp, name=None)
+        raise NotImplementedError(f"const {exp}")
+
     def compile(self, env: Env, exp: Object) -> str:
+        if self._is_const(exp):
+            return self._emit_const(exp)
         if isinstance(exp, Int):
             # TODO(max): Bignum
             self._debug("collect(heap);")
···
     # Declare all functions
     for function in compiler.functions:
         print(function.decl() + ";", file=f)
+    # Emit the const heap
+    print("#define ptrto(obj) ((struct object*)((uword)&(obj) + 1))", file=f)
+    print('#define CONST_HEAP __attribute__((section("const_heap")))', file=f)
+    for line in compiler.const_heap:
+        print(line, file=f)
     for function in compiler.functions:
         print(f"{function.decl()} {{", file=f)
         for line in function.code:

compiler_tests.py

···
     def test_record(self) -> None:
         self.assertEqual(self._run("{a = 1, b = 2}"), "{a = 1, b = 2}\n")
 
+    def test_record_builder(self) -> None:
+        self.assertEqual(self._run("f 1 2 . f = x -> y -> {a = x, b = y}"), "{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_record_builder_access(self) -> None:
+        self.assertEqual(self._run("(f 1 2)@a . f = x -> y -> {a = x, b = y}"), "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_variant_builder(self) -> None:
+        self.assertEqual(self._run("f 123 . f = x -> # foo x"), "#foo 123\n")
+
     def test_function(self) -> None:
         self.assertEqual(self._run("f 1 . f = x -> x + 1"), "2\n")
 
+    def test_anonymous_function_as_value(self) -> None:
+        self.assertEqual(self._run("x -> x"), "<closure>\n")
+
+    def test_anonymous_function(self) -> None:
+        self.assertEqual(self._run("((x -> x + 1) 1)"), "2\n")
+
     def test_match_int(self) -> None:
         self.assertEqual(self._run("f 3 . f = | 1 -> 2 | 3 -> 4"), "4\n")
 
-    @unittest.skipIf("tcc" in os.environ.get("CC", ""), "TODO(max): Fix; TCC emits crashy code")
     def test_match_list(self) -> None:
         self.assertEqual(self._run("f [4, 5] . f = | [1, 2] -> 3 | [4, 5] -> 6"), "6\n")
 

runtime.c

···
   return (struct object*)(addr | (uword)1ULL);
 }
 
+#ifdef __TINYC__
+// libc defines __attribute__ as an empty macro if the compiler is not GCC or
+// GCC < 2. We know tcc has supported __attribute__(section(...)) for 20+ years
+// so we can undefine it.
+// See tinycc-devel: https://lists.nongnu.org/archive/html/tinycc-devel/2018-04/msg00008.html
+// and my StackOverflow question: https://stackoverflow.com/q/78638571/569183
+#undef __attribute__
+#endif
+
+extern char __start_const_heap[];
+extern char __stop_const_heap[];
+
+bool in_const_heap(struct gc_obj* obj) {
+  return (uword)obj >= (uword)__start_const_heap &&
+         (uword)obj < (uword)__stop_const_heap;
+}
+
 void visit_field(struct object** pointer, struct gc_heap* heap) {
   if (!is_heap_object(*pointer)) {
     return;
   }
   struct gc_obj* from = as_heap_object(*pointer);
+  if (in_const_heap(from)) {
+    return;
+  }
   struct gc_obj* to = is_forwarded(from) ? forwarded(from) : copy(heap, from);
   *pointer = heap_tag((uintptr_t)to);
 }
···
   putchar('\n');
   return obj;
 }
+
+// Put something in the const heap so that __start_const_heap and
+// __stop_const_heap are defined by the linker.
+__attribute__((section("const_heap"), used)) struct heap_string private_unused_const_heap = {
+    .HEAD.tag = TAG_STRING, .size = 11, .data = "hello world"
+};