@scriptc/compiler 0.4.0 → 0.4.1

package/dist/backend/llvm/emitter.js

@@ -1,5 +1,6 @@
 import { wasmBoundsChecks } from "./wasm-modules.js";
 import { jsTruthy } from "./jsval.js";
+import { JsIcSites } from "../../ir/js-ic.js";
 import {} from "./array-search.js";
 import { emitStringInputs } from "./string-lifetimes.js";
 import { emitThreadSlotsIntrinsic } from "./thread-slots.js";
@@ -89,7 +90,7 @@ import { emitChildProcessLibCall, emitAsyncContextLibCall, emitProcessLibCall, e
 import { emitStreamLibCall } from "./lib-stream.js";
 import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.js";
-import { buildClassGraph, classMembershipIntervals, classFieldIndex, classStructSym, programLifetimeClass, } from "./classes.js";
+import { buildClassGraph, classMembershipIntervals, classFieldIndex, classPreLines, classStructSym, programLifetimeClass, } from "./classes.js";
 import { LifetimeRegions, REGION_TYPES } from "./regions.js";
 import { LlDyn, recordDynKeepsIdentity } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
@@ -282,12 +283,6 @@ export class LlEmitter {
         }
         return `, !tbaa !${tag}`;
     }
-    /** The `!range` attachment of an array length load: a length is at most
-     * 2^32 - 1 (the runtime's SCR_ARR_MAX_LENGTH), so conversions to double
-     * and back fold. 32-bit targets load the full range anyway. */
-    get arrayLengthRange() {
-        return this.sizeType === "i64" ? ", !range !{i64 0, i64 4294967296}" : "";
-    }
     /** Whether an element access at `index` of `arr` lies in the hole-free
      * prefix: the counter of a dense array loop's fast copy indexing one of
      * the arrays its entry test covered. */
@@ -577,6 +572,12 @@ export class LlEmitter {
     recordCloneShapes = new Set();
     tracedShapes;
     tracedUnions;
+    /** Inline-cache sites of dynamic-tier functions (js-ic.ts): one
+     * zero-initialized ScrJsIc per site (scr_js.h). */
+    jsIcSiteCount = 0;
+    jsIcSitesMemo;
+    /** The tier of the function being emitted. */
+    currentTier = undefined;
     /** The class graph (buildClassGraph): preorder numbering, hierarchy
      * membership, virtual slot lists. */
     classMeta;
@@ -674,6 +675,8 @@ export class LlEmitter {
      * not a constructor (where they change), not async or a generator. */
     finalFieldBorrows = false;
     integerRanges = new Map();
+    /** The current function's bounded for-loop cursors (integer-ranges.ts). */
+    integerLoopRanges = new Map();
     /** Number arrays of the current function whose every present element is
      * an int32 (Int32[] contracts), or null when the module has none. */
     int32Elements = null;
@@ -1053,7 +1056,7 @@ export class LlEmitter {
         // The class graph: base/children links, hierarchy membership, the
         // whole-program preorder numbering for instanceof over runtime and
         // compiled error objects, and the per-hierarchy virtual slot lists.
-        this.classMeta = buildClassGraph(mod, this.fnByName);
+        this.classMeta = buildClassGraph(mod, this.fnByName, this.sizeType);
         if (mod.lifetimeRegions === true) {
             this.regions = new LifetimeRegions(this.shapeHost, mod, this.classMeta, (meta) => programLifetimeClass(this.shapeHost, meta), this.nullableFields);
             const regions = this.regions;
@@ -2208,7 +2211,8 @@ export class LlEmitter {
     emitLoopCopies(loop, allowed, exit, emitCopy) {
         return emitLoopCopies(this, loop, allowed, exit, emitCopy);
     }
-    writeBackSpeculativeGlobals(deferred) {
+    /** Store the double of each deferred shadow back to its binding. */
+    writeBackDeferred(deferred) {
         const B = this.B;
         for (const id of deferred) {
             const integer = B.tmp(), number = B.tmp();
@@ -2336,10 +2340,14 @@ export class LlEmitter {
             this.declare(`declare void @scr_throw_str(ptr)`);
             B.line(`call void @scr_throw_str(ptr ${v.name})`);
         }
-        else if (t.kind === "object" && this.classMeta.get(t.className)?.hierarchy === true) {
+        else if (t.kind === "object" &&
+            this.classMeta.get(t.className)?.hierarchy === true &&
+            this.classMeta.get(t.className)?.idInRc !== true) {
             // Hierarchy instances carry a vtable word: the OBJ kind keeps the
             // dynamic class inspectable (catch-binding instanceof, the uncaught
-            // printer's "name: message" for Error instances).
+            // printer's "name: message" for Error instances). Instances that keep
+            // their class id in the rc word are never Errors and are thrown as
+            // REF payloads (narrow-guards.ts emitCaughtClassIdInstanceof).
             const rc = vAdapters(this.shapeHost, t);
             this.declare(`declare void @scr_throw_obj(ptr, ptr, ptr, ptr)`);
             B.line(`call void @scr_throw_obj(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this.shapeHost, t)})`);
@@ -2641,18 +2649,14 @@ export class LlEmitter {
         this.markFieldPointer(p, field);
         return { ptr: p, type, inline: this.inlineUnions.classField(className, field) };
     }
-    /** `o->vt->pre` — the dynamic class's preorder number (borrowed object;
-     * the static class names which struct spelling carries the vt word). */
+    /** The dynamic class's preorder number (borrowed object; the static class
+     * names the struct spelling and where the number is, classPreLines). */
     loadVtPre(objName, staticClassName) {
         const B = this.B;
-        const vtp = B.tmp();
-        const vt = B.tmp();
-        const prep = B.tmp();
         const pre = B.tmp();
-        B.line(`${vtp} = getelementptr inbounds %${classStructSym(staticClassName)}, ptr ${objName}, i64 0, i32 1`);
-        B.line(`${vt} = load ptr, ptr ${vtp}`);
-        B.line(`${prep} = getelementptr inbounds %ScrVt, ptr ${vt}, i64 0, i32 0`);
-        B.line(`${pre} = load ${this.sizeType}, ptr ${prep}`);
+        const meta = this.classMetaOf(staticClassName);
+        for (const line of classPreLines(meta, classStructSym(staticClassName), objName, pre, this.sizeType))
+            B.line(line.trimStart());
         return pre;
     }
     /** The class object's static symbol (classes as values), registering it
@@ -4371,6 +4375,7 @@ export class LlEmitter {
                     pre: meta.pre,
                     post: meta.post,
                     runtimeRooted: meta.root.def.runtime === true,
+                    idInRc: meta.idInRc,
                     // Inline scalar-union fields are plain bits: nothing to push.
                     fields: meta.def.fields.flatMap((f) => this.inlineUnions.classField(className, f.name)
                         ? []
@@ -4407,13 +4412,15 @@ export class LlEmitter {
         this.toFrame(value);
         return this.own({ name: value.name, type: e.type });
     }
-    /** Branches on "`obj` is published" (rc == SIZE_MAX); leaves the builder
-     * in the cold block and answers the continuation label. */
-    emitPublishedTest(obj) {
+    /** Branches on "`obj` is published" (rc == SIZE_MAX, or a count of
+     * UINT32_MAX in the low half for `count` i32: classes.ts
+     * LlClassMeta.idInRc); leaves the builder in the cold block and answers
+     * the continuation label. */
+    emitPublishedTest(obj, count = this.sizeType) {
         const B = this.B;
         const rc = B.tmp(), frozen = B.tmp(), expected = B.tmp();
-        B.line(`${rc} = load ${this.sizeType}, ptr ${obj}`);
-        B.line(`${frozen} = icmp eq ${this.sizeType} ${rc}, -1`);
+        B.line(`${rc} = load ${count}, ptr ${obj}`);
+        B.line(`${frozen} = icmp eq ${count} ${rc}, -1`);
         this.declare(`declare i1 @llvm.expect.i1(i1, i1)`);
         B.line(`${expected} = call i1 @llvm.expect.i1(i1 ${frozen}, i1 false)`);
         const cold = B.newLabel("pub.frozen"), ok = B.newLabel("pub.ok");
@@ -4453,9 +4460,9 @@ export class LlEmitter {
         if (className !== null && !published.classGuarded(className))
             return;
         const B = this.B;
-        const ok = this.emitPublishedTest(obj);
-        let owner;
         const meta = className === null ? undefined : this.classMeta.get(className);
+        const ok = this.emitPublishedTest(obj, meta?.idInRc === true ? "i32" : this.sizeType);
+        let owner;
         if (meta === undefined)
             owner = this.cstr("Object");
         else if (!meta.hierarchy)
@@ -4463,10 +4470,7 @@ export class LlEmitter {
         else {
             // The DYNAMIC class names the object, as in Node.
             this.publishedNamesSym ??= "@sc_pub_class_names";
-            const vtp = B.tmp(), vt = B.tmp(), pre = B.tmp(), slot = B.tmp(), name = B.tmp();
-            B.line(`${vtp} = getelementptr inbounds ptr, ptr ${obj}, i64 1`);
-            B.line(`${vt} = load ptr, ptr ${vtp}`);
-            B.line(`${pre} = load ${this.sizeType}, ptr ${vt}`);
+            const pre = this.loadVtPre(obj, meta.def.name), slot = B.tmp(), name = B.tmp();
             B.line(`${slot} = getelementptr inbounds ptr, ptr ${this.publishedNamesSym}, ${this.sizeType} ${pre}`);
             B.line(`${name} = load ptr, ptr ${slot}`);
             owner = name;
@@ -4771,6 +4775,13 @@ export class LlEmitter {
     emitExpr(e) {
         return emitExpr(this, e);
     }
+    /** The helper classification of this module's inline-cache sites. */
+    get jsIcSites() {
+        return (this.jsIcSitesMemo ??= new JsIcSites(this.mod));
+    }
+    jsIcSite() {
+        return `@sc_js_ic_${this.jsIcSiteCount++}`;
+    }
     /** A fresh read-site cache for one constant-key dyn read. */
     dynReadIcSite() {
         return `@sc_dyn_read_ic_${this.dynReadIcSites++}`;