Make sure all roots are iterated by delaying builtin generation; Cleanup

Author: dcodeIO

src/builtins.ts

@@ -2629,8 +2629,7 @@ export function compileCall(
 
     // gc
 
-    case "gc.iterateRoots": {
-      // TOOD: make it so that this can only be called from a library file?
+    case "iterateRoots": {
       if (typeArguments) {
         compiler.error(
           DiagnosticCode.Type_0_is_not_generic,
@@ -2661,49 +2660,10 @@ export function compileCall(
         );
         return module.createUnreachable();
       }
-      let exprs = new Array<ExpressionRef>();
-      for (let element of compiler.program.elementsLookup.values()) {
-        if (element.kind != ElementKind.GLOBAL) continue;
-        let global = <Global>element;
-        let classReference = global.type.classReference;
-        if (
-          global.is(CommonFlags.COMPILED) &&
-          classReference !== null &&
-          !classReference.hasDecorator(DecoratorFlags.UNMANAGED)
-        ) {
-          if (global.is(CommonFlags.INLINED)) {
-            let value = global.constantIntegerValue;
-            exprs.push(
-              module.createCallIndirect(
-                expr,
-                [
-                  compiler.options.isWasm64
-                    ? module.createI64(i64_low(value), i64_high(value))
-                    : module.createI32(i64_low(value))
-                ],
-                signatureReference.toSignatureString()
-              )
-            );
-          } else {
-            exprs.push(
-              module.createCallIndirect(
-                expr,
-                [
-                  module.createGetGlobal(
-                    global.internalName,
-                    compiler.options.nativeSizeType
-                  )
-                ],
-                signatureReference.toSignatureString()
-              )
-            );
-          }
-        }
-      }
       compiler.currentType = Type.void;
-      return exprs.length
-        ? module.createBlock(null, exprs)
-        : module.createNop();
+      // just emit a call even if the function doesn't yet exist
+      compiler.needsIterateRoots = true;
+      return module.createCall("~iterateRoots", [ expr ], NativeType.None);
     }
   }
   var expr = deferASMCall(compiler, prototype, operands, contextualType, reportNode);
@@ -2977,3 +2937,54 @@ export function compileAbort(
     module.createUnreachable()
   ]);
 }
+
+/** Compiles the iterateRoots function if requires. */
+export function compileIterateRoots(compiler: Compiler): void {
+  var module = compiler.module;
+  var exprs = new Array<ExpressionRef>();
+
+  for (let element of compiler.program.elementsLookup.values()) {
+    if (element.kind != ElementKind.GLOBAL) continue;
+    let global = <Global>element;
+    let classReference = global.type.classReference;
+    if (
+      global.is(CommonFlags.COMPILED) &&
+      classReference !== null &&
+      !classReference.hasDecorator(DecoratorFlags.UNMANAGED)
+    ) {
+      if (global.is(CommonFlags.INLINED)) {
+        let value = global.constantIntegerValue;
+        exprs.push(
+          module.createCallIndirect(
+            module.createGetLocal(0, NativeType.I32),
+            [
+              compiler.options.isWasm64
+                ? module.createI64(i64_low(value), i64_high(value))
+                : module.createI32(i64_low(value))
+            ],
+            "iv"
+          )
+        );
+      } else {
+        exprs.push(
+          module.createCallIndirect(
+            module.createGetLocal(0, NativeType.I32),
+            [
+              module.createGetGlobal(
+                global.internalName,
+                compiler.options.nativeSizeType
+              )
+            ],
+            "iv"
+          )
+        );
+      }
+    }
+  }
+  var typeRef = compiler.ensureFunctionType([ Type.i32 ], Type.void);
+  module.addFunction("~iterateRoots", typeRef, [],
+    exprs.length
+      ? module.createBlock(null, exprs)
+      : module.createNop()
+  );
+}

src/compiler.ts

@@ -5,8 +5,9 @@
 
 import {
   compileCall as compileBuiltinCall,
-  compileAllocate as compileBuiltinAllocate,
-  compileAbort as compileBuiltinAbort
+  compileAllocate,
+  compileAbort,
+  compileIterateRoots
 } from "./builtins";
 
 import {
@@ -286,6 +287,8 @@ export class Compiler extends DiagnosticEmitter {
   argcVar: GlobalRef = 0;
   /** Argument count helper setter. */
   argcSet: FunctionRef = 0;
+  /** Indicates whether the iterateRoots function must be generated. */
+  needsIterateRoots: bool = false;
 
   /** Compiles a {@link Program} to a {@link Module} using the specified options. */
   static compile(program: Program, options: Options | null = null): Module {
@@ -408,6 +411,9 @@ export class Compiler extends DiagnosticEmitter {
       this.makeModuleExport(name, moduleExport.element);
     }
 
+    // set up gc
+    if (this.needsIterateRoots) compileIterateRoots(this);
+
     return module;
   }
 
@@ -974,7 +980,7 @@ export class Compiler extends DiagnosticEmitter {
   }
 
   /** Either reuses or creates the function type matching the specified signature. */
-  private ensureFunctionType(
+  ensureFunctionType(
     parameterTypes: Type[] | null,
     returnType: Type,
     thisType: Type | null = null
@@ -2022,7 +2028,7 @@ export class Compiler extends DiagnosticEmitter {
     flow.set(FlowFlags.RETURNS);
 
     // TODO: requires exception-handling spec.
-    return compileBuiltinAbort(this, null, statement);
+    return compileAbort(this, null, statement);
   }
 
   compileTryStatement(statement: TryStatement): ExpressionRef {
@@ -6524,7 +6530,7 @@ export class Compiler extends DiagnosticEmitter {
     // allocate a new instance first and assign 'this' to the temp. local
     exprs[0] = module.createSetLocal(
       tempLocal.index,
-      compileBuiltinAllocate(this, classReference, expression)
+      compileAllocate(this, classReference, expression)
     );
 
     // once all field values have been set, return 'this'
@@ -7497,7 +7503,7 @@ export class Compiler extends DiagnosticEmitter {
     var initializers = new Array<ExpressionRef>();
     initializers.push(
       module.createSetLocal(tempLocal.index,
-        compileBuiltinAllocate(this, classInstance, reportNode)
+        compileAllocate(this, classInstance, reportNode)
       )
     );
 

std/assembly/collector/itcm.ts

@@ -6,13 +6,17 @@
 
 // Largely based on the Bach Le's μgc, see: https://github.com/bullno1/ugc
 
-const TRACE = true;
+const TRACE = false;
 
 import {
   AL_MASK,
   MAX_SIZE_32
 } from "../internal/allocator";
 
+import {
+  iterateRoots
+} from "../gc";
+
 /** Collector states. */
 const enum State {
   /** Not yet initialized. */
@@ -31,8 +35,8 @@ var state = State.INIT;
 var white = 0;
 
 // From and to spaces
-var from: ManagedObject;
-var to: ManagedObject;
+var from: ManagedObjectSet;
+var to: ManagedObjectSet;
 var iter: ManagedObject;
 
 // ╒═══════════════ Managed object layout (32-bit) ════════════════╕
@@ -83,16 +87,6 @@ class ManagedObject {
     this.nextWithColor = (this.nextWithColor & ~3) | color;
   }
 
-  /** Inserts an object to this list. */
-  push(obj: ManagedObject): void {
-    var prev = this.prev;
-    trace("   push", 3, objToRef(prev), objToRef(obj), objToRef(this));
-    obj.next = this;
-    obj.prev = prev;
-    prev.next = obj;
-    this.prev = obj;
-  }
-
   /** Unlinks this object from its list. */
   unlink(): void {
     var next = this.next;
@@ -102,12 +96,6 @@ class ManagedObject {
     prev.next = next;
   }
 
-  clear(): void {
-    if (TRACE) trace("   clear", 1, objToRef(this));
-    this.nextWithColor = changetype<usize>(this);
-    this.prev = this;
-  }
-
   /** Marks this object as gray, that is reachable with unscanned children. */
   makeGray(): void {
     if (TRACE) trace("   makeGray", 1, objToRef(this));
@@ -119,24 +107,38 @@ class ManagedObject {
   }
 }
 
-function markRoots(): void {
-  if (TRACE) trace("   markRoots");
-  gc.iterateRoots(function markRoot(ref: usize): void {
-    if (TRACE) trace("   markRoot", 1, ref);
-    if (ref) __gc_mark(ref);
-  });
+/** A set of managed objects. Used for the from and to spaces. */
+@unmanaged
+class ManagedObjectSet extends ManagedObject {
+
+  /** Inserts an object. */
+  push(obj: ManagedObject): void {
+    var prev = this.prev;
+    if (TRACE) trace("   push", 3, objToRef(prev), objToRef(obj), objToRef(this));
+    obj.next = this;
+    obj.prev = prev;
+    prev.next = obj;
+    this.prev = obj;
+  }
+
+  /** Clears this list. */
+  clear(): void {
+    if (TRACE) trace("   clear", 1, objToRef(this));
+    this.nextWithColor = changetype<usize>(this);
+    this.prev = this;
+  }
 }
 
 /** Performs a single step according to the current state. */
-function step(): void {
+export function step(): bool {
   var obj: ManagedObject;
   switch (state) {
     case State.INIT: {
       if (TRACE) trace("gc~step/INIT");
-      from = changetype<ManagedObject>(memory.allocate(ManagedObject.SIZE));
+      from = changetype<ManagedObjectSet>(memory.allocate(ManagedObject.SIZE));
       from.visitFn = changetype<(ref: usize) => void>(<u32>-1); // would error
       from.clear();
-      to = changetype<ManagedObject>(memory.allocate(ManagedObject.SIZE));
+      to = changetype<ManagedObjectSet>(memory.allocate(ManagedObject.SIZE));
       to.visitFn = changetype<(ref: usize) => void>(<u32>-1); // would error
       to.clear();
       iter = to;
@@ -146,7 +148,7 @@ function step(): void {
     }
     case State.IDLE: {
       if (TRACE) trace("gc~step/IDLE");
-      markRoots();
+      iterateRoots(__gc_mark);
       state = State.MARK;
       if (TRACE) trace("gc~state = MARK");
       break;
@@ -160,7 +162,7 @@ function step(): void {
         obj.visitFn(objToRef(obj));
       } else {
         if (TRACE) trace("gc~step/MARK finish");
-        markRoots();
+        iterateRoots(__gc_mark);
         obj = iter.next;
         if (obj === to) {
           let prevFrom = from;
@@ -189,6 +191,7 @@ function step(): void {
       break;
     }
   }
+  return state != State.IDLE;
 }
 
 @inline function refToObj(ref: usize): ManagedObject {
@@ -201,7 +204,6 @@ function step(): void {
 
 // Garbage collector interface
 
-/** Allocates a managed object. */
 @global export function __gc_allocate(
   size: usize,
   visitFn: (ref: usize) => void
@@ -216,21 +218,20 @@ function step(): void {
   return objToRef(obj);
 }
 
-/** Marks a reachable object. Called from the visitFn functions. */
-@global export function __gc_mark(ref: usize): void {
-  if (TRACE) trace("gc.mark", 1, ref);
-  var obj = refToObj(ref);
-  if (obj.color == white) obj.makeGray();
-}
-
-/** Links a managed child object to its parent object. */
 @global export function __gc_link(parentRef: usize, childRef: usize): void {
   if (TRACE) trace("gc.link", 2, parentRef, childRef);
   var parent = refToObj(parentRef);
   if (parent.color == <i32>!white && refToObj(childRef).color == white) parent.makeGray();
 }
 
-/** Performs a full garbage collection cycle. */
+@global export function __gc_mark(ref: usize): void {
+  if (TRACE) trace("gc.mark", 1, ref);
+  if (ref) {
+    let obj = refToObj(ref);
+    if (obj.color == white) obj.makeGray();
+  }
+}
+
 @global export function __gc_collect(): void {
   if (TRACE) trace("gc.collect");
   // begin collecting if not yet collecting

std/assembly/gc.ts

@@ -1,16 +1,16 @@
-export namespace gc {
+@builtin export declare function iterateRoots(fn: (ref: usize) => void): void; // tslint:disable-line
 
-  @builtin export declare function iterateRoots(fn: (ref: usize) => void): void; // tslint:disable-line
+export namespace gc {
 
   export function allocate(size: usize, visitFn: (ref: usize) => void): usize {
     if (isDefined(__gc_allocate)) return __gc_allocate(size, visitFn); // tslint:disable-line
     WARNING("Calling 'gc.allocate' requires a garbage collector to be present.");
     return <usize>unreachable();
   }
 
-  export function mark(ref: usize): void {
-    if (isDefined(__gc_mark)) { __gc_mark(ref); return; } // tslint:disable-line
-    WARNING("Calling 'gc.mark' requires a garbage collector to be present.");
+  export function collect(): void {
+    if (isDefined(__gc_collect)) { __gc_collect(); return; } // tslint:disable-line
+    WARNING("Calling 'gc.collect' requires a garbage collector to be present.");
     unreachable();
   }
 
@@ -20,9 +20,9 @@ export namespace gc {
     unreachable();
   }
 
-  export function collect(): void {
-    if (isDefined(__gc_collect)) { __gc_collect(); return; } // tslint:disable-line
-    WARNING("Calling 'gc.collect' requires a garbage collector to be present.");
+  export function mark(ref: usize): void {
+    if (isDefined(__gc_mark)) { __gc_mark(ref); return; } // tslint:disable-line
+    WARNING("Calling 'gc.mark' requires a garbage collector to be present.");
     unreachable();
   }
 }