test a few things

tests/compiler/std/gc-integration.ts

@@ -17,5 +17,3 @@ var b_ref: B = changetype<B>(32);           // global root, non-nullable
 var i: i32 = 0;
 __rt_iterateroots((ref: usize): void => { assert(<u32>ref == ++i << 3); });
 assert(i == 4);
-
-assert(__rt_classid<A>() != __rt_classid<B>());

tests/compiler/std/gc-integration.untouched.wat

@@ -58,18 +58,6 @@
    call $~lib/env/abort
    unreachable
   end
-  i32.const 43
-  i32.const 44
-  i32.ne
-  i32.eqz
-  if
-   i32.const 0
-   i32.const 8
-   i32.const 21
-   i32.const 0
-   call $~lib/env/abort
-   unreachable
-  end
  )
  (func $start (; 3 ;) (type $FUNCSIG$v)
   call $start:std/gc-integration

tests/compiler/std/runtime.ts

@@ -0,0 +1,60 @@
+import "allocator/tlsf";
+import {
+  HEADER,
+  HEADER_SIZE,
+  HEADER_MAGIC,
+  ALIGN,
+  ALLOC,
+  REALLOC,
+  FREE,
+  REGISTER
+} from "internal/runtime";
+
+class A {}
+class B {}
+assert(__rt_classid<A>() != __rt_classid<B>());
+
+function isPowerOf2(x: i32): bool {
+  return x != 0 && (x & (x - 1)) == 0;
+}
+
+assert(ALIGN(0) > 0);
+for (let i = 0; i < 9000; ++i) {
+  assert(isPowerOf2(ALIGN(i)));
+}
+
+var barrier1 = ALIGN(0);
+var barrier2 = barrier1 + 1;
+while (ALIGN(barrier2 + 1) == ALIGN(barrier2)) ++barrier2;
+var barrier3 = barrier2 + 1;
+while (ALIGN(barrier3 + 1) == ALIGN(barrier3)) ++barrier3;
+
+trace("barrier1", 1, barrier1);
+trace("barrier2", 1, barrier2);
+trace("barrier3", 1, barrier3);
+
+var ref1 = ALLOC(1);
+var header1 = changetype<HEADER>(ref1 - HEADER_SIZE);
+assert(header1.classId == HEADER_MAGIC);
+assert(header1.payloadSize == 1);
+assert(ref1 == REALLOC(ref1, barrier1)); // same segment
+assert(header1.payloadSize == barrier1);
+var ref2 = REALLOC(ref1, barrier2);
+assert(ref1 != ref2); // moves
+var header2 = changetype<HEADER>(ref2 - HEADER_SIZE);
+assert(header2.payloadSize == barrier2);
+FREE(ref2);
+var ref3 = ALLOC(barrier2);
+assert(ref1 == ref3); // reuses space of ref1 (free'd in realloc), ref2 (explicitly free'd)
+
+var ref4 = ALLOC(barrier1);
+var called = false;
+@global function __REGISTER_IMPL(ref: usize, parentRef: usize): void {
+  assert(ref == ref4);
+  assert(parentRef == ref3);
+  var header = changetype<HEADER>(ref - HEADER_SIZE);
+  assert(header.classId == __rt_classid<A>());
+  called = true;
+}
+REGISTER<A>(ref4, ref3); // TODO
+assert(called);