@scriptc/compiler 0.3.3 → 0.3.4

package/dist/backend/llvm/emitter.d.ts

@@ -215,6 +215,7 @@ export declare class LlEmitter {
     readonly checkedNarrows: CheckedNarrows;
     callArrayReads: Map<IrExpr, LocalArrayRead>;
     mapReadLifetimes: MapReadLifetimes;
+    readNumberMapWrites: ReadonlySet<IrExpr>;
     readonly callLifetimes: CallLifetimes;
     readonly constantCallbacks: Map<string, Map<string, string>>;
     currentConstantCallbacks: ReadonlyMap<string, string>;
@@ -687,6 +688,11 @@ export declare class LlEmitter {
      * conditions in expr-calls.ts). */
     private callTestsPending;
     private workerLoopBudget;
+    /** The amortized cancellation poll, emitted on the loop's back edge (the
+     * continue target), after the body. A poll in the header would be a loop
+     * exit ahead of the body; LLVM then cannot rotate the loop, so loads that
+     * the body repeats on every iteration (a typed array's length, for one)
+     * stay in the loop. */
     private emitWorkerLoopCheck;
     /** Moves an already-evaluated value into the runtime's exception cell —
      * the `throw` statement's kind dispatch (stmts.ts's), shared with
@@ -1036,6 +1042,12 @@ export declare class LlEmitter {
     emitRecordExpr(e: ExprOf<"fieldGet" | "recordGet" | "recordLit" | "recordClone" | "recordKeyGet" | "recordOvfKeys" | "recordOvfHas" | "recordHas" | "fieldAbsent">): LlValue;
     emitDynamicExpr(e: ExprOf<"dynFrom" | "dynCall" | "dynInvoke" | "dynArrLit" | "dynObjLit" | "unionWrap" | "unionNarrow" | "unionDisc" | "unionKeyGet" | "unionIsTag" | "dynKeyGet" | "dynHasKey" | "dynScalarEq" | "dynTest" | "unionEq" | "unionFuncEq" | "caughtTest" | "caughtCheck" | "caughtNarrow" | "caughtToDyn">): LlValue;
     emitIntrinsicExpr(e: ExprOf<"intrinsic">): LlValue;
+    /** InternTable's runtime calls (scr_itable.c). Table and entry handles
+     * are f64 values carrying pointer bits; entry values are 64-bit slots
+     * (double bits, a bool, or a pointer to an immortal value) that the
+     * table neither retains nor releases. Lookups and inserts of array keys
+     * throw a TypeError for keys longer than a table accepts. */
+    private emitInternTableIntrinsic;
     /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
      * Created with the class graph; null elsewhere. */
     private regions;

package/dist/backend/llvm/emitter.js

@@ -46,9 +46,9 @@ import { InlineUnionFields, loadInlineUnion, presentBits, stackUnionBox, storeIn
 import { emitLocalArrayRead, emitProjectedArrayRead, emitBorrowedArrayRead, findLocalArrayReads, findCallArrayReads, OptionalArrayReads, } from "./local-array-reads.js";
 import { CheckedNarrows, emitCheckedNarrowReceiver } from "./checked-narrows.js";
 import { emitDenseArrayGet, emitDenseArraySet } from "./dense-array-access.js";
-import { emitStackMapRead, findMapReadLifetimes, matchMapRead, } from "./map-read-lifetimes.js";
+import { emitStackMapRead, findMapReadLifetimes, findReadNumberMapWrites, matchMapRead, } from "./map-read-lifetimes.js";
 import { emitBorrowedFieldSequence, guardedValue } from "./borrowed-receivers.js";
-import { borrowableInputs, emitBorrowedInput } from "./borrowed-inputs.js";
+import { borrowableInputs, emitBorrowedInput, emitBorrowedInputs } from "./borrowed-inputs.js";
 import { analyzeWalks, findWalkBorrows } from "./walk-borrows.js";
 import { findReboundParameters } from "./rebound-parameters.js";
 import { ReferenceEffects } from "./reference-effects.js";
@@ -61,7 +61,7 @@ import { AmbientReceiverReaders, findConstantCallbacks } from "./constant-callba
 import { findScalarStringSlices, emitStringSliceSnapshot, } from "./string-slices.js";
 import { LazyCaptures } from "./lazy-captures.js";
 import { StackCaptures } from "./stack-captures.js";
-import { ABSENT_FIELD_PAYLOAD, emitFieldAbsentTest, exactIndexLines, f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText, } from "./common.js";
+import { ABSENT_FIELD_PAYLOAD, emitFieldAbsentTest, exactIndexLines, f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText, sizeToDouble, } from "./common.js";
 import { ffiExtendsNarrowIntegers } from "../targets.js";
 import { emitLiteralExpr, emitOperatorExpr, emitStringExpr, emitContainerExpr, emitRecordExpr, } from "./expr-primitives.js";
 import { emitControlExpr } from "./expr-control.js";
@@ -85,7 +85,7 @@ import { emitNetworkHttpLibCall } from "./lib-network.js";
 import { emitAssertInspectLibCall, emitIoLibCall, emitGenericLibCall, emitLibCall, } from "./lib-dispatch.js";
 import { buildClassGraph, classMembershipIntervals, emitClassMembershipHelper, classEnvironmentIndex, classFieldIndex, classStructSym, programLifetimeClass, } from "./classes.js";
 import { LifetimeRegions, REGION_TYPES } from "./regions.js";
-import { LlDyn } from "./dyn.js";
+import { LlDyn, recordDynKeepsIdentity } from "./dyn.js";
 import { VirtualBorrows } from "./virtual-borrows.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { LlWalkers } from "./walkers.js";
@@ -354,6 +354,7 @@ export class LlEmitter {
     checkedNarrows;
     callArrayReads = new Map();
     mapReadLifetimes = { locals: new Map(), arguments: new Map() };
+    readNumberMapWrites = new Set();
     callLifetimes;
     constantCallbacks;
     currentConstantCallbacks = new Map();
@@ -737,6 +738,9 @@ export class LlEmitter {
         this.callLifetimes = analyzeCallLifetimes(this.fnByName, (className, field) => this.nullableFields.get(className, field) !== null, walkParameters, new Set([...this.int32Abis].filter(([, abi]) => abi.union).map(([name]) => name)), {
             record: (shapeId, field) => this.recordFieldInline(shapeId, field),
             classField: (className, field) => this.inlineUnions.classField(className, field),
+        }, (shapeId) => {
+            const shape = this.recordsById.get(shapeId);
+            return shape !== undefined && !recordDynKeepsIdentity(shape);
         });
         this.constantCallbacks = findConstantCallbacks(mod, this.callLifetimes);
         this.stackCallbacks = new StackCallbacks(this.fnByName);
@@ -1413,21 +1417,17 @@ export class LlEmitter {
             if (!asyncEntry)
                 return [];
             const lines = [];
+            // finish_top_level noted 13 unless the program set process.exitCode.
+            // A failed node:test run outranks either before exit listeners run.
             if (usesNodeTest) {
-                lines.push(`  %tla_program_exit = call i32 @scr_test_exit_code()`);
+                lines.push(`  %tla_program_exit = call i32 @scr_test_exit_code()`, `  %tla_program_exit_zero = icmp eq i32 %tla_program_exit, 0`, `  %tla_hint = call i32 @scr_exit_code_hint_get()`, `  %tla_exit_status = select i1 %tla_program_exit_zero, i32 %tla_hint, i32 %tla_program_exit`, `  call void @scr_exit_code_note(i32 %tla_exit_status)`);
             }
-            if (usesNodeTest) {
-                lines.push(`  %tla_program_exit_zero = icmp eq i32 %tla_program_exit, 0`, `  %tla_exit_status = select i1 %tla_program_exit_zero, i32 %tla_status, i32 %tla_program_exit`);
-            }
-            const exitStatus = usesNodeTest ? "%tla_exit_status" : "%tla_status";
-            // finish_top_level initially notes 13. Replace that hint before exit
-            // listeners run when a higher-priority verdict was already selected.
-            lines.push(`  call void @scr_exit_code_note(i32 ${exitStatus})`);
             for (const line of exitListenerLines("xp"))
                 lines.push(line);
             for (const line of topPendingReleases)
                 lines.push(line);
-            lines.push(`  ret i32 ${exitStatus}`);
+            // An exit listener may set process.exitCode again, as in Node.
+            lines.push(`  %tla_exit_code = call i32 @scr_exit_code_hint_get()`, `  ret i32 %tla_exit_code`);
             return lines;
         };
         // LIBRARY mode: the runtime entry points the generated library
@@ -2185,9 +2185,13 @@ export class LlEmitter {
         // Number-key Map/Set lookups probe the runtime's direct index inline:
         // while ndense is nonzero every live key is an integer below it, so an
         // in-range integral key reads its slot (entry index + 1, 0 = absent) and
-        // any other key is absent. Maps without the index (ndense 0) and every
-        // non-integral probe outside the table take the runtime lookup, which
-        // keeps the complete SameValueZero semantics.
+        // any other key is absent. Maps without the index (ndense 0) hash the
+        // key in sc_map_entry_f64_hashed, which scans the entries of a small map
+        // or probes a compact bucket table as scr_map_find_f64 does, and calls
+        // the runtime lookup for a wide table. It stays out of line so that the
+        // direct-index path stays small at every call site. Both only read
+        // memory, so LLVM merges lookups of one key when nothing is stored in
+        // between (a has() followed by get(), for example).
         if (this.decls.has(NUMBER_MAP_ENTRY_DECL)) {
             const sz = this.sizeType;
             let mapTmp = 0;
@@ -2196,7 +2200,15 @@ export class LlEmitter {
             // A non-integral key inside the table is as absent as one outside it.
             ...mapIndex.lines.map((line) => `  ${line}`), `  br i1 ${mapIndex.ok}, label %slot, label %outside`, `slot:`, sz === "i64"
                 ? `  %i = add i64 ${mapIndex.wide}, 0`
-                : `  %i = trunc i64 ${mapIndex.wide} to ${sz}`, `  %dp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 19`, `  %dense = load ptr, ptr %dp`, `  %sp = getelementptr inbounds i32, ptr %dense, ${sz} %i`, `  %s = load i32, ptr %sp`, `  %empty = icmp eq i32 %s, 0`, `  br i1 %empty, label %miss, label %hit`, `hit:`, `  %e32 = sub i32 %s, 1`, sz === "i32" ? `  %e = add i32 %e32, 0` : `  %e = zext i32 %e32 to ${sz}`, `  %ep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`, `  %entries = load ptr, ptr %ep`, `  %found = getelementptr inbounds %ScrMapEntry, ptr %entries, ${sz} %e`, `  ret ptr %found`, `miss:`, `  ret ptr null`, `outside:`, `  %dense.any = icmp ne ${sz} %nd, 0`, `  br i1 %dense.any, label %miss, label %slow`, `slow:`, `  %r = call ptr @scr_map_entry_f64(ptr %m, double %k)`, `  ret ptr %r`, `}`, ``);
+                : `  %i = trunc i64 ${mapIndex.wide} to ${sz}`, `  %dp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 19`, `  %dense = load ptr, ptr %dp`, `  %sp = getelementptr inbounds i32, ptr %dense, ${sz} %i`, `  %s = load i32, ptr %sp`, `  %empty = icmp eq i32 %s, 0`, `  br i1 %empty, label %miss, label %hit`, `hit:`, `  %e32 = sub i32 %s, 1`, sz === "i32" ? `  %e = add i32 %e32, 0` : `  %e = zext i32 %e32 to ${sz}`, `  %ep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`, `  %entries = load ptr, ptr %ep`, `  %found = getelementptr inbounds %ScrMapEntry, ptr %entries, ${sz} %e`, `  ret ptr %found`, `miss:`, `  ret ptr null`, `outside:`, `  %dense.any = icmp ne ${sz} %nd, 0`, `  br i1 %dense.any, label %miss, label %slow`, `slow:`, `  %hashed = call ptr @sc_map_entry_f64_hashed(ptr %m, double %k)`, `  ret ptr %hashed`, `}`, ``, 
+            // Hashing (scr_map_find_f64): the SameValueZero key word, its
+            // scr_key_mix hash (zero remapped to one) and the absent-key filter.
+            `define internal ptr @sc_map_entry_f64_hashed(ptr %m, double %k) noinline ${FN_ATTRS} {`, `entry:`, `  %nan = fcmp uno double %k, %k`, `  %zero = fcmp oeq double %k, 0.0`, `  %kz = select i1 %zero, double 0.0, double %k`, `  %kzb = bitcast double %kz to i64`, `  %kb = select i1 %nan, i64 9221120237041090560, i64 %kzb`, `  %x1s = lshr i64 %kb, 30`, `  %x1 = xor i64 %kb, %x1s`, `  %x2 = mul i64 %x1, -4658895280553007687`, `  %x3s = lshr i64 %x2, 27`, `  %x3 = xor i64 %x2, %x3s`, `  %x4 = mul i64 %x3, -7723592293110705685`, `  %x5s = lshr i64 %x4, 31`, `  %x5 = xor i64 %x4, %x5s`, `  %hz = icmp eq i64 %x5, 0`, `  %h = select i1 %hz, i64 1, i64 %x5`, `  %f1s = lshr i64 %h, 44`, `  %f1a = and i64 %f1s, 63`, `  %f1 = shl i64 1, %f1a`, `  %f2s = lshr i64 %h, 50`, `  %f2a = and i64 %f2s, 63`, `  %f2 = shl i64 1, %f2a`, `  %fb = or i64 %f1, %f2`, `  %fp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 11`, `  %filter = load i64, ptr %fp`, `  %fm = and i64 %filter, %fb`, `  %fin = icmp eq i64 %fm, %fb`, `  br i1 %fin, label %table, label %miss`, `table:`, `  %nbp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 14`, `  %nb = load ${sz}, ptr %nbp`, `  %eps = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 13`, `  %ents = load ptr, ptr %eps`, `  %linear = icmp eq ${sz} %nb, 0`, `  br i1 %linear, label %scan, label %buckets`, 
+            // Small maps keep no bucket table: scan the cached entry hashes.
+            `scan:`, `  %nep = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 9`, `  %ne = load ${sz}, ptr %nep`, `  br label %scan.loop`, `scan.loop:`, `  %si = phi ${sz} [ 0, %scan ], [ %si.next, %scan.next ]`, `  %sdone = icmp eq ${sz} %si, %ne`, `  br i1 %sdone, label %miss, label %scan.entry`, `scan.entry:`, `  %se = getelementptr inbounds %ScrMapEntry, ptr %ents, ${sz} %si`, `  %seh = getelementptr inbounds %ScrMapEntry, ptr %se, i32 0, i32 2`, `  %sh = load i64, ptr %seh`, `  %sk = load i64, ptr %se`, `  %shq = icmp eq i64 %sh, %h`, `  %skq = icmp eq i64 %sk, %kb`, `  %sq = and i1 %shq, %skq`, `  br i1 %sq, label %scan.found, label %scan.next`, `scan.found:`, `  ret ptr %se`, `scan.next:`, `  %si.next = add ${sz} %si, 1`, `  br label %scan.loop`, 
+            // Compact tables tag each 24-bit entry index (+1) with the hash's
+            // top byte; wider tables take the runtime lookup.
+            `buckets:`, `  %wide = icmp ugt ${sz} %nb, 16777216`, `  br i1 %wide, label %runtime, label %probe`, `probe:`, `  %bp = getelementptr inbounds %ScrMapIx, ptr %m, i32 0, i32 15`, `  %bk = load ptr, ptr %bp`, `  %mask = sub ${sz} %nb, 1`, `  %ht = lshr i64 %h, 32`, `  %ht32 = trunc i64 %ht to i32`, `  %tag = and i32 %ht32, -16777216`, sz === "i64" ? `  %hi = add i64 %h, 0` : `  %hi = trunc i64 %h to ${sz}`, `  %i0 = and ${sz} %hi, %mask`, `  br label %probe.loop`, `probe.loop:`, `  %pi = phi ${sz} [ %i0, %probe ], [ %pi.next, %probe.next ]`, `  %bep = getelementptr inbounds i32, ptr %bk, ${sz} %pi`, `  %b = load i32, ptr %bep`, `  %bempty = icmp eq i32 %b, 0`, `  br i1 %bempty, label %miss, label %probe.tag`, `probe.tag:`, `  %bt = and i32 %b, -16777216`, `  %btq = icmp eq i32 %bt, %tag`, `  br i1 %btq, label %probe.entry, label %probe.next`, `probe.entry:`, `  %bix = and i32 %b, 16777215`, `  %bix1 = sub i32 %bix, 1`, sz === "i32" ? `  %bi = add i32 %bix1, 0` : `  %bi = zext i32 %bix1 to ${sz}`, `  %pe = getelementptr inbounds %ScrMapEntry, ptr %ents, ${sz} %bi`, `  %peh = getelementptr inbounds %ScrMapEntry, ptr %pe, i32 0, i32 2`, `  %ph = load i64, ptr %peh`, `  %pk = load i64, ptr %pe`, `  %phq = icmp eq i64 %ph, %h`, `  %pkq = icmp eq i64 %pk, %kb`, `  %pq = and i1 %phq, %pkq`, `  br i1 %pq, label %probe.found, label %probe.next`, `probe.found:`, `  ret ptr %pe`, `probe.next:`, `  %pi.inc = add ${sz} %pi, 1`, `  %pi.next = and ${sz} %pi.inc, %mask`, `  br label %probe.loop`, `miss:`, `  ret ptr null`, `runtime:`, `  %r = call ptr @scr_map_entry_f64(ptr %m, double %k) memory(read) nounwind willreturn`, `  ret ptr %r`, `}`, ``);
         }
         // Map/Set iteration steps read the entries array inline: an index is
         // live when it is below the entry count and its entry's cached hash is
@@ -3604,6 +3616,11 @@ export class LlEmitter {
         this.B.line(`store i32 0, ptr ${slot}`);
         return slot;
     }
+    /** The amortized cancellation poll, emitted on the loop's back edge (the
+     * continue target), after the body. A poll in the header would be a loop
+     * exit ahead of the body; LLVM then cannot rotate the loop, so loads that
+     * the body repeats on every iteration (a typed array's length, for one)
+     * stay in the loop. */
     emitWorkerLoopCheck(slot) {
         if (slot === null)
             return;
@@ -4571,6 +4588,7 @@ export class LlEmitter {
         this.scalarStringSlices =
             this.debug === null ? findScalarStringSlices(fn, this.callLifetimes) : new Map();
         this.mapReadLifetimes = findMapReadLifetimes(fn, this.boxedUnionsById, this.callLifetimes);
+        this.readNumberMapWrites = findReadNumberMapWrites(fn);
         this.localStackUnions = findLocalStackUnions(fn, this.callLifetimes, this.boxedUnionsById);
         this.localStackObjects = this.stackObjects
             ? findLocalStackObjects(this, fn, this.callLifetimes)
@@ -5796,7 +5814,7 @@ export class LlEmitter {
                 B.line(`${lenPtr} = getelementptr inbounds %ScrArr, ptr ${arr.name}, i32 0, i32 1`);
                 this.markMemoryPointer(lenPtr, "array:header");
                 B.line(`${len} = load ${this.sizeType}, ptr ${lenPtr}${this.fieldAliasAttachment(lenPtr)}`);
-                B.line(`${lenNumber} = sitofp ${this.sizeType} ${len} to double`);
+                B.line(`${lenNumber} = ${sizeToDouble(this.sizeType)} ${this.sizeType} ${len} to double`);
                 B.line(`${same} = fcmp oeq double ${length.name}, ${lenNumber}`);
                 B.condBr(same, done, resize);
                 B.startBlock(resize);
@@ -6088,15 +6106,15 @@ export class LlEmitter {
                 const lc = B.newLabel("loop.c");
                 const lb = B.newLabel("loop.b");
                 const le = B.newLabel("loop.e");
+                const lp = workerBudget !== null ? B.newLabel("loop.p") : lc;
                 B.br(lc);
                 B.startBlock(lc);
-                this.emitWorkerLoopCheck(workerBudget);
                 B.condBr(this.emitCondition(s.cond), lb, le);
                 B.startBlock(lb);
                 this.jumpTargets.push({
                     kind: "loop",
                     brkLabel: le,
-                    contLabel: lc,
+                    contLabel: lp,
                     labels: s.labels,
                     frameDepth: this.frames.length,
                     scopeDepth: this.scopes.length,
@@ -6104,7 +6122,12 @@ export class LlEmitter {
                 });
                 this.emitBlock(s.body);
                 this.jumpTargets.pop();
-                B.br(lc);
+                B.br(lp);
+                if (lp !== lc) {
+                    B.startBlock(lp);
+                    this.emitWorkerLoopCheck(workerBudget);
+                    B.br(lc);
+                }
                 B.startBlock(le);
                 break;
             }
@@ -6116,7 +6139,6 @@ export class LlEmitter {
                 const le = B.newLabel("loop.e");
                 B.br(lb);
                 B.startBlock(lb);
-                this.emitWorkerLoopCheck(workerBudget);
                 this.jumpTargets.push({
                     kind: "loop",
                     brkLabel: le,
@@ -6130,6 +6152,7 @@ export class LlEmitter {
                 this.jumpTargets.pop();
                 B.br(lc);
                 B.startBlock(lc);
+                this.emitWorkerLoopCheck(workerBudget);
                 B.condBr(this.emitCondition(s.cond), lb, le);
                 B.startBlock(le);
                 break;
@@ -6289,12 +6312,11 @@ export class LlEmitter {
                         B.line(`store ptr ${fresh}, ptr ${slot}`);
                     }
                 };
-                const lu = s.update || capturedLets.length > 0 ? B.newLabel("loop.u") : lc;
-                freshenBindings();
                 const workerBudget = this.workerLoopBudget(s);
+                const lu = s.update || capturedLets.length > 0 || workerBudget !== null ? B.newLabel("loop.u") : lc;
+                freshenBindings();
                 B.br(lc);
                 B.startBlock(lc);
-                this.emitWorkerLoopCheck(workerBudget);
                 if (integerLoop && integerSlot) {
                     const receiver = this.emitStableReceiver(integerLoop.limitReceiver, []);
                     const lenPtr = B.tmp();
@@ -6335,6 +6357,7 @@ export class LlEmitter {
                 B.br(lu);
                 if (lu !== lc) {
                     B.startBlock(lu);
+                    this.emitWorkerLoopCheck(workerBudget);
                     freshenBindings();
                     if (integerLoop && integerSlot) {
                         const old = B.tmp();
@@ -6402,7 +6425,6 @@ export class LlEmitter {
                 const workerBudget = this.workerLoopBudget(s);
                 B.br(lc);
                 B.startBlock(lc);
-                this.emitWorkerLoopCheck(workerBudget);
                 const inBounds = B.tmp();
                 let cur;
                 if (snapshot && cursor && scratch) {
@@ -6418,7 +6440,7 @@ export class LlEmitter {
                     B.line(`${lenPtr} = getelementptr inbounds %ScrArr, ptr ${arr.name}, i32 0, i32 1`);
                     this.markMemoryPointer(lenPtr, "array:header");
                     B.line(`${rawLen} = load ${this.sizeType}, ptr ${lenPtr}${this.fieldAliasAttachment(lenPtr)}`);
-                    B.line(`${len} = sitofp ${this.sizeType} ${rawLen} to double`);
+                    B.line(`${len} = ${sizeToDouble(this.sizeType)} ${this.sizeType} ${rawLen} to double`);
                     B.line(`${inBounds} = fcmp olt double ${i}, ${len}`);
                     cur = i;
                 }
@@ -6476,6 +6498,7 @@ export class LlEmitter {
                 this.jumpTargets.pop();
                 B.br(lu);
                 B.startBlock(lu);
+                this.emitWorkerLoopCheck(workerBudget);
                 if (idxSlot) {
                     const i2 = B.tmp(), i3 = B.tmp();
                     B.line(`${i2} = load double, ptr ${idxSlot}`);
@@ -7192,8 +7215,122 @@ export class LlEmitter {
             e.name === "region.leave" ||
             e.name === "region.release")
             return this.emitRegionIntrinsic(e);
+        if (e.name.startsWith("itable."))
+            return this.emitInternTableIntrinsic(e);
         return emitIntrinsicExpr(this, e);
     }
+    /** InternTable's runtime calls (scr_itable.c). Table and entry handles
+     * are f64 values carrying pointer bits; entry values are 64-bit slots
+     * (double bits, a bool, or a pointer to an immortal value) that the
+     * table neither retains nor releases. Lookups and inserts of array keys
+     * throw a TypeError for keys longer than a table accepts. */
+    emitInternTableIntrinsic(e) {
+        const B = this.B;
+        // The runtime copies keys and stores published values without counts,
+        // so every operand is borrowed.
+        const args = emitBorrowedInputs(this, e.args);
+        if (B.isTerminated())
+            return { name: "", type: e.type };
+        const toPtr = (handle) => {
+            const bits = B.tmp(), ptr = B.tmp();
+            B.line(`${bits} = bitcast double ${handle} to i64`);
+            B.line(`${ptr} = inttoptr i64 ${bits} to ptr`);
+            return ptr;
+        };
+        const toHandle = (ptr) => {
+            const bits = B.tmp(), handle = B.tmp();
+            B.line(`${bits} = ptrtoint ptr ${ptr} to i64`);
+            B.line(`${handle} = bitcast i64 ${bits} to double`);
+            return { name: handle, type: e.type };
+        };
+        const keyCall = (op) => {
+            const kind = e.args[1].type.kind;
+            const key = kind === "string" ? "str" : kind === "array" ? "arr" : "f64";
+            const keyTy = key === "f64" ? "double" : "ptr";
+            const value = op === "insert" ? ", i64" : "";
+            this.declare(`declare ptr @scr_itable_${op}_${key}(ptr, ${keyTy}${value})`);
+            return `@scr_itable_${op}_${key}(ptr ${toPtr(args[0].name)}, ${keyTy} ${args[1].name}`;
+        };
+        switch (e.name) {
+            case "itable.open": {
+                this.declare(`declare ptr @scr_itable_open(ptr, i32)`);
+                const kind = B.tmp(), table = B.tmp();
+                B.line(`${kind} = fptosi double ${args[1].name} to i32`);
+                B.line(`${table} = call ptr @scr_itable_open(ptr ${args[0].name}, i32 ${kind})`);
+                return toHandle(table);
+            }
+            case "itable.find": {
+                const call = keyCall("find");
+                const entry = B.tmp();
+                B.line(`${entry} = call ptr ${call})`);
+                // Array keys longer than a table accepts throw a TypeError.
+                if (e.args[1].type.kind === "array")
+                    this.emitPendingCheck();
+                return toHandle(entry);
+            }
+            case "itable.insert": {
+                const value = args[2];
+                const ty = this.llType(value.type);
+                let slot = value.name;
+                if (ty === "double") {
+                    slot = B.tmp();
+                    B.line(`${slot} = bitcast double ${value.name} to i64`);
+                }
+                else if (ty === "i1") {
+                    slot = B.tmp();
+                    B.line(`${slot} = zext i1 ${value.name} to i64`);
+                }
+                else if (ty === "ptr") {
+                    slot = B.tmp();
+                    B.line(`${slot} = ptrtoint ptr ${value.name} to i64`);
+                }
+                else
+                    throw new InternalCompilerError(`llvm emitter bug: itable value of type ${ty}`);
+                const call = keyCall("insert");
+                const entry = B.tmp();
+                B.line(`${entry} = call ptr ${call}, i64 ${slot})`);
+                if (e.args[1].type.kind === "array")
+                    this.emitPendingCheck();
+                return toHandle(entry);
+            }
+            case "itable.value": {
+                // The handle's bits reach the address through memory: at -O0, x86
+                // FastISel folds inttoptr(bitcast double) into the load's address
+                // without moving the value out of its XMM register. Optimized
+                // builds turn the stack round trip back into one register move.
+                const carrier = B.slot();
+                B.entryAllocas.push(`${carrier} = alloca double`);
+                B.line(`store double ${args[0].name}, ptr ${carrier}`);
+                const bits = B.tmp(), entry = B.tmp();
+                B.line(`${bits} = load i64, ptr ${carrier}`);
+                B.line(`${entry} = inttoptr i64 ${bits} to ptr`);
+                const slot = B.tmp();
+                B.line(`${slot} = load i64, ptr ${entry}, align 8`);
+                const ty = this.llType(e.type);
+                const result = B.tmp();
+                if (ty === "double")
+                    B.line(`${result} = bitcast i64 ${slot} to double`);
+                else if (ty === "i1")
+                    B.line(`${result} = trunc i64 ${slot} to i1`);
+                else if (ty === "ptr")
+                    B.line(`${result} = inttoptr i64 ${slot} to ptr`);
+                else
+                    throw new InternalCompilerError(`llvm emitter bug: itable value of type ${ty}`);
+                // Stored values are immortal: owning one adds no count.
+                return isRefCounted(e.type)
+                    ? this.own({ name: result, type: e.type })
+                    : { name: result, type: e.type };
+            }
+            case "itable.size": {
+                this.declare(`declare double @scr_itable_size(ptr)`);
+                const size = B.tmp();
+                B.line(`${size} = call double @scr_itable_size(ptr ${toPtr(args[0].name)})`);
+                return { name: size, type: e.type };
+            }
+            default:
+                throw new InternalCompilerError(`llvm emitter bug: unknown intrinsic ${e.name}`);
+        }
+    }
     /** Lifetime regions in modules with lifetimeRegions (llvm/regions.ts).
      * Created with the class graph; null elsewhere. */
     regions = null;