@scriptc/compiler 0.1.4 → 0.1.6

package/dist/backend/llvm/emitter.js

@@ -66,6 +66,9 @@ import { endsWithJump, matchStringSelfConcat, streamTypedRefEligible } from "../
 import { emitLibraryIdentityLines } from "../library-identity-markers.js";
 import { CAUGHT, ffiCallbackType, isDynTypedRefType, isFfiContextParam, isRefCounted, isUnitType, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, moduleUsesChildProcess, moduleUsesDynInvoke, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttpServer, moduleUsesNet, moduleUsesNodeTest, moduleUsesProcessEvents, moduleUsesStream, moduleUsesTls, moduleUsesTlsCa, NPM_COMPRESS_MIN, POINTER_KINDS, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, typeKey, VOID } from "../../ir/ir.js";
 import { matchIntegerBytesForLoop } from "../../ir/integer-loops.js";
+import { scalarizeNumericRecords } from "../../ir/scalar-records.js";
+import { analyzeIntegerRanges } from "../../ir/integer-ranges.js";
+import { findConstantNumericTables } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback } from "../ffi-callbacks.js";
 import { RUNTIME_ABI_MARKER } from "../runtime-abi.js";
 import { computeMayThrow } from "../c/may-throw.js";
@@ -81,8 +84,8 @@ import { emitJsInteropExpr, emitExpr } from "./expr-dispatch.js";
 import { emitJsMarshal, emitJsOp, emitJsExit, islandAdapter, islandTypedAdapter } from "./expr-island.js";
 import { dynKind, raceAdapterFor, genResultThunkFor, childExitThunkFor, childExitSignalThunkFor, childDataThunkFor, execFileThunkFor, ipcMessageThunkFor, ipcSendThunkFor, emitterFixedAdapter, wrapEmitterListener, unwrapNullableClosure, closeBindThunkFor, closeOverrideWrapFor } from "./expr-callbacks.js";
 import { streamDataAdapter, streamDoneFnFor, cryptoBytesThunkFor, fsRenameThunkFor, streamCbThunkFor, zlibBytesThunkFor } from "./expr-stream-callbacks.js";
-import { resolveThunkFor, tagInSet, arrPush, emitArrayCopyLoop, emitStrIntrinsic, emitArrIntrinsic, wrapNullable, emitMapNew, mapSet, emitMapLikeIntrinsic, emitSetNew } from "./expr-containers.js";
-import { emitBytesReceiver, emitIntegerLoopIndex, emitBytesIndex, emitBytesData, emitBytesLength, emitBytesGet, emitToUint32, emitBytesSet, emitBytesIntrinsic } from "./expr-bytes.js";
+import { emitStableReceiver, resolveThunkFor, tagInSet, arrPush, emitArrayCopyLoop, emitStrIntrinsic, emitArrIntrinsic, wrapNullable, emitMapNew, mapSet, emitMapLikeIntrinsic, emitSetNew } from "./expr-containers.js";
+import { emitIntegerLoopIndex, emitBytesIndex, emitBytesData, emitBytesLength, emitBytesGet, emitToUint32, emitBytesSet, emitBytesIntrinsic } from "./expr-bytes.js";
 import { emitRegexIntrinsic, emitRecordKeyGet, keyedRecordReadInto } from "./expr-records.js";
 import { dynPromiseAdapter, streamTypedRefCommitAdapter, liveDynUnionRefAdapter, streamTypedRefBoxValue, streamTypedRefMaterializeAdapter, streamFromArrayAdapter } from "./expr-stream-bridges.js";
 import { emitWebLibCall, emitDynamicLibCall, emitFilesystemLibCall, emitPathUrlLibCall, emitPrimitiveLibCall } from "./lib-filesystem.js";
@@ -111,7 +114,7 @@ function ffiCallbackDummyLl(callback) {
     }
 }
 export function emitLlvmModule(mod, options = {}) {
-    return new LlEmitter(mod, options).emit();
+    return new LlEmitter(scalarizeNumericRecords(mod), options).emit();
 }
 /** LLVM c"..." payload for a UTF-8 literal, NUL-terminated like the C
  * emitter's flexible-array-member initializer. */
@@ -185,6 +188,7 @@ class LlEmitter {
     ffiHasRetainedCallback;
     ffiHasForeignCallback;
     globalTypes = new Map();
+    constantNumericTables;
     /** May-throw analysis (the C emitter's computeMayThrow, shared): pending
      * checks are emitted only after calls that can actually raise. */
     mayThrow;
@@ -249,6 +253,7 @@ class LlEmitter {
     captureIds = new Set();
     /** Active canonical byte-loop induction bindings: local id → size_t slot. */
     integerLoopBindings = new Map();
+    integerRanges = new Map();
     /** Enclosing try-with-FINALLY regions, innermost last: a `return`
      * inside one runs every crossed finally (innermost first) before the
      * actual ret — the C emitter's pending-return path, with the finally
@@ -280,6 +285,7 @@ class LlEmitter {
     logArgSlots = 0;
     constructor(mod, options) {
         this.mod = mod;
+        this.constantNumericTables = findConstantNumericTables(mod);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
         this.wasi = options.wasi === true;
         this.emitLibraryIdentity = options.emitLibraryIdentity !== false;
@@ -890,6 +896,8 @@ class LlEmitter {
         // Helpers assemble BEFORE the declaration table flushes (they add
         // write/abort declarations).
         const helpers = this.helperDefs();
+        if (this.constantNumericTables.size > 0)
+            this.declare(`declare double @scr_arr_get_number(ptr, double)`);
         const out = [
             `; Generated by scriptc (LLVM backend) from ${this.mod.sourceFile}. Do not edit.`,
             ``,
@@ -959,6 +967,13 @@ class LlEmitter {
         for (const d of this.decls)
             out.push(d);
         out.push(``);
+        for (const table of this.constantNumericTables.values()) {
+            const n = table.values.length;
+            out.push(`@${table.symbol} = private constant [${n} x double] [${table.values.map((v) => `double ${f64Lit(v)}`).join(", ")}]`, `define internal double @${table.symbol}_get(ptr %a, double %i) alwaysinline #0 {`, `entry:`, `  %initialized = icmp ne ptr %a, null`, `  %nonnegative = fcmp oge double %i, ${f64Lit(0)}`, `  %below = fcmp olt double %i, ${f64Lit(n)}`, `  %range = and i1 %nonnegative, %below`, `  %safe = and i1 %initialized, %range`, `  br i1 %safe, label %convert, label %fallback`, `convert:`, 
+            // The branch must dominate fptoui: NaN/out-of-range conversion
+            // would produce poison. Fractional indices also need a fallback.
+            `  %index = fptoui double %i to ${this.sizeType}`, `  %roundtrip = uitofp ${this.sizeType} %index to double`, `  %integer = fcmp oeq double %roundtrip, %i`, `  br i1 %integer, label %read, label %fallback`, `read:`, `  %slot = getelementptr inbounds [${n} x double], ptr @${table.symbol}, ${this.sizeType} 0, ${this.sizeType} %index`, `  %value = load double, ptr %slot`, `  ret double %value`, `fallback:`, `  %generic = call double @scr_arr_get_number(ptr %a, double %i)`, `  ret double %generic`, `}`, ``);
+        }
         for (const [text, lit] of this.literals) {
             // Immortal interned ScrStr: { rc = SIZE_MAX, len, cap = len, bytes\0 } —
             // the C emitter's static table, retain/release skip rc == SIZE_MAX.
@@ -2532,6 +2547,7 @@ class LlEmitter {
         this.currentLocals = new Map(fn.locals.map((l) => [l.id, l]));
         this.captureIds = new Set((fn.captures ?? []).map((c) => c.localId));
         this.integerLoopBindings.clear();
+        this.integerRanges = analyzeIntegerRanges(fn);
         this.chainSlots.clear();
         this.finallyStack = [];
         this.tryStack = [];
@@ -2841,7 +2857,7 @@ class LlEmitter {
                 // JS-exactly), so no ownership moves. Any invalid index traps — no
                 // append. IrBytesElem is static, so never rediscover it through the
                 // generic runtime switch in a hot loop.
-                const arr = this.emitBytesReceiver(s.arr, [s.index, s.value]);
+                const arr = this.emitStableReceiver(s.arr, [s.index, s.value]);
                 const integerIndex = this.emitIntegerLoopIndex(s.index);
                 const idx = integerIndex ?? this.emitExpr(s.index).name;
                 const v = this.emitExpr(s.value);
@@ -3133,7 +3149,7 @@ class LlEmitter {
                 B.br(lc);
                 B.startBlock(lc);
                 if (integerLoop && integerSlot) {
-                    const receiver = this.emitBytesReceiver(integerLoop.limitReceiver, []);
+                    const receiver = this.emitStableReceiver(integerLoop.limitReceiver, []);
                     const lenPtr = B.tmp();
                     const len = B.tmp();
                     const index = B.tmp();
@@ -3875,8 +3891,8 @@ class LlEmitter {
     emitSetNew(e) {
         return emitSetNew(this.expressionContext(), e);
     }
-    emitBytesReceiver(receiver, following) {
-        return emitBytesReceiver(this.expressionContext(), receiver, following);
+    emitStableReceiver(receiver, following) {
+        return emitStableReceiver(this.expressionContext(), receiver, following);
     }
     emitIntegerLoopIndex(expr) {
         return emitIntegerLoopIndex(this.expressionContext(), expr);
@@ -3893,8 +3909,8 @@ class LlEmitter {
     emitBytesGet(elem, receiver, index, integerIndex = false) {
         return emitBytesGet(this.expressionContext(), elem, receiver, index, integerIndex);
     }
-    emitToUint32(value) {
-        return emitToUint32(this.expressionContext(), value);
+    emitToUint32(value, expr) {
+        return emitToUint32(this.expressionContext(), value, expr);
     }
     emitBytesSet(elem, receiver, index, value, integerIndex = false) {
         return emitBytesSet(this.expressionContext(), elem, receiver, index, value, integerIndex);