what std/string would look like

Author: dcodeIO

std/assembly/runtime/index.ts

@@ -1,4 +1,4 @@
-import { AL_MASK } from "../internal/allocator";
+import { AL_MASK, MAX_SIZE_32 } from "../internal/allocator";
 import { __rt_classid } from "../builtins";
 
 /** Common runtime header of all objects. */
@@ -8,18 +8,22 @@ import { __rt_classid } from "../builtins";
   /** Size of the allocated payload. */
   payloadSize: u32;
   /** Reserved field for use by GC. Only present if GC is. */
-  reserved1: usize; // itcm: tagged next
+  gc1: usize; // itcm: tagged next
   /** Reserved field for use by GC. Only present if GC is. */
-  reserved2: usize; // itcm: prev
+  gc2: usize; // itcm: prev
 }
 
+// Note that header data and layout isn't quite optimal depending on which allocator one
+// decides to use, but it's done this way for maximum flexibility. Also remember that the
+// runtime will most likely change significantly once reftypes and WASM GC are a thing.
+
 /** Whether a GC is present or not. */
-@inline export const GC = isDefined(__REGISTER_IMPL);
+@inline export const GC = isDefined(gc);
 
 /** Size of the common runtime header. */
 @inline export const HEADER_SIZE: usize = GC
-  ? (offsetof<HEADER>(           ) + AL_MASK) & ~AL_MASK  // full header if GC is present
-  : (offsetof<HEADER>("reserved1") + AL_MASK) & ~AL_MASK; // half header if GC is absent
+  ? (offsetof<HEADER>(     ) + AL_MASK) & ~AL_MASK  // full header if GC is present
+  : (offsetof<HEADER>("gc1") + AL_MASK) & ~AL_MASK; // half header if GC is absent
 
 /** Magic value used to validate common runtime headers. */
 @inline export const HEADER_MAGIC: u32 = 0xA55E4B17;
@@ -41,8 +45,8 @@ export function ALLOC(payloadSize: u32): usize {
   header.classId = HEADER_MAGIC;
   header.payloadSize = payloadSize;
   if (GC) {
-    header.reserved1 = 0;
-    header.reserved2 = 0;
+    header.gc1 = 0;
+    header.gc2 = 0;
   }
   var ref = changetype<usize>(header) + HEADER_SIZE;
   memory.fill(ref, 0, payloadSize);
@@ -60,8 +64,8 @@ export function REALLOC(ref: usize, newPayloadSize: u32): usize {
       let newHeader = changetype<HEADER>(memory.allocate(newAlignedSize));
       newHeader.classId = HEADER_MAGIC;
       if (GC) {
-        newHeader.reserved1 = 0;
-        newHeader.reserved2 = 0;
+        newHeader.gc1 = 0;
+        newHeader.gc2 = 0;
       }
       let newRef = changetype<usize>(newHeader) + HEADER_SIZE;
       memory.copy(newRef, ref, payloadSize);
@@ -85,7 +89,7 @@ export function REALLOC(ref: usize, newPayloadSize: u32): usize {
   return ref;
 }
 
-function ensureUnregistered(ref: usize): HEADER {
+function unref(ref: usize): HEADER {
   assert(ref >= HEAP_BASE + HEADER_SIZE); // must be a heap object
   var header = changetype<HEADER>(ref - HEADER_SIZE);
   assert(header.classId == HEADER_MAGIC); // must be unregistered
@@ -94,24 +98,36 @@ function ensureUnregistered(ref: usize): HEADER {
 
 /** Frees an object. Must not have been registered with GC yet. */
 export function FREE(ref: usize): void {
-  memory.free(changetype<usize>(ensureUnregistered(ref)));
+  memory.free(changetype<usize>(unref(ref)));
+}
+
+/** Registers a managed object. Cannot be free'd anymore afterwards. */
+@inline export function REGISTER<T>(ref: usize): T {
+  // inline this because it's generic so we don't get a bunch of functions
+  unref(ref).classId = __rt_classid<T>();
+  if (GC) gc.register(ref);
+  return changetype<T>(ref);
 }
 
-/** Registers a managed object with GC. Cannot be free'd anymore afterwards. */
-@inline export function REGISTER<T>(ref: usize, parentRef: usize): void {
-  ensureUnregistered(ref).classId = __rt_classid<T>();
-  if (GC) __REGISTER_IMPL(ref, parentRef); // tslint:disable-line
+/** Links a managed object with its managed parent. */
+export function LINK(ref: usize, parentRef: usize): void {
+  assert(ref >= HEAP_BASE + HEADER_SIZE); // must be a heap object
+  var header = changetype<HEADER>(ref - HEADER_SIZE);
+  assert(header.classId != HEADER_MAGIC && header.gc1 != 0 && header.gc2 != 0); // must be registered
+  if (GC) gc.link(ref, parentRef); // tslint:disable-line
 }
 
 /** ArrayBuffer base class.  */
 export abstract class ArrayBufferBase {
+  static readonly MAX_BYTELENGTH: i32 = MAX_SIZE_32 - HEADER_SIZE;
   get byteLength(): i32 {
     return changetype<HEADER>(changetype<usize>(this) - HEADER_SIZE).payloadSize;
   }
 }
 
 /** String base class. */
 export abstract class StringBase {
+  static readonly MAX_LENGTH: i32 = (MAX_SIZE_32 - HEADER_SIZE) >> 1;
   get length(): i32 {
     return changetype<HEADER>(changetype<usize>(this) - HEADER_SIZE).payloadSize >> 1;
   }

std/assembly/runtime/itcm.ts

@@ -0,0 +1,8 @@
+@global namespace gc {
+  @unsafe export function register(ref: usize): void {
+  }
+  @unsafe export function link(ref: usize, parentRef: usize): void {
+  }
+  export function collect(): void {
+  }
+}