@scriptc/compiler 0.4.6 → 0.4.8

package/dist/backend/llvm/emit-statements.js

@@ -42,6 +42,7 @@ import { LOOPS } from "./loop-state.js";
 import { loopUnrollAttachment, periodicGuardPeriod } from "./periodic-guards.js";
 import { containsLoop, loopAccessesTypedArrays } from "../loop-polls.js";
 import { emitConstantChoice, matchConstantChoice } from "./constant-choices.js";
+import { emitFusedRecordSet } from "./record-entry-fusion.js";
 /** A callback loop version copies the loop; keep the copies small. */
 const MAX_CALLBACK_VERSION_COST = 400;
 export function emitStmtBody(emitter, s) {
@@ -235,9 +236,12 @@ export function emitStmtBody(emitter, s) {
             // Whole-value uses still retain their own copies, so returning or
             // storing the alias preserves the ordinary heap representation.
             // Boxed captures, reassigned sources and projections need ownership.
+            // A tree value has one owner and no copy to lend: the alias would be
+            // a second pointer the source's scope exit still destroys.
             if (b.kind === "local" &&
                 b.local &&
                 isRefCounted(b.type) &&
+                !emitter.isTreeValue(b.type) &&
                 emitter.stableCallBindings.has(s.localId) &&
                 (emitter.canBorrowCallArgument(s.init) || emitter.unwrittenAlias(s))) {
                 const v = emitter.emitReadReceiver(s.init);
@@ -540,7 +544,7 @@ export function emitStmtBody(emitter, s) {
                 // evaluates it itself.)
                 emitter.emitStoreGuard(obj.name, s);
                 emitter.heapCensus?.countStore((line) => B.line(line), () => B.tmp(), s.className, s.field, s.value, null);
-                emitter.emitNullableFieldStore(obj.name, s.className, s.field, nullable, s.value);
+                emitter.emitNullableFieldStore(obj.name, s.className, s.field, nullable, s.value, emitter.freshFieldStores.has(s));
                 break;
             }
             if (s.kind === "fieldSet" && emitter.int32Slots.isField(s.className, s.field)) {
@@ -563,11 +567,36 @@ export function emitStmtBody(emitter, s) {
             }
             else if (emitter.publishedTypes?.recordGuarded(s.shapeId) === true)
                 emitter.emitPublishedFieldGuard(obj.name, null, s.field);
+            if (s.kind === "recordSet" && emitter.partialFieldMissing(s.shapeId, s.field)) {
+                // A field a partial record view may lack: the view keeps it as a
+                // boxed property when the viewed record does not declare it.
+                const fieldType = emitter
+                    .recordShape(s.shapeId)
+                    .fields.find((f) => f.name === s.field).type;
+                const fieldInline = emitter.recordFieldInline(s.shapeId, s.field);
+                emitter.storePartialField(obj.name, s.shapeId, s.field, fieldType, v, (slot) => {
+                    // A result-slot entry fills zeroed caller storage, each field
+                    // once; a constructor's first store to its own field fills the
+                    // slot `new` left.
+                    if (resultSlotStore(emitter.currentFunctionName, s) || emitter.freshFieldStores.has(s))
+                        emitter.initField(slot, fieldType, fieldInline, v);
+                    else
+                        emitter.replaceField(slot, fieldType, fieldInline, v);
+                }, 
+                // The store owns the value on the slot path; the extra-property
+                // path boxes it (retaining) and gives up the store's reference.
+                () => {
+                    if (!fieldInline && isRefCounted(fieldType))
+                        emitter.releaseHeap(v.name, fieldType);
+                });
+                break;
+            }
             const { ptr, type, inline } = s.kind === "fieldSet"
                 ? emitter.classFieldPtr(obj.name, s.className, s.field, "compressed")
                 : emitter.recordFieldPtr(obj.name, s.shapeId, s.field);
-            // A result-slot entry fills zeroed caller storage, each field once.
-            if (resultSlotStore(emitter.currentFunctionName, s))
+            // A result-slot entry fills zeroed caller storage, each field once; a
+            // constructor's first store to its own field fills the slot `new` left.
+            if (resultSlotStore(emitter.currentFunctionName, s) || emitter.freshFieldStores.has(s))
                 emitter.initField(ptr, type, inline, v);
             else
                 emitter.replaceField(ptr, type, inline, v);
@@ -608,6 +637,26 @@ export function emitStmtBody(emitter, s) {
             // whose writes validate and can throw, stay refused), undeclared
             // keys insert/replace in the overflow map. Evaluation order: obj,
             // key, value; the write OWNS the value (+1 moves in).
+            const paired = emitter.recordEntryFusion?.writes.get(s);
+            const pairedIv = paired === undefined ? undefined : emitter.recordShape(s.shapeId).indexValue;
+            if (paired !== undefined && (pairedIv?.kind === "f64" || pairedIv?.kind === "bool")) {
+                // Paired with a fused read of the same object and key binding
+                // (record-entry-fusion.ts): the read already evaluated both and
+                // parked the overflow entry, so the write evaluates only the value
+                // and overwrites the entry's value slot in place. A miss takes the
+                // ordinary insert with the parked map and key.
+                const v = emitter.emitExpr(s.value);
+                const vAcc = pairedIv.kind === "f64" ? "f64" : "bool";
+                if (emitFusedRecordSet(emitter, s, { name: v.name, access: vAcc }, (map, key) => emitter.mapSet(map, "str", vAcc, key, v.name)))
+                    break;
+                // The paired read took a non-fused lowering: finish with the
+                // ordinary set. Both bindings are plain variables, so reading them
+                // after the value is unobservable.
+                const objFallback = emitter.emitExpr(s.obj);
+                const keyFallback = emitter.emitExpr(s.key);
+                emitter.mapSet(emitter.recordOvfPtr(objFallback.name, s.shapeId), "str", vAcc, keyFallback.name, v.name);
+                break;
+            }
             const obj = emitter.emitExpr(s.obj);
             const key = emitter.emitExpr(s.key);
             const v = emitter.emitExpr(s.value);
@@ -707,21 +756,36 @@ export function emitStmtBody(emitter, s) {
                 const ln = B.newLabel("rks.n");
                 B.condBr(hit, lh, ln);
                 B.startBlock(lh);
-                const { ptr, type, inline } = emitter.recordFieldPtr(obj.name, s.shapeId, f.name);
-                if (inline) {
-                    // The write owns the moved-in value; the slot copies its bits.
-                    emitter.storeField(ptr, type, v.name, true);
-                    emitter.releaseHeap(v.name, type);
-                }
-                else if (isRefCounted(type)) {
-                    const old = B.tmp();
-                    B.line(`${old} = load ptr, ptr ${ptr}`);
-                    emitter.storeField(ptr, type, v.name, false);
-                    emitter.releaseHeap(old, type);
-                }
-                else {
-                    emitter.storeField(ptr, type, v.name, false);
-                }
+                const partial = emitter.partialFieldMissing(s.shapeId, f.name);
+                // A field a partial record view may lack has no slot to address:
+                // its write goes through the view's extra-property store.
+                const field = partial
+                    ? { type: f.type, inline: emitter.recordFieldInline(s.shapeId, f.name), ptr: "" }
+                    : emitter.recordFieldPtr(obj.name, s.shapeId, f.name);
+                const { ptr, type, inline } = field;
+                const storeAt = (slot) => {
+                    if (inline) {
+                        // The write owns the moved-in value; the slot copies its bits.
+                        emitter.storeField(slot, type, v.name, true);
+                        emitter.releaseHeap(v.name, type);
+                    }
+                    else if (isRefCounted(type)) {
+                        const old = B.tmp();
+                        B.line(`${old} = load ptr, ptr ${slot}`);
+                        emitter.storeField(slot, type, v.name, false);
+                        emitter.releaseHeap(old, type);
+                    }
+                    else {
+                        emitter.storeField(slot, type, v.name, false);
+                    }
+                };
+                if (partial)
+                    emitter.storePartialField(obj.name, s.shapeId, f.name, type, v, storeAt, () => {
+                        if (inline || isRefCounted(type))
+                            emitter.releaseHeap(v.name, type);
+                    });
+                else
+                    storeAt(ptr);
                 B.br(join);
                 B.startBlock(ln);
             }
@@ -983,6 +1047,14 @@ export function emitStmtBody(emitter, s) {
             let countedJoin = null;
             if ((countedLoop?.guarded || pairedLoop?.guarded) &&
                 !LOOPS.of(emitter).provenCountedGuards.has(s)) {
+                // A function that emits each loop once takes only the copy without
+                // the integer form, which needs no safety test.
+                if (LOOPS.of(emitter).plainLoops) {
+                    LOOPS.of(emitter).countedLoopsEnabled = false;
+                    emitSlowCopy(emitter, s);
+                    LOOPS.of(emitter).countedLoopsEnabled = true;
+                    break;
+                }
                 const safe = countedLoop
                     ? emitCountedLoopSafety(emitter, countedLoop)
                     : emitPairedLoopSafety(emitter, pairedLoop);
@@ -1105,31 +1177,32 @@ export function emitStmtBody(emitter, s) {
                 }
             };
             // A counted loop over typed arrays, or a loop to a typed array's
-            // length, polls between blocks of WORKER_POLL_BLOCK iterations instead
+            // length, polls between blocks of workerPollBlock iterations instead
             // of in its body: the inner loop over a block then has no exit
             // besides its own bound, which LLVM can vectorize. A typed
             // array's length is fixed, so each block can take it as its limit when
             // the loop does not assign the array's binding.
             //
             // Inside another loop of this function, which polls at least once
-            // every WORKER_POLL_BLOCK of its own iterations, a loop needs less:
+            // every workerPollBlock of its own iterations, a loop needs less:
             // - a loop whose counters' ranges bound its runs, and those of the
-            //   loops in its body, to WORKER_POLL_BLOCK^2 needs no poll;
+            //   loops in its body, to workerPollBlock^2 needs no poll;
             // - an innermost counted loop is strip-mined, typed arrays or not,
             //   and does not poll after its last block. A run of at most
-            //   WORKER_POLL_BLOCK iterations then never polls, and the countdown
+            //   workerPollBlock iterations then never polls, and the countdown
             //   leaves its body. A run of at most WORKER_UNPOLLED_RUN iterations
             //   is one block, polled once as it leaves.
+            const pollBlock = workerPollBlock(emitter);
             const enclosed = emitter.mod.workers === true &&
                 emitter.jumpTargets.some((target) => target.kind === "loop");
-            const bounded = enclosed && boundedLoopRuns(emitter, s) <= WORKER_POLL_BLOCK * WORKER_POLL_BLOCK;
+            const bounded = enclosed && boundedLoopRuns(emitter, s) <= pollBlock * pollBlock;
             const innermost = enclosed && !containsLoop(s.body);
             const stripMined = !bounded &&
                 capturedLets.length === 0 &&
                 integerSlot !== null &&
                 ((countedLoop !== null &&
                     countedLimit !== null &&
-                    Math.abs(countedLoop.step) * WORKER_POLL_BLOCK <= 2 ** 52) ||
+                    Math.abs(countedLoop.step) * pollBlock <= 2 ** 52) ||
                     (integerLoop !== null && integerArrayLoop === null && integerLoop.stableReceiver)) &&
                 emitter.workerLoopPolls(s) &&
                 (loopAccessesTypedArrays(s) || (countedLoop !== null && innermost));
@@ -1138,9 +1211,10 @@ export function emitStmtBody(emitter, s) {
             // step on each side, has a run whose length its counters fix on entry.
             // With a small body, a run of at most WORKER_UNPOLLED_RUN steps takes a
             // plain copy of the loop without a poll, which polls once as it leaves
-            // when it ran more than WORKER_POLL_BLOCK steps, like a strip-mined run;
+            // when it ran more than workerPollBlock steps, like a strip-mined run;
             // longer runs take the loop as it is emitted otherwise.
             const shortRuns = !innermost ||
+                LOOPS.of(emitter).plainLoops ||
                 bounded ||
                 capturedLets.length > 0 ||
                 !emitter.workerLoopPolls(s) ||
@@ -1305,7 +1379,7 @@ export function emitStmtBody(emitter, s) {
                     emitPlainLoop(shortEnd, null);
                     // A run longer than one block polls once as it leaves.
                     B.startBlock(shortEnd);
-                    B.line(`${pollsAfter} = icmp sgt i64 ${left}, ${shortRuns.stride * WORKER_POLL_BLOCK}`);
+                    B.line(`${pollsAfter} = icmp sgt i64 ${left}, ${shortRuns.stride * pollBlock}`);
                     B.condBr(pollsAfter, shortPoll, exit);
                     B.startBlock(shortPoll);
                     emitter.emitWorkerPoll();
@@ -1685,6 +1759,27 @@ export function emitStmtBody(emitter, s) {
             emitter.emitUnwind();
             break;
         }
+        case "genBindBarrier": {
+            // The end of a generator's parameter prologue (fn.generator.bindAtCall):
+            // suspend invisibly so the spawn wrapper can run the prologue at the
+            // call. No OUT value is produced and no IN value is taken — the first
+            // `.next(v)` argument stays unread, exactly as a suspendedStart
+            // generator discards it — but the resumption may carry an injected
+            // throw or the `.return()` sentinel, so it checks like a yield.
+            if (emitter.currentGenerator === null)
+                throw new InternalCompilerError("llvm emitter bug: genBindBarrier outside a generator body");
+            if (emitter.currentCoro !== null) {
+                emitter.emitCoroSuspendPrepared();
+            }
+            else {
+                // A fiber body parks no OUT value and switches back to the resumer:
+                // the valueless yield form the runtime already offers.
+                emitter.declare(`declare void @scr_gen_yield_ref(ptr, ptr)`);
+                B.line(`call void @scr_gen_yield_ref(ptr null, ptr null)`);
+            }
+            emitter.emitPendingCheck();
+            break;
+        }
         case "tryCatch":
             emitter.emitTryCatch(s);
             break;
@@ -2574,8 +2669,15 @@ function emitInt32KindLoop(emitter, plan, exit, ordinary) {
 }
 /** At the top of a loop copy's header: lets a speculative loop find its
  * ordinary copy's header, and keeps its third copy out of the loop. */
-/** Iterations between cancellation polls of a strip-mined counted loop. */
-const WORKER_POLL_BLOCK = 64;
+/** Iterations between cancellation polls of a strip-mined counted loop. A
+ * block holds at least one step of the vectorized loop over bytes, so that
+ * a full block runs vector code: 64 iterations at the baseline (16-byte
+ * vectors, interleaved 4 times), and 128 when the program's code is compiled
+ * for x86-64-v3 or above, whose vectors take 32 bytes. */
+function workerPollBlock(emitter) {
+    const cpu = emitter.targetCpu;
+    return emitter.cpuDispatch || cpu === "x86-64-v3" || cpu === "x86-64-v4" ? 128 : 64;
+}
 /** The longest run of a strip-mined loop inside another loop that polls
  * only as it leaves. */
 const WORKER_UNPOLLED_RUN = 16384;
@@ -2611,7 +2713,8 @@ function boundedLoopRuns(emitter, loop) {
         if (stepped && range && exactSteps(range, stepped.step))
             trips = Math.floor((range.max - range.min) / Math.abs(stepped.step)) + 1;
     }
-    if (!(trips <= WORKER_POLL_BLOCK * WORKER_POLL_BLOCK))
+    const pollBlock = workerPollBlock(emitter);
+    if (!(trips <= pollBlock * pollBlock))
         return Infinity;
     let nested = 0;
     const visit = (s) => {
@@ -2648,22 +2751,23 @@ function emitPairedLoopGap(emitter, slots) {
     B.line(`${gap} = sub nsw i64 ${high}, ${low}`);
     return gap;
 }
-/** A counted `for` loop of a worker program as blocks of WORKER_POLL_BLOCK
+/** A counted `for` loop of a worker program as blocks of workerPollBlock
  * iterations, with the cancellation poll between blocks: the outer header
  * tests the counter against the loop's limit, each block runs the body up
- * to the nearer of the limit and WORKER_POLL_BLOCK steps on, and the poll
+ * to the nearer of the limit and workerPollBlock steps on, and the poll
  * follows the block. It polls once per block, and the inner loop's only
  * exit besides `break` and `return` is its bound.
  *
  * With `runSlot` (for a loop that another loop of the function encloses), a
  * block that ends at the limit leaves the loop without polling, and a run
  * of at most WORKER_UNPOLLED_RUN iterations is one block, polled once as
- * it leaves when it took more than WORKER_POLL_BLOCK iterations. `runSlot`
+ * it leaves when it took more than workerPollBlock iterations. `runSlot`
  * holds whether the current block is such a run. */
 function emitStripMinedCountedLoop(emitter, s, counter, boundSlot, exit, runSlot) {
     const B = emitter.B;
     const { slot, type, signed, step } = counter;
     const ascending = step > 0;
+    const pollBlock = workerPollBlock(emitter);
     const compare = !signed ? "ult" : ascending ? "slt" : "sgt";
     const saturating = `llvm.${signed ? "sadd" : "uadd"}.sat.${type}`;
     const nearer = `llvm.${!signed ? "umin" : ascending ? "smin" : "smax"}.${type}`;
@@ -2688,7 +2792,7 @@ function emitStripMinedCountedLoop(emitter, s, counter, boundSlot, exit, runSlot
     B.startBlock(block);
     const stepped = B.tmp();
     const bound = B.tmp();
-    B.line(`${stepped} = call ${type} @${saturating}(${type} ${start}, ${type} ${step * WORKER_POLL_BLOCK})`);
+    B.line(`${stepped} = call ${type} @${saturating}(${type} ${start}, ${type} ${step * pollBlock})`);
     B.line(`${bound} = call ${type} @${nearer}(${type} ${stepped}, ${type} ${limit})`);
     if (runSlot === null)
         B.line(`store ${type} ${bound}, ptr ${boundSlot}`);
@@ -2700,7 +2804,7 @@ function emitStripMinedCountedLoop(emitter, s, counter, boundSlot, exit, runSlot
             ? `${left} = sub ${wrap} ${type} ${limit}, ${start}`
             : `${left} = sub ${wrap} ${type} ${start}, ${limit}`);
         B.line(`${whole} = icmp ule ${type} ${left}, ${stride * WORKER_UNPOLLED_RUN}`);
-        B.line(`${long} = icmp ugt ${type} ${left}, ${stride * WORKER_POLL_BLOCK}`);
+        B.line(`${long} = icmp ugt ${type} ${left}, ${stride * pollBlock}`);
         B.line(`${polled} = and i1 ${whole}, ${long}`);
         B.line(`${end} = select i1 ${whole}, ${type} ${limit}, ${type} ${bound}`);
         B.line(`store ${type} ${end}, ptr ${boundSlot}`);