@scriptc/compiler 0.4.6 → 0.4.8

package/dist/backend/llvm/expr-dynamic.js

@@ -12,12 +12,14 @@ import { streamTypedRefEligible } from "../../ir/analysis.js";
 import { DYN, isDynTypedRefType, textCodecRecordClass, isRefCounted, isUnitType, typeEquals, typeKey, VOID, } from "../../ir/ir.js";
 import { BYTES_ELEM_NUM, closureIdentityEqual } from "./common.js";
 import { DYN_KIND } from "./dyn.js";
-import { elemAccess, vAdapters } from "./shapes.js";
+import { elemAccess, releaseSym, vAdapters } from "./shapes.js";
+import { JS_BITS } from "./jsval-encoding.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { emitUnionWiden } from "./expr-records.js";
 import { emitJsIcLiteralMember, emitJsIcMethod, jsIcMethods } from "./js-ic.js";
+import { jsImmediates } from "./jsval.js";
 import { jsIcLiteralKey } from "../../ir/js-ic.js";
-import { DYN_BUFFER_METHODS } from "../../ir/runtime-features.js";
+import { ARRAY_PROTOTYPE_MEMBER_NAMES, DYN_BUFFER_METHODS } from "../../ir/runtime-features.js";
 export function emitDynamicExpr(host, e, discarded = false) {
     const B = host.B;
     switch (e.kind) {
@@ -73,11 +75,32 @@ export function emitDynamicExpr(host, e, discarded = false) {
             if (v.type.kind === "func") {
                 // A closure boxes as the checked-dynamic tree's function kind: retained closure +
                 // the per-signature call thunk + the interned signature key. The
-                // best-effort name rides along (null when the lowering had none).
-                const name = e.fnName !== undefined && e.fnName !== "" ? host.cstr(e.fnName) : "null";
-                const box = host.dyn.dynFuncBoxHelper(v.type);
+                // best-effort name rides along (null when the lowering had none). A
+                // closure made here takes its name from the closure-name table at
+                // compile time.
                 const t = B.tmp();
-                B.line(`${t} = call ptr @${box}(ptr ${v.name}, ptr ${name})`);
+                const name = e.fnName !== undefined && e.fnName !== ""
+                    ? e.fnName
+                    : e.value.kind === "closure" && e.value.adapts !== true
+                        ? host.closureNameOf(e.value.fnName)
+                        : undefined;
+                if (name !== undefined) {
+                    const box = host.dyn.dynFuncBoxHelper(v.type);
+                    let nameArg = name === null ? "null" : host.cstr(name);
+                    if (name !== null && e.fnNameMainThreadOnly) {
+                        // Node's main thread wraps the function under this name; a
+                        // Worker hands out the unwrapped function, named "".
+                        host.declare(`declare zeroext i1 @scr_context_is_main()`);
+                        const onMain = B.tmp();
+                        B.line(`${onMain} = call zeroext i1 @scr_context_is_main()`);
+                        const chosen = B.tmp();
+                        B.line(`${chosen} = select i1 ${onMain}, ptr ${nameArg}, ptr ${host.cstr("")}`);
+                        nameArg = chosen;
+                    }
+                    B.line(`${t} = call ptr @${box}(ptr ${v.name}, ptr ${nameArg})`);
+                }
+                else
+                    B.line(`${t} = ${host.dyn.unnamedFuncBoxCall(v.type, v.name)}`);
                 if (e.fnLength !== undefined) {
                     host.declare(`declare void @scr_dyn_function_set_length(ptr, i32)`);
                     B.line(`call void @scr_dyn_function_set_length(ptr ${t}, i32 ${e.fnLength})`);
@@ -145,6 +168,21 @@ export function emitDynamicExpr(host, e, discarded = false) {
                 return out;
             }
             const args = e.args.map((a) => emitBorrowedInput(host, a));
+            host.declare(`declare ptr @scr_dyn_call(ptr, ptr, ${host.sizeType}, ptr)`);
+            const fast = jsEntrySites(host);
+            if (fast || args.some((a) => a.type.kind === "jsval")) {
+                const name = calleeName();
+                const t = emitJsvalArgumentsCall(host, callee.name, receiver?.name ?? "null", args, fast, (argsPtr) => {
+                    const r = B.tmp();
+                    B.line(`call void @scr_dyn_this_push_dyn(ptr ${receiver?.name ?? "null"})`);
+                    B.line(`${r} = call ptr @scr_dyn_call(ptr ${callee.name}, ptr ${argsPtr}, ${host.sizeType} ${args.length}, ptr ${name})`);
+                    B.line("call void @scr_dyn_this_pop()");
+                    return r;
+                });
+                const out = host.own({ name: t, type: e.type });
+                host.emitPendingCheck();
+                return out;
+            }
             let argsPtr = "null";
             if (args.length > 0) {
                 const arr = B.slot();
@@ -156,7 +194,6 @@ export function emitDynamicExpr(host, e, discarded = false) {
                 });
                 argsPtr = arr;
             }
-            host.declare(`declare ptr @scr_dyn_call(ptr, ptr, ${host.sizeType}, ptr)`);
             const t = B.tmp();
             const name = calleeName();
             B.line(`call void @scr_dyn_this_push_dyn(ptr ${receiver?.name ?? "null"})`);
@@ -195,6 +232,37 @@ export function emitDynamicExpr(host, e, discarded = false) {
                     B.line(`call void @scr_dyn_func_set_message(ptr ${args[1].name}, ptr @${host.dyn.dynFuncThunkHelper(listener)}, ptr @${entry})`);
                 }
             }
+            // Buffer.prototype method names take their scr_bytes_dyn.c entry, which
+            // runs them on Buffer receivers and dispatches any other receiver.
+            // Each call passes its method name's id slot, so only the first call
+            // looks the name up.
+            const invoke = DYN_BUFFER_METHODS.get(e.method) ?? "scr_dyn_invoke_prepared_id";
+            const discardedPush = discarded && e.method === "push" && invoke === "scr_dyn_invoke_prepared_id";
+            const fast = !discardedPush && invoke === "scr_dyn_invoke_prepared_id" && jsEntrySites(host);
+            if (fast || args.some((a) => a.type.kind === "jsval")) {
+                const name = discardedPush ? host.cstr(e.calleeName) : dynInvokeCalleeName(host, e);
+                if (discardedPush)
+                    host.declare(`declare void @scr_dyn_invoke_discard_id(ptr, ptr, ptr, ptr, ptr, ${host.sizeType}, ptr)`);
+                else
+                    host.declare(`declare ptr @${invoke}(ptr, ptr, ptr, ptr, ptr, ${host.sizeType}, ptr)`);
+                const t = emitJsvalArgumentsCall(host, prepared, recv.name, args, fast, (argsPtr) => {
+                    const site = `ptr ${recv.name}, ptr ${prepared}, ptr ${host.cstr(e.method)}, ptr ${host.methodIdSlot(e.method)}, ptr ${argsPtr}, ${host.sizeType} ${args.length}, ptr ${name}`;
+                    if (discardedPush) {
+                        B.line(`call void @scr_dyn_invoke_discard_id(${site})`);
+                        return "null";
+                    }
+                    const r = B.tmp();
+                    B.line(`${r} = call ptr @${invoke}(${site})`);
+                    return r;
+                });
+                if (discardedPush) {
+                    host.emitPendingCheck();
+                    return { name: "", type: VOID };
+                }
+                const out = host.own({ name: t, type: e.type });
+                host.emitPendingCheck();
+                return out;
+            }
             let argsPtr = "null";
             if (args.length > 0) {
                 const arr = B.slot();
@@ -206,11 +274,6 @@ export function emitDynamicExpr(host, e, discarded = false) {
                 });
                 argsPtr = arr;
             }
-            // Buffer.prototype method names take their scr_bytes_dyn.c entry, which
-            // runs them on Buffer receivers and dispatches any other receiver.
-            // Each call passes its method name's id slot, so only the first call
-            // looks the name up.
-            const invoke = DYN_BUFFER_METHODS.get(e.method) ?? "scr_dyn_invoke_prepared_id";
             // A statement-position push drops the new length, so its entry
             // need not box it.
             if (discarded && e.method === "push" && invoke === "scr_dyn_invoke_prepared_id") {
@@ -220,12 +283,7 @@ export function emitDynamicExpr(host, e, discarded = false) {
                 return { name: "", type: VOID };
             }
             host.declare(`declare ptr @${invoke}(ptr, ptr, ptr, ptr, ptr, ${host.sizeType}, ptr)`);
-            let name = host.cstr(e.calleeName);
-            if (e.calleeNameValue !== undefined) {
-                const value = emitBorrowedInput(host, e.calleeNameValue);
-                name = B.tmp();
-                B.line(`${name} = getelementptr inbounds %ScrStr, ptr ${value.name}, i32 1`);
-            }
+            const name = dynInvokeCalleeName(host, e);
             const t = B.tmp();
             B.line(`${t} = call ptr @${invoke}(ptr ${recv.name}, ptr ${prepared}, ptr ${host.cstr(e.method)}, ptr ${host.methodIdSlot(e.method)}, ptr ${argsPtr}, ${host.sizeType} ${args.length}, ptr ${name})`);
             const out = host.own({ name: t, type: e.type });
@@ -421,6 +479,24 @@ export function emitDynamicExpr(host, e, discarded = false) {
                     B.br(join);
                     return;
                 }
+                // A scalar primitive arm under a LITERAL key the frontend proved
+                // the primitive does not declare (`{ url?: string } | "pending"`
+                // read as `x?.url`): JS boxes the primitive, finds no such
+                // property, and answers undefined — the record arm's
+                // missing-key answer below.
+                if (literal !== null &&
+                    (arm.kind === "string" ||
+                        arm.kind === "f64" ||
+                        arm.kind === "bool" ||
+                        arm.kind === "bigint")) {
+                    const tag = resultDef?.arms.findIndex((a) => a.kind === "undefinedT") ?? -1;
+                    if (tag < 0 || e.type.kind !== "union") {
+                        throw new InternalCompilerError("llvm emitter bug: unionKeyGet primitive arm without an undefined result arm");
+                    }
+                    B.line(`store ptr ${host.unitInstanceRef(e.type.unionId, tag)}, ptr ${slot}`);
+                    B.br(join);
+                    return;
+                }
                 if (arm.kind !== "record")
                     throw new LlvmUnsupportedError(`unionKeyGet:${arm.kind}`, e.loc);
                 const shape = host.recordShape(arm.shapeId);
@@ -460,6 +536,17 @@ export function emitDynamicExpr(host, e, discarded = false) {
                     B.br(join);
                     return;
                 }
+                // A declared-only arm without the literal key: the object has no
+                // such own property, so the read answers undefined.
+                if (literal !== null && !shape.indexValue) {
+                    const tag = resultDef?.arms.findIndex((a) => a.kind === "undefinedT") ?? -1;
+                    if (tag < 0 || e.type.kind !== "union") {
+                        throw new InternalCompilerError("llvm emitter bug: unionKeyGet missing key without an undefined result arm");
+                    }
+                    B.line(`store ptr ${host.unitInstanceRef(e.type.unionId, tag)}, ptr ${slot}`);
+                    B.br(join);
+                    return;
+                }
                 // Index-signature arm (or declared-only shape under a runtime
                 // key): the shared keyed-read chain — a literal key naming no
                 // declared field touches only the overflow map.
@@ -491,9 +578,12 @@ export function emitDynamicExpr(host, e, discarded = false) {
             const helper = e.key.type.kind === "dyn" ? host.dyn.dynComputedKeyGetHelper() : host.dyn.dynKeyGetHelper();
             const t = B.tmp();
             const generic = `call ptr @${helper}(ptr ${d.name}, ptr ${k.name}, i1 ${e.optional ? "true" : "false"})`;
-            const inherited = e.key.kind === "strLit" && INHERITED_OBJECT_MEMBERS.has(e.key.value);
+            const inherited = e.key.kind === "strLit" &&
+                (INHERITED_OBJECT_MEMBERS.has(e.key.value) ||
+                    ARRAY_PROTOTYPE_MEMBER_NAMES.has(e.key.value));
             // Object.prototype itself answers its own members before the ordinary
-            // read (which fences reflection on the prototype).
+            // read (which fences reflection on the prototype); an array answers
+            // the methods its prototype installs.
             let prototypeJoin = null;
             if (inherited) {
                 host.declare(`declare ptr @scr_dyn_object_prototype_member(ptr, ptr)`);
@@ -536,9 +626,10 @@ export function emitDynamicExpr(host, e, discarded = false) {
             }
             let result = t;
             if (prototypeJoin) {
-                // An undefined read of an Object.prototype member name answers the
-                // member the receiver inherits (scr_dyn_invoke.c; the frontend
-                // links that unit for these reads).
+                // An undefined read of an Object.prototype member name, or of an
+                // Array.prototype method on an array, answers the member the
+                // receiver inherits (scr_dyn_invoke.c; the frontend links that unit
+                // for these reads).
                 host.declare(`declare ptr @scr_dyn_inherited_read(ptr, ptr, ptr)`);
                 const read = B.tmp();
                 B.line(`${read} = call ptr @scr_dyn_inherited_read(ptr ${d.name}, ptr ${k.name}, ptr ${t})`);
@@ -1267,4 +1358,127 @@ function messageListenerArg(e) {
         return null;
     return listener.value.type;
 }
+/** Whether a dynCall or dynInvoke site of the current function tests its
+ * callee for a jsval entry (emitJsvalArgumentsCall): dynamic-tier code of
+ * a module with closure jsval bodies, on targets with jsval words. */
+function jsEntrySites(host) {
+    return (host.jsEntries &&
+        jsImmediates(host) &&
+        host.fnByName.get(host.currentFunctionName)?.tier === "dynamic");
+}
+/** A call of the function value `callee` (null for a site without one)
+ * with `args`, which may include jsval words (ir/jsval.ts). With `fast`,
+ * a callee boxed from a closure with a jsval body (ScrDyn.v.fn.js, +72)
+ * takes the arguments as words, a dyn argument under the cell tag, with
+ * `receiver` bound as `this` around the call. Every other call goes
+ * through `slow`, which takes an array of dyn arguments: the words boxed
+ * for it and released after it. Returns the owned dyn result (null on
+ * the slow path with an exception pending). */
+function emitJsvalArgumentsCall(host, callee, receiver, args, fast, slow) {
+    const B = host.B;
+    const n = args.length;
+    const result = B.slot();
+    B.entryAllocas.push(`${result} = alloca ptr`);
+    const lSlow = B.newLabel("jse.slow");
+    const lJoin = B.newLabel("jse.join");
+    if (fast && callee !== null) {
+        let words = "null";
+        if (n > 0) {
+            words = B.slot();
+            B.entryAllocas.push(`${words} = alloca [${n} x ptr]`);
+            args.forEach((a, i) => {
+                let word = a.name;
+                if (a.type.kind !== "jsval") {
+                    const bits = B.tmp();
+                    const tagged = B.tmp();
+                    word = B.tmp();
+                    B.line(`${bits} = ptrtoint ptr ${a.name} to i64`);
+                    B.line(`${tagged} = or i64 ${bits}, ${JS_BITS.cellTag}`);
+                    B.line(`${word} = inttoptr i64 ${tagged} to ptr`);
+                }
+                const p = B.tmp();
+                B.line(`${p} = getelementptr inbounds [${n} x ptr], ptr ${words}, i64 0, i64 ${i}`);
+                B.line(`store ptr ${word}, ptr ${p}`);
+            });
+        }
+        const lKind = B.newLabel("jse.kind");
+        const lFn = B.newLabel("jse.fn");
+        const lEntry = B.newLabel("jse.entry");
+        const present = B.tmp();
+        B.line(`${present} = icmp ne ptr ${callee}, null`);
+        B.condBr(present, lKind, lSlow);
+        B.startBlock(lKind);
+        const kindPtr = B.tmp();
+        const kind = B.tmp();
+        const isFn = B.tmp();
+        B.line(`${kindPtr} = getelementptr inbounds i8, ptr ${callee}, i64 8`);
+        B.line(`${kind} = load i32, ptr ${kindPtr}`);
+        B.line(`${isFn} = icmp eq i32 ${kind}, ${DYN_KIND.FUNC}`);
+        B.condBr(isFn, lFn, lSlow);
+        B.startBlock(lFn);
+        const entryPtr = B.tmp();
+        const entry = B.tmp();
+        const hasEntry = B.tmp();
+        B.line(`${entryPtr} = getelementptr inbounds i8, ptr ${callee}, i64 72 ; ->v.fn.js`);
+        B.line(`${entry} = load ptr, ptr ${entryPtr}`);
+        B.line(`${hasEntry} = icmp ne ptr ${entry}, null`);
+        B.condBr(hasEntry, lEntry, lSlow);
+        B.startBlock(lEntry);
+        const cloPtr = B.tmp();
+        const clo = B.tmp();
+        const word = B.tmp();
+        const value = B.tmp();
+        host.declare("declare void @scr_dyn_this_push_dyn(ptr)");
+        host.declare("declare void @scr_dyn_this_pop()");
+        host.declare("declare ptr @scr_js_to_dyn(ptr)");
+        B.line(`${cloPtr} = getelementptr inbounds i8, ptr ${callee}, i64 16 ; ->v.fn.clo`);
+        B.line(`${clo} = load ptr, ptr ${cloPtr}`);
+        B.line(`call void @scr_dyn_this_push_dyn(ptr ${receiver})`);
+        B.line(`${word} = call ptr ${entry}(ptr ${clo}, ptr ${words}, ${host.sizeType} ${n})`);
+        B.line("call void @scr_dyn_this_pop()");
+        B.line(`${value} = call ptr @scr_js_to_dyn(ptr ${word})`);
+        B.line(`store ptr ${value}, ptr ${result}`);
+        B.br(lJoin);
+    }
+    else {
+        B.br(lSlow);
+    }
+    B.startBlock(lSlow);
+    let cells = "null";
+    const boxed = [];
+    if (n > 0) {
+        cells = B.slot();
+        B.entryAllocas.push(`${cells} = alloca [${n} x ptr]`);
+        args.forEach((a, i) => {
+            let cell = a.name;
+            if (a.type.kind === "jsval") {
+                host.declare("declare ptr @scr_js_to_dyn_borrow(ptr)");
+                cell = B.tmp();
+                B.line(`${cell} = call ptr @scr_js_to_dyn_borrow(ptr ${a.name})`);
+                boxed.push(cell);
+            }
+            const p = B.tmp();
+            B.line(`${p} = getelementptr inbounds [${n} x ptr], ptr ${cells}, i64 0, i64 ${i}`);
+            B.line(`store ptr ${cell}, ptr ${p}`);
+        });
+    }
+    const r = slow(cells);
+    for (const cell of boxed)
+        B.line(`call void ${releaseSym(host.shapeHost, DYN)}(ptr ${cell})`);
+    B.line(`store ptr ${r}, ptr ${result}`);
+    B.br(lJoin);
+    B.startBlock(lJoin);
+    const out = B.tmp();
+    B.line(`${out} = load ptr, ptr ${result}`);
+    return out;
+}
+/** A dynInvoke's callee spelling for the runtime's error texts. */
+function dynInvokeCalleeName(host, e) {
+    if (e.calleeNameValue === undefined)
+        return host.cstr(e.calleeName);
+    const value = emitBorrowedInput(host, e.calleeNameValue);
+    const name = host.B.tmp();
+    host.B.line(`${name} = getelementptr inbounds %ScrStr, ptr ${value.name}, i32 1`);
+    return name;
+}
 //# sourceMappingURL=expr-dynamic.js.map