@scriptc/compiler 0.4.6 → 0.4.8

package/dist/ir/jsval.js

@@ -33,6 +33,15 @@
  * - a dyn local becomes a jsval local when the boxing it saves on writes
  *   of operator results outweighs the boxing its reads by dyn consumers add
  *   (loop depth weights both);
+ * - a function that dynamic-tier functions call directly but that is also
+ *   reached otherwise (a class member, a function value, a static caller)
+ *   gets a jsval entry `%js.<name>` holding its body when one of its
+ *   parameters qualifies the same way: the direct calls of dynamic-tier
+ *   functions call the entry, and the function itself becomes a wrapper
+ *   that keeps the dyn ABI for everyone else;
+ * - a closure whose body uses a parameter only as an operand gets a jsval
+ *   copy of its body (IrFunction.jsEntry), which the function values boxed
+ *   from it enter with jsval arguments from dynCall and dynInvoke sites;
  * - a dyn module global becomes a jsval global by the same measure, summed
  *   over every function, when only dynamic-tier functions reference it.
  *
@@ -47,9 +56,10 @@
  * Async functions and generators are rewritten like other functions (their
  * suspensions keep jsvals like any pointer) but keep the dyn result ABI. */
 import { exprFunctionReference, moduleFunctionReferences } from "./function-references.js";
-import { DYN, JSVAL } from "./ir.js";
+import { DYN, JSVAL, } from "./ir.js";
 import { JsIcSites } from "./js-ic.js";
-import { everyExprChild, everyStmtChild, everyStmtList, mapExprChildren, mapStmtChildren, } from "./traverse.js";
+import { reparseStmt } from "./serialize.js";
+import { everyExprChild, everyStmtChild, everyStmtList, mapExprChildren, mapStmtChildren, transformStmtList, } from "./traverse.js";
 /** dyn operators whose result is a fresh dynamic value, with their jsval
  * twins. Every argument typed dyn is an operand. */
 const PRODUCERS = {
@@ -101,11 +111,15 @@ export function promoteJsvals(mod) {
             results.add(fn.name);
     const sites = new JsIcSites(mod);
     const storesJs = (e) => e.kind === "call" && sites.site(e.callee)?.kind === "set";
-    const params = jsvalParams(mod, direct, results, storesJs);
-    const globals = promotableGlobals(mod, results, params, storesJs);
+    const candidates = entryCandidates(mod, direct, sites);
+    const params = jsvalParams(mod, direct, candidates, results, sites, storesJs);
+    splitEntries(mod, candidates, params, results);
+    const jsDynArguments = closureEntries(mod, params, results, storesJs);
+    const globals = promotableGlobals(mod, results, params, storesJs, jsDynArguments);
     let count = 0;
     for (const fn of mod.functions)
-        if (jsvalEligible(fn) && promoteFunction(fn, results, params, storesJs, globals))
+        if (jsvalEligible(fn) &&
+            promoteFunction(fn, results, params, storesJs, globals, jsDynArguments))
             count++;
     for (const fn of mod.functions)
         if (results.has(fn.name))
@@ -157,60 +171,284 @@ function directCallees(mod) {
     }
     return results;
 }
-/** The parameters of direct callees that take a jsval, by position. A dyn
- * parameter of a direct callee other than a library helper (`%dyn.*`,
- * whose calls the inline caches emit) is a candidate. Its credit is the
- * share of its arguments, weighted by the callers' loop depth, that the
- * callers compute as jsvals (operator results, jsval results and static
- * numbers): the boxing a call saves. promotableLocals weighs it against
- * the callee's reads of the parameter by dyn consumers. */
-function jsvalParams(mod, direct, results, storesJs) {
-    const byName = new Map();
-    const passed = new Map();
+/** Functions that dynamic-tier functions call directly but that are also
+ * reached otherwise, so they keep the dyn ABI: candidates for a jsval
+ * entry (splitEntries). Library helpers (`%dyn.*`), inline-cache sites, the
+ * entry, closures (`captures`, `selfRef`) and suspending functions are
+ * left out. */
+function entryCandidates(mod, direct, sites) {
+    const called = new Set();
     for (const fn of mod.functions) {
-        byName.set(fn.name, fn);
-        if (!direct.has(fn.name) || fn.name.startsWith("%dyn."))
+        if (fn.tier !== "dynamic")
+            continue;
+        everyStmtList(fn.body, {
+            expr: (e) => {
+                if (e.kind === "call")
+                    called.add(e.callee);
+                return true;
+            },
+            stmt: () => true,
+        });
+    }
+    const candidates = new Set();
+    for (const fn of mod.functions) {
+        if (!called.has(fn.name) || direct.has(fn.name) || fn.name === mod.entry)
+            continue;
+        if (!jsvalEligible(fn) || fn.async !== undefined || fn.generator !== undefined)
+            continue;
+        if (fn.captures !== undefined || fn.classCaptures !== undefined)
+            continue;
+        if (fn.speculativeDispatch !== undefined || fn.fastRead !== undefined)
+            continue;
+        if (fn.name.startsWith("%dyn.") || sites.site(fn.name) !== null)
             continue;
         if (!fn.params.some((p) => p.type.kind === "dyn"))
             continue;
-        passed.set(fn.name, { total: fn.params.map(() => 0), js: fn.params.map(() => 0) });
+        const plain = everyStmtList(fn.body, { expr: (e) => e.kind !== "selfRef", stmt: () => true });
+        if (plain)
+            candidates.add(fn.name);
     }
+    return candidates;
+}
+/** The parameters that take a jsval, by function and position: parameters
+ * of direct callees and entry candidates, other than inline-cache sites.
+ * A parameter's credit is the share of its arguments, weighted by the
+ * callers' loop depth, that the callers compute as jsvals (operator
+ * results, jsval results, static numbers and the callers' own jsval
+ * parameters): the boxing a call saves. promotableLocals weighs it against
+ * the callee's reads of the parameter by dyn consumers.
+ *
+ * The decision starts from every candidate parameter and drops the ones
+ * whose credit no longer pays, until nothing changes, so a parameter that
+ * a dispatch helper forwards to a method can qualify in both. */
+function jsvalParams(mod, direct, candidates, results, sites, storesJs) {
+    const byName = new Map();
     const params = new Map();
-    if (passed.size === 0)
-        return params;
-    const jsArgument = (e) => isProducerCall(e) || isImmediateSource(e) || (e.kind === "call" && results.has(e.callee));
     for (const fn of mod.functions) {
-        if (fn.tier !== "dynamic")
+        byName.set(fn.name, fn);
+        if (!direct.has(fn.name) && !candidates.has(fn.name))
             continue;
-        everyWeightedExpr(fn.body, (e, weight) => {
-            const counts = e.kind === "call" ? passed.get(e.callee) : undefined;
-            if (counts === undefined || e.kind !== "call")
-                return;
-            e.args.forEach((arg, i) => {
-                if (i >= counts.total.length || arg.type.kind !== "dyn")
+        if (sites.site(fn.name) !== null)
+            continue;
+        const js = fn.params.map((p) => p.type.kind === "dyn");
+        if (js.includes(true))
+            params.set(fn.name, js);
+    }
+    const returnsJs = (callee) => results.has(callee) ||
+        (candidates.has(callee) && byName.get(callee).returnType.kind === "dyn");
+    const producer = (e) => isProducerCall(e) || (e.kind === "call" && returnsJs(e.callee));
+    for (let changed = params.size > 0; changed;) {
+        changed = false;
+        const passed = new Map();
+        for (const [name, js] of params)
+            passed.set(name, { total: js.map(() => 0), js: js.map(() => 0) });
+        for (const fn of mod.functions) {
+            if (fn.tier !== "dynamic")
+                continue;
+            const own = params.get(fn.name);
+            const jsLocals = new Set(fn.params.filter((_, i) => own?.[i] === true).map((p) => p.localId));
+            const jsArgument = (e) => producer(e) || isImmediateSource(e) || (e.kind === "varRef" && jsLocals.has(e.localId));
+            everyWeightedExpr(fn.body, (e, weight) => {
+                const counts = e.kind === "call" ? passed.get(e.callee) : undefined;
+                if (counts === undefined || e.kind !== "call")
                     return;
-                counts.total[i] += weight;
-                if (jsArgument(arg))
-                    counts.js[i] += weight;
+                e.args.forEach((arg, i) => {
+                    if (i >= counts.total.length || arg.type.kind !== "dyn")
+                        return;
+                    counts.total[i] += weight;
+                    if (jsArgument(arg))
+                        counts.js[i] += weight;
+                });
             });
+        }
+        for (const [name, js] of params) {
+            const fn = byName.get(name);
+            const counts = passed.get(name);
+            const credits = new Map();
+            fn.params.forEach((p, i) => {
+                if (js[i] === true && counts.js[i] > 0)
+                    credits.set(p.localId, counts.js[i] / counts.total[i]);
+            });
+            const promoted = credits.size === 0
+                ? new Set()
+                : promotableLocals(fn, producer, returnsJs(name), storesJs, credits, params);
+            const next = fn.params.map((p, i) => js[i] === true && promoted.has(p.localId));
+            if (next.every((v, i) => v === js[i]))
+                continue;
+            changed = true;
+            if (next.includes(true))
+                params.set(name, next);
+            else
+                params.delete(name);
+        }
+    }
+    return params;
+}
+/** Give each entry candidate with a jsval parameter its jsval entry: a new
+ * function `%js.<name>` takes the body (its stack frame included), the
+ * function keeps its name and dyn ABI as a wrapper that calls the entry,
+ * and the direct calls of dynamic-tier functions call the entry instead.
+ * Static callers, vtables, function values and the runtime keep reaching
+ * the wrapper. The decisions in `params` and `results` move to the
+ * entries. */
+function splitEntries(mod, candidates, params, results) {
+    const entries = new Map();
+    for (const name of candidates) {
+        const js = params.get(name);
+        if (js === undefined)
+            continue;
+        const entry = `%js.${name}`;
+        entries.set(name, entry);
+        params.delete(name);
+        params.set(entry, js);
+    }
+    if (entries.size === 0)
+        return;
+    const functions = [];
+    for (const fn of mod.functions) {
+        const entryName = entries.get(fn.name);
+        if (entryName === undefined) {
+            functions.push(fn);
+            continue;
+        }
+        const { ownsPrototype: _ownsPrototype, ...rest } = fn;
+        const entry = {
+            ...rest,
+            name: entryName,
+            params: fn.params.map((p) => ({ ...p })),
+        };
+        if (fn.returnType.kind === "dyn")
+            results.add(entryName);
+        const call = {
+            kind: "call",
+            callee: entryName,
+            args: fn.params.map((p) => ({
+                kind: "varRef",
+                localId: p.localId,
+                type: p.type,
+                loc: fn.loc,
+            })),
+            type: fn.returnType,
+            loc: fn.loc,
+        };
+        fn.locals = fn.params.map((p) => ({
+            id: p.localId,
+            name: p.name,
+            type: p.type,
+            mutable: false,
+        }));
+        fn.body =
+            fn.returnType.kind === "void"
+                ? [{ kind: "exprStmt", expr: call, loc: fn.loc }]
+                : [{ kind: "return", value: call, loc: fn.loc }];
+        delete fn.sourceName;
+        functions.push(fn, entry);
+    }
+    mod.functions = functions;
+    const wrappers = new Set(entries.keys());
+    const retarget = (e) => {
+        const entry = e.kind === "call" ? entries.get(e.callee) : undefined;
+        return entry === undefined ? e : { ...e, callee: entry };
+    };
+    for (const fn of mod.functions) {
+        if (fn.tier !== "dynamic" || wrappers.has(fn.name))
+            continue;
+        fn.body = transformStmtList(fn.body, { expr: retarget, stmt: (s) => s });
+    }
+}
+/** Give closures a jsval entry for the function values boxed from them:
+ * `%js.<name>`, a copy of the body with the same captures whose
+ * parameters that the body only uses as operands take jsvals, named by
+ * the closure's `jsEntry`. The backend's box builders register the entry
+ * on every function value of the closure, and the dynamic tier's dynCall
+ * and dynInvoke sites call it with jsval arguments. A closure keeps one
+ * body when no parameter qualifies, when a parameter is typed, when its
+ * body is not dynamic-tier,
+ * when a closure of it reads arguments past its parameters (a
+ * rest-marked type), or when it suspends. Returns whether any closure got
+ * an entry. */
+function closureEntries(mod, params, results, storesJs) {
+    const boxed = new Set();
+    const variadic = new Set();
+    for (const fn of mod.functions) {
+        everyStmtList(fn.body, {
+            expr: (e) => {
+                if (e.kind === "closure") {
+                    if (e.type.kind === "func" && e.type.rest !== true)
+                        boxed.add(e.fnName);
+                    else
+                        variadic.add(e.fnName);
+                }
+                return true;
+            },
+            stmt: () => true,
         });
     }
+    for (const name of variadic)
+        boxed.delete(name);
+    if (boxed.size === 0)
+        return false;
     const producer = (e) => isProducerCall(e) || (e.kind === "call" && results.has(e.callee));
-    for (const [name, counts] of passed) {
-        const fn = byName.get(name);
+    const functions = [];
+    let any = false;
+    for (const fn of mod.functions) {
+        functions.push(fn);
+        if (!boxed.has(fn.name) || fn.captures === undefined || fn.classCaptures !== undefined)
+            continue;
+        if (!jsvalEligible(fn) || fn.async !== undefined || fn.generator !== undefined)
+            continue;
+        // The jsval entry passes words: a typed parameter would need the dyn
+        // entry's argument checks.
+        if (fn.params.some((p) => p.type.kind !== "dyn"))
+            continue;
+        // A caller of a function value passes no argument the body could not
+        // take as a cell, so a parameter takes a jsval only when no dyn
+        // consumer reads it: the half credit loses to any such read.
         const credits = new Map();
-        fn.params.forEach((p, i) => {
-            if (p.type.kind === "dyn" && counts.js[i] > 0)
-                credits.set(p.localId, counts.js[i] / counts.total[i]);
-        });
+        for (const p of fn.params)
+            if (p.type.kind === "dyn")
+                credits.set(p.localId, 0.5);
         if (credits.size === 0)
             continue;
-        const promoted = promotableLocals(fn, producer, results.has(name), storesJs, credits);
+        const jsResult = fn.returnType.kind === "dyn";
+        const promoted = promotableLocals(fn, producer, jsResult, storesJs, credits, params, true);
         const js = fn.params.map((p) => credits.has(p.localId) && promoted.has(p.localId));
-        if (js.includes(true))
-            params.set(name, js);
+        if (!js.includes(true))
+            continue;
+        const name = `%js.${fn.name}`;
+        const { ownsPrototype: _ownsPrototype, ...rest } = fn;
+        functions.push({
+            ...rest,
+            name,
+            params: fn.params.map((p) => ({ ...p })),
+            locals: fn.locals.map(copyLocal),
+            captures: fn.captures.map((c) => ({ ...c })),
+            body: fn.body.map(reparseStmt),
+        });
+        fn.jsEntry = name;
+        params.set(name, js);
+        if (jsResult)
+            results.add(name);
+        any = true;
     }
-    return params;
+    mod.functions = functions;
+    return any;
+}
+/** A local's own copy, for a body copy whose rewrite retypes locals. */
+function copyLocal(local) {
+    const copy = {
+        id: local.id,
+        name: local.name,
+        type: local.type,
+        mutable: local.mutable,
+    };
+    if (local.source !== undefined)
+        copy.source = local.source;
+    if (local.boxed !== undefined)
+        copy.boxed = local.boxed;
+    if (local.tdz !== undefined)
+        copy.tdz = local.tdz;
+    return copy;
 }
 /** Visit every expression of a body with its loop weight. */
 function everyWeightedExpr(body, visit) {
@@ -245,17 +483,42 @@ const MAX_WEIGHT = 8 ** 6;
 /** The dyn locals of a function that become jsval locals. `producer`
  * tells which dyn expressions the rewrite computes as jsvals. Parameters
  * are candidates only with a credit (jsvalParams); `jsParams` lists the
- * arguments that calls pass as jsvals. */
-function promotableLocals(fn, producer, jsResult, storesJs, credits = new Map(), jsParams = new Map()) {
-    const candidates = localCandidates(fn, credits);
-    if (candidates.size === 0)
-        return new Set();
-    const blocked = new Set();
-    scanBindingCosts(fn, candidates, blocked, producer, jsResult, storesJs, jsParams);
-    const promoted = new Set();
-    for (const [id, cost] of candidates)
-        if (!blocked.has(id) && cost.saved > cost.added)
-            promoted.add(id);
+ * arguments that calls pass as jsvals, `jsDynArguments` whether dynCall
+ * and dynInvoke take jsval arguments (closureEntries), and `jsBindings`
+ * the module globals that hold jsvals. */
+function promotableLocals(fn, producer, jsResult, storesJs, credits = new Map(), jsParams = new Map(), jsDynArguments = false, jsBindings = new Set()) {
+    /* One round: `sources` are the bindings taken as jsvals, so a copy of
+     * one is a jsval write, and the copy's read of it a jsval use. */
+    const round = (sources) => {
+        const candidates = localCandidates(fn, credits);
+        if (candidates.size === 0)
+            return new Set();
+        const blocked = new Set();
+        scanBindingCosts(fn, candidates, blocked, producer, jsResult, storesJs, jsParams, {
+            sources,
+            jsDynArguments,
+        });
+        const promoted = new Set();
+        // A caller boxes on every call, the callee only on the paths that read
+        // the parameter by a dyn consumer: a parameter takes a jsval on a tie.
+        for (const [id, cost] of candidates)
+            if (!blocked.has(id) &&
+                (cost.saved > cost.added || (credits.has(id) && cost.saved >= cost.added)))
+                promoted.add(id);
+        return promoted;
+    };
+    // Each round takes the previous round's promotions as sources, so a copy
+    // chain from a promoted local, a credited parameter or a jsval global
+    // follows it.
+    let sources = new Set([...credits.keys(), ...jsBindings]);
+    let promoted = round(sources);
+    for (let i = 0; i < 4; i++) {
+        const next = new Set([...sources, ...promoted]);
+        if (next.size === sources.size)
+            break;
+        sources = next;
+        promoted = round(sources);
+    }
     return promoted;
 }
 /** The dyn locals of a function that may become jsval locals, parameters
@@ -285,7 +548,7 @@ function localCandidates(fn, credits) {
  * saved boxing outweighs the added boxing summed over every function, the
  * same measure as for locals. Libraries keep every global (the host reads
  * exported bindings), and so do bindings with a temporal dead zone. */
-function promotableGlobals(mod, results, jsParams, storesJs) {
+function promotableGlobals(mod, results, jsParams, storesJs, jsDynArguments) {
     const candidates = new Map();
     if (mod.lib !== undefined)
         return new Set();
@@ -314,7 +577,10 @@ function promotableGlobals(mod, results, jsParams, storesJs) {
             });
             continue;
         }
-        scanBindingCosts(fn, candidates, blocked, producer, results.has(fn.name), storesJs, jsParams);
+        scanBindingCosts(fn, candidates, blocked, producer, results.has(fn.name), storesJs, jsParams, {
+            sources: new Set(),
+            jsDynArguments,
+        });
     }
     const promoted = new Set();
     for (const [id, cost] of candidates)
@@ -324,8 +590,10 @@ function promotableGlobals(mod, results, jsParams, storesJs) {
 }
 /** Adds to `candidates` the boxing a jsval binding saves and adds in `fn`,
  * and to `blocked` the candidates `fn` references other than by reads and
- * plain writes. */
-function scanBindingCosts(fn, candidates, blocked, producer, jsResult, storesJs, jsParams) {
+ * plain writes. `sources` are bindings taken as jsvals: writing one to a
+ * candidate saves a box, and the copy reads it as a jsval. With
+ * `jsDynArguments`, dynCall and dynInvoke take jsval arguments. */
+function scanBindingCosts(fn, candidates, blocked, producer, jsResult, storesJs, jsParams, { sources, jsDynArguments }) {
     const write = (id, value, weight) => {
         const cost = candidates.get(id);
         if (cost === undefined)
@@ -335,7 +603,9 @@ function scanBindingCosts(fn, candidates, blocked, producer, jsResult, storesJs,
             blocked.add(id);
             return;
         }
-        if (producer(value) || isImmediateSource(value))
+        if (producer(value) ||
+            isImmediateSource(value) ||
+            (value.kind === "varRef" && sources.has(value.localId)))
             cost.saved += weight;
     };
     /* `js`: the expression is an operand the rewrite turns into a jsval. */
@@ -349,7 +619,7 @@ function scanBindingCosts(fn, candidates, blocked, producer, jsResult, storesJs,
             }
             case "assignExpr":
                 write(e.localId, e.value, weight);
-                expr(e.value, false, weight);
+                expr(e.value, sources.has(e.localId), weight);
                 // The assignment's own value is read where it stands.
                 if (!js && candidates.has(e.localId))
                     candidates.get(e.localId).added += weight;
@@ -387,6 +657,22 @@ function scanBindingCosts(fn, candidates, blocked, producer, jsResult, storesJs,
                 }
                 break;
             }
+            case "dynCall":
+            case "dynInvoke": {
+                const jsArgs = jsDynArguments && (e.kind === "dynInvoke" || e.spreads === undefined);
+                for (const arg of e.args)
+                    expr(arg, jsArgs, weight);
+                if (e.kind === "dynInvoke")
+                    expr(e.recv, false, weight);
+                else {
+                    expr(e.callee, false, weight);
+                    if (e.receiver !== undefined)
+                        expr(e.receiver, false, weight);
+                }
+                if (e.calleeNameValue !== undefined)
+                    expr(e.calleeNameValue, false, weight);
+                return;
+            }
             default:
                 break;
         }
@@ -438,13 +724,13 @@ function scanBindingCosts(fn, candidates, blocked, producer, jsResult, storesJs,
             case "varDecl":
                 write(s.localId, s.init, weight);
                 if (s.init !== null)
-                    expr(s.init, false, weight);
+                    expr(s.init, sources.has(s.localId), weight);
                 return;
             case "assign":
                 if (s.initializes !== undefined)
                     blocked.add(s.localId);
                 write(s.localId, s.value, weight);
-                expr(s.value, false, weight);
+                expr(s.value, sources.has(s.localId), weight);
                 return;
             case "while":
             case "doWhile":
@@ -480,13 +766,20 @@ function discardedSequence(e) {
     return e.kind === "seqExpr" && e.generatorDelegate === undefined && e.diverges === undefined;
 }
 /* ── the rewrite ─────────────────────────────────────────────────────── */
-function promoteFunction(fn, results, params, storesJs, globals) {
+function promoteFunction(fn, results, params, storesJs, globals, jsDynArguments) {
     const resultCall = (e) => e.kind === "call" && results.has(e.callee);
     const operatorCall = (e) => isProducerCall(e);
-    const promoted = promotableLocals(fn, (e) => operatorCall(e) || resultCall(e), results.has(fn.name), storesJs, new Map(), params);
+    const ownParams = params.get(fn.name);
+    // The function's own jsval parameters are sources for the copies the
+    // rewrite makes jsval locals.
+    const own = new Map();
+    fn.params.forEach((p, i) => {
+        if (ownParams?.[i] === true)
+            own.set(p.localId, 1);
+    });
+    const promoted = promotableLocals(fn, (e) => operatorCall(e) || resultCall(e), results.has(fn.name), storesJs, own, params, jsDynArguments, globals);
     for (const id of globals)
         promoted.add(id);
-    const ownParams = params.get(fn.name);
     fn.params.forEach((p, i) => {
         if (ownParams?.[i] === true)
             promoted.add(p.localId);
@@ -545,6 +838,24 @@ function promoteFunction(fn, results, params, storesJs, globals) {
             changed = true;
             return { ...e, args: callArgs(e) };
         }
+        // A callee with a jsval entry takes the arguments the rewrite computes
+        // as jsvals unboxed; the call boxes them for any other callee.
+        if (jsDynArguments &&
+            (e.kind === "dynInvoke" || (e.kind === "dynCall" && e.spreads === undefined))) {
+            const args = e.args.map((arg) => producesJs(arg) || isImmediateSource(arg) ? toJs(arg) : rewrite(arg));
+            if (e.kind === "dynInvoke") {
+                const invoke = { ...e, recv: rewrite(e.recv), args };
+                if (e.calleeNameValue !== undefined)
+                    invoke.calleeNameValue = rewrite(e.calleeNameValue);
+                return invoke;
+            }
+            const call = { ...e, callee: rewrite(e.callee), args };
+            if (e.receiver !== undefined)
+                call.receiver = rewrite(e.receiver);
+            if (e.calleeNameValue !== undefined)
+                call.calleeNameValue = rewrite(e.calleeNameValue);
+            return call;
+        }
         return mapExprChildren(e, rewrite, rewriteStmt);
     };
     const rewriteStmt = (s) => {