Support chibicc

This requires moving constants out of globals and into defines. To make
this more flexible---we've changed back and forth a couple of times
now---define the constants in Python and print them into the runtime.

compiler.py

···
     main_fn.code.append(f"return {result};")
 
     f = io.StringIO()
+    constants = [
+        ("uword", "kKiB", 1024),
+        ("uword", "kMiB", "kKiB * kKiB"),
+        ("uword", "kGiB", "kKiB * kKiB * kKiB"),
+        ("uword", "kPageSize", "4 * kKiB"),
+        ("uword", "kSmallIntTagBits", 1),
+        ("uword", "kPrimaryTagBits", 3),
+        ("uword", "kImmediateTagBits", 5),
+        ("uword", "kSmallIntTagMask", "(1 << kSmallIntTagBits) - 1"),
+        ("uword", "kPrimaryTagMask", "(1 << kPrimaryTagBits) - 1"),
+        ("uword", "kImmediateTagMask", "(1 << kImmediateTagBits) - 1"),
+        ("uword", "kWordSize", "sizeof(word)"),
+        ("uword", "kMaxSmallStringLength", "kWordSize - 1"),
+        ("uword", "kBitsPerByte", 8),
+        # 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.
+        ("uword", "kSmallIntTag", 0),  # 0b****0
+        ("uword", "kHeapObjectTag", 1),  # 0b**001
+        ("uword", "kEmptyListTag", 5),  # 0b00101
+        ("uword", "kHoleTag", 7),  # 0b00111
+        ("uword", "kSmallStringTag", 13),  # 0b01101
+        ("uword", "kBitsPerPointer", "kBitsPerByte * kWordSize"),
+        ("word", "kSmallIntBits", "kBitsPerPointer - kSmallIntTagBits"),
+        ("word", "kSmallIntMinValue", "-(((word)1) << (kSmallIntBits - 1))"),
+        ("word", "kSmallIntMaxValue", "(((word)1) << (kSmallIntBits - 1)) - 1"),
+    ]
+    for type_, name, value in constants:
+        print(f"#define {name} ({type_})({value})", file=f)
     # The runtime is in the same directory as this file
     dirname = os.path.dirname(__file__)
     with open(os.path.join(dirname, "runtime.c"), "r") as runtime:
         print(runtime.read(), 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.record_keys:
+        print("const char* record_keys[] = {", file=f)
+        for key in compiler.record_keys:
+            print(f'"{key}",', file=f)
+        print("};", file=f)
         print("enum {", file=f)
         for key, idx in compiler.record_keys.items():
             print(f"Record_{key} = {idx},", file=f)
         print("};", file=f)
+    else:
+        # Pacify the C compiler
+        print("const char* record_keys[] = { NULL };", file=f)
     if compiler.variant_tags:
         print("const char* variant_names[] = {", file=f)
         for key in compiler.variant_tags:
···
     else:
         # Pacify the C compiler
         print("const char* variant_names[] = { NULL };", file=f)
+    # Declare all functions
     for function in compiler.functions:
         print(function.decl() + ";", file=f)
     for function in compiler.functions:

compiler_tests.py

···
     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

···
   uintptr_t payload[0];
 };
 
-const uword kKiB = 1024;
-const uword kMiB = kKiB * kKiB;
-const uword kGiB = kKiB * kKiB * kKiB;
-
-const uword kPageSize = 4 * kKiB;
-
 // 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;
-
-static const uword kWordSize = sizeof(word);
-static const uword kMaxSmallStringLength = kWordSize - 1;
-static const uword 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
+struct object;
 
 bool is_small_int(struct object* obj) {
   return (((uword)obj) & kSmallIntTagMask) == kSmallIntTag;
···
 #endif
 }
 
+#if defined(__builtin_expect)
 #define LIKELY(x) __builtin_expect(!!(x), 1)
 #define UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define LIKELY(x) x
+#define UNLIKELY(x) x
+#endif
 #define ALLOCATOR __attribute__((__malloc__))
 
 static NEVER_INLINE ALLOCATOR struct object* allocate_slow_path(
···
   }
   return heap_object_size(obj);
 }
-
-static const uword 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);