@scriptc/compiler 0.4.6 → 0.4.8

package/dist/backend/llvm/js-ic.js

@@ -8,11 +8,15 @@
  *          read slot `slot` inline; otherwise scr_js_get_probe
  *          (polymorphic, prototype hits, absent keys, misses)
  *   store  ordinary object whose layout is entry 0's replace layout,
- *          outside an intact parse region: replace inline; otherwise
+ *          outside an intact parse region (or storing an inert value,
+ *          which leaves a region intact): replace inline; otherwise
  *          scr_js_store_probe (adds, polymorphic, misses)
  *   keyed  dense array element at an integral number key: inline;
  *          otherwise scr_js_keyed_probe (string keys of ordinary objects)
  *   method dynInvoke's method read: scr_js_load_probe
+ *   call   a method dispatch helper's call: a capsule whose key is one of
+ *          the helper's plain class branches calls that branch's method
+ *          directly (capsuleCallSite); otherwise the helper
  *   literal an object literal's constant-key member: scr_js_store_probe,
  *          else scr_dyn_key_set
  *
@@ -30,12 +34,15 @@
  *   ScrJsIc      entries of 40 bytes {layout, target, holder,
  *                holder_layout, slot}; 168 bytes in all */
 import { BOOL, DYN, F64, STRING } from "../../ir/ir.js";
+import { inertValue } from "../../ir/js-groups.js";
 import { jsIcMethodSites } from "../../ir/js-ic.js";
 import { mangleBorrowedFunction } from "../mangle.js";
 import { emitBorrowedInput } from "./borrowed-inputs.js";
 import { classFieldBase, classFieldIndex } from "./classes.js";
 import { DYN_KIND } from "./dyn.js";
+import { dispatchesCall } from "./integer-clones.js";
 import { JS_BITS } from "./jsval-encoding.js";
+import { emitGroupedGet, emitGroupedSet } from "./js-groups.js";
 import { jsImmediates } from "./jsval.js";
 /** Words of one ScrJsIc record. */
 export const JS_IC_WORDS = 21;
@@ -52,20 +59,20 @@ export function jsIcSiteOf(host, e) {
 export function jsIcMethods(host) {
     return (jsImmediates(host) &&
         host.currentTier === "dynamic" &&
-        jsIcMethodSites(host.currentFunctionName));
+        jsIcMethodSites(host.currentFunctionName, host.loopDepth > 0));
 }
-function gep(host, base, offset) {
+export function gep(host, base, offset) {
     const p = host.B.tmp();
     host.B.line(`${p} = getelementptr inbounds i8, ptr ${base}, i64 ${offset}`);
     return p;
 }
-function load(host, type, base, offset) {
+export function load(host, type, base, offset) {
     const v = host.B.tmp();
     host.B.line(`${v} = load ${type}, ptr ${offset === 0 ? base : gep(host, base, offset)}`);
     return v;
 }
 /** Branches to `yes` when the dyn cell `d` has kind `kind`. */
-function kindIs(host, d, kind, yes, no) {
+export function kindIs(host, d, kind, yes, no) {
     const k = load(host, "i32", d, 8);
     const is = host.B.tmp();
     host.B.line(`${is} = icmp eq i32 ${k}, ${kind}`);
@@ -81,8 +88,29 @@ function kindIs(host, d, kind, yes, no) {
  * they made the run 13% faster than one entry, and 26% faster without its
  * class instances; four were no faster than two. So a site tests entries
  * 0 and 1, own or prototype, and its probe does the rest. (0 makes every access probe: with a runtime
- * built with SCR_JS_VERIFY, that probes every access.) */
-const INLINE_WAYS = 2;
+ * built with SCR_JS_VERIFY, that probes every access.)
+ *
+ * SCRIPTC_DEBUG_JS_IC_WAYS=0|1|2 overrides the count for an attribution run,
+ * where every access should reach the probe so that the runtime entry points
+ * can count it; the value is read once, so one build is one way count. */
+/** The attribution way count `SCRIPTC_DEBUG_JS_IC_WAYS` asks for, or null
+ * when the variable is unset. The value changes emitted code, so the build
+ * cache keys on it (executable/executable-cache.ts). */
+export function debugJsIcWays(env = process.env) {
+    const raw = env["SCRIPTC_DEBUG_JS_IC_WAYS"];
+    if (raw === undefined || raw === "")
+        return null;
+    const ways = Number(raw);
+    if (ways !== 0 && ways !== 1 && ways !== 2)
+        throw new Error(`SCRIPTC_DEBUG_JS_IC_WAYS must be 0, 1 or 2, got ${raw}`);
+    return ways;
+}
+const IC_WAYS_DEBUG = debugJsIcWays();
+const INLINE_WAYS = IC_WAYS_DEBUG ?? 2;
+/* An attribution run gives an object literal's member stores their own probe
+ * entry point, so a profile can split them from other stores. With the
+ * variable unset the emitted code calls scr_js_store_probe as before. */
+const LITERAL_PROBE = IC_WAYS_DEBUG === null ? "scr_js_store_probe" : "scr_js_literal_probe";
 const INLINE_PROTO = true;
 /** The address of slot `slot` of layout-mode object `d`. */
 function slotAt(host, d, slot) {
@@ -195,7 +223,7 @@ function inlineReplace(host, d, ic, ways, store, miss) {
  * immediate, so arithmetic on it takes no reference and a later store can
  * update an unshared number cell in place; any other cell is carried under
  * the cell tag. */
-function asResult(host, cell, e, owned) {
+export function asResult(host, cell, e, owned) {
     const B = host.B;
     /** Retains the cell unless the caller owns it. */
     const hold = () => {
@@ -264,7 +292,7 @@ function asResult(host, cell, e, owned) {
 /** The helper call of a site's slow path, with the site's evaluated
  * (borrowed) arguments. Ordinary parameters take a reference; borrowed
  * ones lend it. Returns the owned result, or "" for a void helper. */
-function helperCall(host, e, callee, args) {
+export function helperCall(host, e, callee, args) {
     const B = host.B;
     const borrowed = host.callLifetimes.borrowed.get(e.callee);
     const argList = args
@@ -309,7 +337,7 @@ function capsuleReads(host, helper) {
     if (receiver === undefined || helper.params.length !== 1)
         return [];
     const reads = new Map();
-    for (const stmt of helper.body) {
+    for (const stmt of tableBranches(helper.body)) {
         if (normalizes(stmt, receiver))
             continue;
         if (stmt.kind !== "if" || stmt.else_ !== null)
@@ -342,6 +370,29 @@ function capsuleReads(host, helper) {
     }
     return out;
 }
+/** A class table's branches in the order a receiver that matches none of
+ * them reaches their guards: the statements of the body, with a
+ * `dyn.classHash` switch replaced by its cases' branches. A capsule whose
+ * key is a branch's selects that case, whose guard is then true, so the
+ * site can treat the branches as the chain they were lowered from. */
+function tableBranches(body) {
+    if (!body.some(isClassHashSwitch))
+        return body;
+    const branches = [];
+    for (const stmt of body) {
+        if (isClassHashSwitch(stmt))
+            for (const { body: caseBody } of stmt.cases)
+                branches.push(...caseBody);
+        else
+            branches.push(stmt);
+    }
+    return branches;
+}
+/** The switch the compiler builds over a generated class table's branches
+ * (frontend/lowering/class-dynamic-dispatch.ts). */
+function isClassHashSwitch(stmt) {
+    return stmt.kind === "switch" && stmt.disc.kind === "libCall" && stmt.disc.fn === "dyn.classHash";
+}
 /** `p = %dyn.class.normalize(p)`. */
 function normalizes(stmt, receiver) {
     return (stmt.kind === "assign" &&
@@ -397,7 +448,7 @@ function normalizationTargets(host) {
     const value = normalize.params[0]?.localId;
     if (value === undefined)
         return null;
-    for (const stmt of normalize.body) {
+    for (const stmt of tableBranches(normalize.body)) {
         if (stmt.kind === "return") {
             if (stmt.value !== null && isLocal(stmt.value, value))
                 continue;
@@ -494,6 +545,296 @@ function inlineCapsuleLoad(host, d, reads, incoming, join, miss) {
         B.br(join);
     });
 }
+/** The capsule call site a call from dynamic-tier code is, or null.
+ *
+ * The helper normalizes its receiver like a read helper, then tests each
+ * class branch; the callback the site calls before evaluating the
+ * arguments resolves own function-valued properties of bag classes. A
+ * capsule whose key is a branch's key calls the branch's method directly
+ * when the branch qualifies under capsuleReads' rule (every subclass the
+ * normalization can rebox the key to has a branch calling the same
+ * method) and the callback has no branch for the key or any of those
+ * subclasses, so it answers undefined for the capsule without effects.
+ * Module initializers call this way only inside loops (jsIcMethodSites). */
+export function capsuleCallSite(host, e, helper) {
+    if (!jsIcMethods(host) || !helper.name.startsWith("%dyn.class.call."))
+        return null;
+    if (helper.async !== undefined || helper.generator !== undefined)
+        return null;
+    if (e.type.kind !== "jsval" && e.type.kind !== "dyn")
+        return null;
+    const { params } = helper;
+    const arity = params.length - 3;
+    if (arity < 0 ||
+        e.args.length !== params.length ||
+        params[1].localId !== "p.callback" ||
+        params[params.length - 1].localId !== "p.calleeName" ||
+        params.slice(2, -1).some((p, i) => p.localId !== `p.${i + 1}`))
+        return null;
+    const [receiver, resolve] = e.args;
+    if (receiver?.kind !== "varRef" ||
+        resolve?.kind !== "call" ||
+        resolve.args.length !== 1 ||
+        !isLocal(resolve.args[0], receiver.localId))
+        return null;
+    const callback = host.fnByName.get(resolve.callee);
+    if (callback === undefined || callback.params.length !== 1)
+        return null;
+    const resolved = callbackKeys(callback);
+    if (resolved === null)
+        return null;
+    const branches = new Map();
+    const self = params[0].localId;
+    for (const stmt of tableBranches(helper.body)) {
+        if (normalizes(stmt, self))
+            continue;
+        if (stmt.kind !== "if" || stmt.else_ !== null)
+            break;
+        if (notCapsule(stmt.cond, self) || classObjectTest(stmt.cond, self))
+            continue;
+        const key = brandKey(stmt.cond, self);
+        if (key === null)
+            return null;
+        if (!branches.has(key))
+            branches.set(key, capsuleCall(host, stmt, self, key, arity));
+    }
+    const reboxes = normalizationTargets(host);
+    if (reboxes === null)
+        return null;
+    const calls = [];
+    for (const call of branches.values()) {
+        if (call === null)
+            continue;
+        const targets = reboxes.get(call.key) ?? [];
+        if (resolved.has(call.key) || targets.some((t) => resolved.has(`object:${t}`)))
+            continue;
+        const same = targets.every((target) => {
+            const other = branches.get(`object:${target}`);
+            return (other != null &&
+                other.method === call.method &&
+                other.returnsReceiver === call.returnsReceiver);
+        });
+        if (same)
+            calls.push(call);
+    }
+    return calls.length > 0 ? { callback, calls } : null;
+}
+/** The capsule keys a dispatch callback has branches for, or null when
+ * its body has another form: the normalization, branches on capsule or
+ * class-object tests, and a final return of undefined. */
+function callbackKeys(callback) {
+    const value = callback.params[0].localId;
+    const keys = new Set();
+    const body = tableBranches(callback.body);
+    for (let i = 0; i < body.length; i++) {
+        const stmt = body[i];
+        if (normalizes(stmt, value))
+            continue;
+        if (stmt.kind === "if" && stmt.else_ === null) {
+            if (notCapsule(stmt.cond, value) || classObjectTest(stmt.cond, value))
+                continue;
+            const key = brandKey(stmt.cond, value);
+            if (key === null)
+                return null;
+            keys.add(key);
+            continue;
+        }
+        if (i === body.length - 1 && stmt.kind === "return" && returnsUndefined(stmt.value))
+            return keys;
+        return null;
+    }
+    return null;
+}
+/** `dyn.classIs(p, "classval:C")`: true only for a class object, never
+ * for a capsule. */
+function classObjectTest(cond, receiver) {
+    return (cond.kind === "libCall" &&
+        cond.fn === "dyn.classIs" &&
+        cond.args.length === 2 &&
+        isLocal(cond.args[0], receiver));
+}
+function returnsUndefined(value) {
+    if (value?.kind === "libCall" && value.fn === "js.fromDyn" && value.args.length === 1)
+        value = value.args[0];
+    return (value?.kind === "dynFrom" && value.value.kind === "unitLit" && value.value.unit === "undefined");
+}
+/** The method a class branch calls, or null for a branch of another
+ * form. */
+function capsuleCall(host, branch, receiver, key, arity) {
+    const [first, second] = branch.then;
+    let call;
+    let returnsReceiver;
+    if (branch.then.length === 2 && first?.kind === "exprStmt" && second?.kind === "return") {
+        call = first.expr;
+        let value = second.value;
+        if (value?.kind === "libCall" && value.fn === "js.fromDyn" && value.args.length === 1)
+            value = value.args[0];
+        if (value === null || !isLocal(value, receiver) || call.type.kind !== "void")
+            return null;
+        returnsReceiver = true;
+    }
+    else if (branch.then.length === 1 && first?.kind === "return") {
+        call = first.value;
+        if (call?.kind === "libCall" && call.fn === "js.fromDyn" && call.args.length === 1)
+            call = call.args[0];
+        returnsReceiver = false;
+    }
+    else
+        return null;
+    if (call?.kind !== "call" || call.args.length !== arity + 1)
+        return null;
+    let self = call.args[0];
+    if (self.kind === "upcast")
+        self = self.value;
+    if (self.kind !== "dynCheck" || !isLocal(self.value, receiver) || self.type.kind !== "object")
+        return null;
+    if (key !== `object:${self.type.className}`)
+        return null;
+    if (!call.args.slice(1).every((a, i) => isLocal(a, `p.${i + 1}`)))
+        return null;
+    if (!plainMethod(host, call.callee, returnsReceiver))
+        return null;
+    return { key, className: self.type.className, method: call.callee, returnsReceiver };
+}
+/** A method the site can call with the ordinary or borrowed ABI and a
+ * dyn, jsval or void result. */
+function plainMethod(host, name, returnsReceiver) {
+    const fn = host.fnByName.get(name);
+    if (fn === undefined || fn.async !== undefined || fn.generator !== undefined)
+        return false;
+    if (fn.captures !== undefined)
+        return false;
+    if (host.int32Abis.has(name))
+        return false;
+    if (dispatchesCall(host.integerClones, host.currentFunctionName, name))
+        return false;
+    const result = fn.returnType.kind;
+    return returnsReceiver ? result === "void" : result === "dyn" || result === "jsval";
+}
+/** A call of a method dispatch helper from dynamic-tier code whose class
+ * branches qualify (capsuleCallSite). A capsule with one of their keys
+ * skips the callback (it answers undefined for it) and calls the
+ * branch's method with the capsule's instance; anything else calls the
+ * callback before the arguments and then the helper, as the plain call
+ * does. The arguments are evaluated once, after the callback. */
+export function emitCapsuleCall(host, e, helper, site) {
+    const B = host.B;
+    const receiver = emitBorrowedInput(host, e.args[0]);
+    const capsule = B.newLabel("iccall.cap");
+    const resolve = B.newLabel("iccall.cb");
+    const evaluate = B.newLabel("iccall.args");
+    const matched = site.calls.map(() => B.newLabel("iccall.k"));
+    kindIs(host, receiver.name, DYN_KIND.TYPED_REF, capsule, resolve);
+    B.startBlock(capsule);
+    // Capsules boxed by this program share its key constants.
+    const key = load(host, "ptr", receiver.name, 40);
+    site.calls.forEach((call, i) => {
+        const same = B.tmp();
+        B.line(`${same} = icmp eq ptr ${key}, ${host.cstr(call.key)}`);
+        const next = i + 1 < site.calls.length ? B.newLabel("iccall.t") : resolve;
+        B.condBr(same, matched[i], next);
+        if (next !== resolve)
+            B.startBlock(next);
+    });
+    for (const label of matched) {
+        B.startBlock(label);
+        B.br(evaluate);
+    }
+    B.startBlock(resolve);
+    const resolved = helperCall(host, e.args[1], site.callback, [receiver]);
+    const resolveEnd = B.currentLabel();
+    B.br(evaluate);
+    B.startBlock(evaluate);
+    // The branch a capsule takes, or -1 for the helper.
+    const branch = B.tmp();
+    const branches = matched.map((label, i) => `[ ${i}, %${label} ]`);
+    B.line(`${branch} = phi i32 ${[...branches, `[ -1, %${resolveEnd} ]`].join(", ")}`);
+    // The callback's result for an inline capsule is never read: undefined
+    // for a jsval result, null for a dyn one.
+    const unread = site.callback.returnType.kind === "jsval"
+        ? `inttoptr (i64 ${JS_BITS.undefined} to ptr)`
+        : "null";
+    const cb = B.tmp();
+    const cbIn = matched.map((label) => `[ ${unread}, %${label} ]`);
+    B.line(`${cb} = phi ptr ${[...cbIn, `[ ${resolved}, %${resolveEnd} ]`].join(", ")}`);
+    host.own({ name: cb, type: site.callback.returnType });
+    const rest = e.args.slice(2).map((a) => emitBorrowedInput(host, a));
+    const slow = B.newLabel("iccall.slow");
+    const join = B.newLabel("iccall.j");
+    const calls = site.calls.map(() => B.newLabel("iccall.m"));
+    const cases = calls.map((label, i) => `i32 ${i}, label %${label}`).join(" ");
+    B.terminate(`switch i32 ${branch}, label %${slow} [ ${cases} ]`);
+    const incoming = [];
+    site.calls.forEach((call, i) => {
+        B.startBlock(calls[i]);
+        const instance = load(host, "ptr", receiver.name, 16);
+        const self = { name: instance, type: { kind: "object", className: call.className } };
+        const result = methodCall(host, call.method, [self, ...rest.slice(0, -1)]);
+        let out;
+        if (call.returnsReceiver) {
+            const held = host.retainFrame(receiver.name, DYN);
+            out = e.type.kind === "jsval" ? cellWord(host, held) : held;
+        }
+        else {
+            const returned = host.fnByName.get(call.method).returnType;
+            out = returned.kind === e.type.kind ? result : asResult(host, result, e, true);
+        }
+        incoming.push(`[ ${out}, %${B.currentLabel()} ]`);
+        B.br(join);
+    });
+    B.startBlock(slow);
+    const result = helperCall(host, e, helper, [
+        receiver,
+        { name: cb, type: site.callback.returnType },
+        ...rest,
+    ]);
+    incoming.push(`[ ${result}, %${B.currentLabel()} ]`);
+    B.br(join);
+    B.startBlock(join);
+    const out = B.tmp();
+    B.line(`${out} = phi ptr ${incoming.join(", ")}`);
+    return host.own({ name: out, type: e.type });
+}
+/** A held cell as a jsval word. */
+function cellWord(host, cell) {
+    const B = host.B;
+    const bits = B.tmp();
+    const word = B.tmp();
+    const tagged = B.tmp();
+    B.line(`${bits} = ptrtoint ptr ${cell} to i64`);
+    B.line(`${word} = or i64 ${bits}, ${JS_BITS.cellTag}`);
+    B.line(`${tagged} = inttoptr i64 ${word} to ptr`);
+    return tagged;
+}
+/** A direct call of a compiled method with the site's evaluated
+ * (borrowed) arguments, as helperCall passes them. Returns the owned
+ * result, or "" for a void method. */
+function methodCall(host, name, args) {
+    const B = host.B;
+    const method = host.fnByName.get(name);
+    const borrowed = host.callLifetimes.borrowed.get(name);
+    const argList = args
+        .map((a, i) => {
+        const type = method.params[i].type;
+        const value = borrowed?.has(i) ? a.name : host.retainFrame(a.name, type);
+        return `${host.llType(type)} ${value}`;
+    })
+        .join(", ");
+    const target = `@${borrowed ? mangleBorrowedFunction(name) : host.callTarget(name)}`;
+    if (method.returnType.kind === "void") {
+        const invoked = host.emitDirectCall(`call void ${target}(${argList})`, name);
+        if (!invoked && host.mayThrow.has(name))
+            host.emitPendingCheck();
+        return "";
+    }
+    let t = B.tmp();
+    const invoked = host.emitDirectCall(`${t} = call ${host.llType(method.returnType)} ${target}(${argList})`, name);
+    if (!invoked && host.mayThrow.has(name))
+        host.emitPendingCheck();
+    if (borrowed && host.borrowedReturns.has(name))
+        t = host.retainFrame(t, method.returnType);
+    return t;
+}
 /** Emits a call to a classified helper as a cache site. */
 export function emitJsIcCall(host, e, callee, site) {
     switch (site.kind) {
@@ -506,6 +847,11 @@ export function emitJsIcCall(host, e, callee, site) {
     }
 }
 function emitGet(host, e, callee, key) {
+    // A member of a guard group reads through the group's entry (js-groups.ts)
+    // unless its guard is not in effect here.
+    const grouped = emitGroupedGet(host, e, callee);
+    if (grouped !== null)
+        return grouped;
     const B = host.B;
     const receiver = emitBorrowedInput(host, e.args[0]);
     const name = keyString(host, key, e);
@@ -600,17 +946,31 @@ function numberResult(host, d, e) {
     B.line(`${cell} = call ptr @scr_dyn_new_num(double ${d})`);
     return cell;
 }
+/** The jsval word of a store's value when the jsval pass left one: the
+ * operand of `js.toDyn`. The word of a double is its bits with NaN
+ * canonicalized, the same word the pass carries for it. */
+function storeWord(host, value) {
+    if (value.kind === "libCall" && value.fn === "js.toDyn")
+        return host.emitExpr(value.args[0]).name;
+    return null;
+}
 function emitSet(host, e, callee, key) {
     const B = host.B;
     const receiver = emitBorrowedInput(host, e.args[0]);
     // A value the jsval pass left as `js.toDyn(x)` is stored from the jsval
-    // itself: a number replaces the value of an unshared number cell in
-    // place instead of boxing a new one.
+    // itself: a number replaces the value of an unshared number cell in place
+    // instead of boxing a new one, and the generic path boxes it only where it
+    // must store a cell.
     const stored = e.args[1];
-    const word = stored.kind === "libCall" && stored.fn === "js.toDyn"
-        ? host.emitExpr(stored.args[0]).name
-        : null;
+    const word = storeWord(host, stored);
     const value = word === null ? emitBorrowedInput(host, stored) : null;
+    // A member of a guard group stores through the group's entry
+    // (js-groups.ts) unless its guard is not in effect here. Its operands are
+    // already evaluated: a member read inside the stored value comes first in
+    // the group's order.
+    const grouped = emitGroupedSet(host, e, callee, receiver, word, value);
+    if (grouped !== null)
+        return grouped;
     const name = keyString(host, key, e);
     const ic = host.jsIcSite();
     const object = B.newLabel("ics.obj");
@@ -628,11 +988,18 @@ function emitSet(host, e, callee, key) {
     }
     kindIs(host, receiver.name, DYN_KIND.OBJ, object, probe);
     B.startBlock(object);
-    const region = load(host, "ptr", receiver.name, 72);
-    const outside = B.tmp();
-    B.line(`${outside} = icmp eq ptr ${region}, null`);
     const unshared = B.newLabel("ics.r");
-    B.condBr(outside, unshared, probe);
+    if (inertValue(stored)) {
+        // An inert value leaves a parse region intact, so the barrier the probe
+        // applies behind the region test cannot fire: the replace stays inline.
+        B.br(unshared);
+    }
+    else {
+        const region = load(host, "ptr", receiver.name, 72);
+        const outside = B.tmp();
+        B.line(`${outside} = icmp eq ptr ${region}, null`);
+        B.condBr(outside, unshared, probe);
+    }
     B.startBlock(unshared);
     host.declare(`declare ptr @scr_js_to_dyn_borrow(ptr)`);
     inlineReplace(host, receiver.name, ic, INLINE_WAYS, (slot) => {
@@ -964,9 +1331,9 @@ function emitKeyed(host, e, callee) {
 export function emitJsIcLiteralMember(host, obj, key, value) {
     const B = host.B;
     const ic = host.jsIcSite();
-    host.declare(`declare zeroext i1 @scr_js_store_probe(ptr, ptr, ptr, ptr)`);
+    host.declare(`declare zeroext i1 @${LITERAL_PROBE}(ptr, ptr, ptr, ptr)`);
     const done = B.tmp();
-    B.line(`${done} = call zeroext i1 @scr_js_store_probe(ptr ${obj}, ptr ${key}, ptr ${value}, ptr ${ic})`);
+    B.line(`${done} = call zeroext i1 @${LITERAL_PROBE}(ptr ${obj}, ptr ${key}, ptr ${value}, ptr ${ic})`);
     const slow = B.newLabel("icl.slow");
     const join = B.newLabel("icl.j");
     B.condBr(done, join, slow);