@scriptc/compiler 0.0.22 → 0.0.23

package/dist/backend/llvm/emitter.js

@@ -129,13 +129,36 @@ const LIB_FN_SYMS = {
     "process.stderrWrite": "scr_process_stderr_write",
     "process.isTTY": "scr_process_is_tty",
     "date.now": "scr_date_now",
+    "date.newNow": "scr_date_now",
+    "date.newMs": "scr_date_new_ms",
+    "date.newString": "scr_date_parse_get_time",
+    "date.getTime": "scr_date_get_time",
+    "date.valueOf": "scr_date_get_time",
     "date.parseGetTime": "scr_date_parse_get_time",
     "date.utc": "scr_date_utc",
+    "date.getFullYear": "scr_date_get_full_year_local",
+    "date.getUTCFullYear": "scr_date_get_full_year_utc",
+    "date.getMonth": "scr_date_get_month_local",
+    "date.getUTCMonth": "scr_date_get_month_utc",
+    "date.getDate": "scr_date_get_date_local",
+    "date.getUTCDate": "scr_date_get_date_utc",
+    "date.getDay": "scr_date_get_day_local",
+    "date.getUTCDay": "scr_date_get_day_utc",
+    "date.getHours": "scr_date_get_hours_local",
+    "date.getUTCHours": "scr_date_get_hours_utc",
+    "date.getMinutes": "scr_date_get_minutes_local",
+    "date.getUTCMinutes": "scr_date_get_minutes_utc",
+    "date.getSeconds": "scr_date_get_seconds_local",
+    "date.getUTCSeconds": "scr_date_get_seconds_utc",
+    "date.getMilliseconds": "scr_date_get_milliseconds",
+    "date.getUTCMilliseconds": "scr_date_get_milliseconds",
+    "date.getTimezoneOffset": "scr_date_get_timezone_offset",
     "fs.existsSync": "scr_fs_exists",
     // ── the throwing slice (MAY_THROW_LIB_FNS members): the generic path
     // emits the standard pending check after each — emit-exprs.ts's finish.
     "process.cpuPrevValidate": "scr_cpu_prev_validate",
     "date.toISOString": "scr_date_to_iso",
+    "date.toISOStringValue": "scr_date_to_iso",
     "process.chdir": "scr_process_chdir",
     "fs.writeFileSync": "scr_fs_write_file",
     "fs.appendFileSync": "scr_fs_append_file",
@@ -352,9 +375,11 @@ const LIB_FN_SYMS = {
     // the generic path emits the standard pending check). typeof and the
     // ambient-this read never throw. The fs dyn read is the sync-fs story.
     "fetch.start": "scr_fetch_static",
+    "fetch.responseNew": "scr_fetch_response_new",
     "fetch.responseJson": "scr_fetch_response_json",
     "fetch.responseText": "scr_fetch_response_text",
     "fetch.responseBytes": "scr_fetch_response_bytes",
+    "fetch.abortControllerNew": "scr_fetch_abort_controller_new",
     "fetch.abortTimeout": "scr_fetch_abort_timeout",
     "fetch.abortNow": "scr_fetch_abort_now",
     "fetch.abortAny": "scr_fetch_abort_any",
@@ -940,6 +965,7 @@ class LlEmitter {
     llType(t) {
         switch (t.kind) {
             case "f64":
+            case "date":
                 return "double";
             case "bool":
                 return "i1";
@@ -1192,6 +1218,11 @@ class LlEmitter {
             // scr_runtime.h's natural alignment: kind at 8, f64 at 16, b at 24,
             // payload at 32).
             `%ScrCaught = type { i64, i32, double, i8, ptr, ptr, ptr, ptr }`,
+            // ScrBytes { rc, len, elem(i32+pad), data, backing }. Indexed
+            // typed-array access GEPs through this directly: the IR type already
+            // fixes elem, so the hot path needs neither a runtime kind load nor
+            // the generic scr_bytes_get/set call.
+            `%ScrBytes = type { i64, i64, i32, ptr, ptr }`,
             // The capture box { rc, kind, obj_retain, obj_release, obj_trace,
             // slot } — TDZ reads peek the payload slot (offset 40) directly.
             `%ScrBox = type { i64, i32, ptr, ptr, ptr, i64 }`,
@@ -1696,6 +1727,7 @@ class LlEmitter {
                     tr.push(`  call void @scr_promise_fulfill_void(ptr %pr)`);
                     break;
                 case "f64":
+                case "date":
                     this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
                     tr.push(`  call void @scr_promise_fulfill_f64(ptr %pr, double %r)`);
                     break;
@@ -1851,6 +1883,7 @@ class LlEmitter {
                     tr.push(`  br label %done ; void body: the done value is undefined (NONE)`);
                     break;
                 case "f64":
+                case "date":
                     this.declare(`declare void @scr_gen_out_f64(ptr, double)`);
                     tr.push(`  call void @scr_gen_out_f64(ptr %g, double %r)`, `  br label %done`);
                     break;
@@ -2072,7 +2105,7 @@ class LlEmitter {
         const t = this.currentReturnType;
         if (t.kind === "void")
             this.B.terminate("ret void");
-        else if (t.kind === "f64")
+        else if (t.kind === "f64" || t.kind === "date")
             this.B.terminate(`ret double ${f64Lit(0)}`);
         else if (t.kind === "bool")
             this.B.terminate("ret i1 false");
@@ -2104,7 +2137,10 @@ class LlEmitter {
     emitThrowValue(v) {
         const B = this.B;
         const t = v.type;
-        if (t.kind === "f64") {
+        if (t.kind === "date") {
+            throw new Error("LLVM emitter bug: Date throw reached backend");
+        }
+        else if (t.kind === "f64") {
             this.declare(`declare void @scr_throw_f64(double)`);
             B.line(`call void @scr_throw_f64(double ${v.name})`);
         }
@@ -2153,6 +2189,8 @@ class LlEmitter {
                 B.line(`${t} = icmp ne i64 ${len}, 0`);
                 return t;
             }
+            case "date":
+                return "true";
             case "array":
             case "record":
             case "object":
@@ -2247,6 +2285,9 @@ class LlEmitter {
                             B.line(`store i1 ${t}, ptr ${slot}`);
                             break;
                         }
+                        case "date":
+                            B.line(`store i1 true, ptr ${slot} ; Date objects are truthy`);
+                            break;
                         case "array":
                         case "record":
                         case "object":
@@ -2791,13 +2832,16 @@ class LlEmitter {
             }
             case "bytesSet": {
                 // Typed-array element write: same evaluation order as arraySet;
-                // the value is a scalar (the runtime coerces JS-exactly), so no
-                // ownership moves. Any invalid index traps — no append.
-                const arr = this.emitExpr(s.arr);
+                // the value is a scalar (the kind-specific inline path coerces
+                // 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 idx = this.emitExpr(s.index);
                 const v = this.emitExpr(s.value);
-                this.declare(`declare void @scr_bytes_set(ptr, double, double)`);
-                B.line(`call void @scr_bytes_set(ptr ${arr.name}, double ${idx.name}, double ${v.name})`);
+                if (s.arr.type.kind !== "bytes")
+                    throw new Error("llvm emitter bug: bytesSet on non-bytes");
+                this.emitBytesSet(s.arr.type.elem, arr.name, idx.name, v.name);
                 break;
             }
             case "fieldSet":
@@ -5280,7 +5324,7 @@ class LlEmitter {
                     throw new Error("llvm emitter bug: yieldExpr with no operand (frontend fills undefined)");
                 const v = this.emitExpr(e.value);
                 const yt = e.value.type;
-                if (yt.kind === "f64") {
+                if (yt.kind === "f64" || yt.kind === "date") {
                     this.declare(`declare void @scr_gen_yield_f64(double)`);
                     B.line(`call void @scr_gen_yield_f64(double ${v.name})`);
                 }
@@ -5300,7 +5344,7 @@ class LlEmitter {
                     return { name: "", type: e.type };
                 }
                 const t = B.tmp();
-                if (e.type.kind === "f64") {
+                if (e.type.kind === "f64" || e.type.kind === "date") {
                     this.declare(`declare double @scr_gen_take_in_f64()`);
                     B.line(`${t} = call double @scr_gen_take_in_f64()`);
                     return { name: t, type: e.type };
@@ -5332,7 +5376,7 @@ class LlEmitter {
                     store(a.name, e.arg.type);
                 };
                 const parkIn = (name, t) => {
-                    if (t.kind === "f64") {
+                    if (t.kind === "f64" || t.kind === "date") {
                         this.declare(`declare void @scr_gen_in_f64(ptr, double)`);
                         B.line(`call void @scr_gen_in_f64(ptr ${g.name}, double ${name})`);
                     }
@@ -5378,7 +5422,7 @@ class LlEmitter {
                     }
                     else {
                         sendArg((name, t) => {
-                            if (t.kind === "f64") {
+                            if (t.kind === "f64" || t.kind === "date") {
                                 this.declare(`declare void @scr_gen_ret_f64(ptr, double)`);
                                 B.line(`call void @scr_gen_ret_f64(ptr ${g.name}, double ${name})`);
                             }
@@ -5431,7 +5475,7 @@ class LlEmitter {
                     return { name: "", type: e.type };
                 }
                 const t = B.tmp();
-                if (e.type.kind === "f64") {
+                if (e.type.kind === "f64" || e.type.kind === "date") {
                     this.declare(`declare double @scr_await_f64(ptr)`);
                     B.line(`${t} = call double @scr_await_f64(ptr ${pr.name})`);
                 }
@@ -5511,7 +5555,7 @@ class LlEmitter {
                 B.startBlock(lp);
                 const peek = this.unionPeek(u.name);
                 let awaited;
-                if (inner.kind === "f64") {
+                if (inner.kind === "f64" || inner.kind === "date") {
                     this.declare(`declare double @scr_await_f64(ptr)`);
                     const x = B.tmp();
                     B.line(`${x} = call double @scr_await_f64(ptr ${peek})`);
@@ -5588,7 +5632,7 @@ class LlEmitter {
                     return out;
                 }
                 let resolve;
-                const kindNums = { f64: 0, bool: 1, string: 2, void: 3 };
+                const kindNums = { f64: 0, date: 0, bool: 1, string: 2, void: 3 };
                 const kindNum = kindNums[inner.kind];
                 if (kindNum !== undefined) {
                     this.declare(`declare ptr @scr_make_resolve(ptr, i32)`);
@@ -5634,7 +5678,7 @@ class LlEmitter {
                 this.declare(`declare ptr @scr_make_reject(ptr)`);
                 const p = B.tmp();
                 B.line(`${p} = call ptr @scr_promise_new()`);
-                const kindNums = { f64: 0, bool: 1, string: 2, void: 3 };
+                const kindNums = { f64: 0, date: 0, bool: 1, string: 2, void: 3 };
                 const kindNum = kindNums[inner.kind];
                 const resolve = B.tmp();
                 if (kindNum !== undefined) {
@@ -5749,7 +5793,7 @@ class LlEmitter {
                     }
                     const v = this.emitExpr(e.args[0]);
                     const t = e.args[0].type;
-                    if (t.kind === "f64") {
+                    if (t.kind === "f64" || t.kind === "date") {
                         this.declare(`declare void @scr_promise_fulfill_f64(ptr, double)`);
                         B.line(`call void @scr_promise_fulfill_f64(ptr ${p}, double ${v.name})`);
                     }
@@ -8625,6 +8669,233 @@ class LlEmitter {
             }
         }
     }
+    /** Whether an index/value expression can overwrite the bytes receiver
+     * binding. Kept deliberately conservative; uncertain or calling shapes
+     * retain the ordinary owned-receiver snapshot. */
+    isStableBytesOperand(e, receiverLocalId) {
+        switch (e.kind) {
+            case "numLit":
+            case "boolLit":
+            case "varRef":
+            case "incDec":
+                return true;
+            case "assignExpr":
+                // A bytes assignment nested under truthiness/ternary can still
+                // produce the numeric index/value expected by the outer access.
+                return (e.localId !== receiverLocalId &&
+                    this.isStableBytesOperand(e.value, receiverLocalId));
+            case "bin":
+                return (this.isStableBytesOperand(e.left, receiverLocalId) &&
+                    this.isStableBytesOperand(e.right, receiverLocalId));
+            case "unary":
+            case "toBool":
+                return this.isStableBytesOperand(e.operand, receiverLocalId);
+            case "logical":
+                return (this.isStableBytesOperand(e.left, receiverLocalId) &&
+                    this.isStableBytesOperand(e.right, receiverLocalId));
+            case "ternary":
+                return (this.isStableBytesOperand(e.cond, receiverLocalId) &&
+                    this.isStableBytesOperand(e.then, receiverLocalId) &&
+                    this.isStableBytesOperand(e.else_, receiverLocalId));
+            case "bytesIntrinsic":
+                return ((e.method === "get" || e.method === "length" || e.method === "byteLength") &&
+                    e.receiver.kind === "varRef" &&
+                    e.args.every((arg) => this.isStableBytesOperand(arg, receiverLocalId)));
+            default:
+                return false;
+        }
+    }
+    /** Borrow a direct, unboxed bytes binding when later operands are stable.
+     * Its scope/global owner keeps it alive through the access. */
+    emitBytesReceiver(receiver, following) {
+        if (receiver.kind === "varRef" &&
+            following.every((operand) => this.isStableBytesOperand(operand, receiver.localId))) {
+            const b = this.binding(receiver.localId);
+            if (b.kind !== "boxed") {
+                const value = this.B.tmp();
+                this.B.line(`${value} = load ptr, ptr ${b.slot}`);
+                return { name: value, type: receiver.type };
+            }
+        }
+        return this.emitExpr(receiver);
+    }
+    /** Bounds-check a typed-array element index without an out-of-line call
+     * on the valid path. The range test rejects NaN/infinity before fptoui;
+     * the integer round trip then rejects fractions. The error block retains
+     * the runtime's exact trap text. Leaves the builder in the valid block. */
+    emitBytesIndex(receiver, index) {
+        const B = this.B;
+        const lenPtr = B.tmp();
+        const len = B.tmp();
+        const lenF64 = B.tmp();
+        const nonnegative = B.tmp();
+        const belowLen = B.tmp();
+        const inRange = B.tmp();
+        B.line(`${lenPtr} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
+        B.line(`${len} = load i64, ptr ${lenPtr}`);
+        B.line(`${lenF64} = uitofp i64 ${len} to double`);
+        B.line(`${nonnegative} = fcmp oge double ${index}, ${f64Lit(0)}`);
+        B.line(`${belowLen} = fcmp olt double ${index}, ${lenF64}`);
+        B.line(`${inRange} = and i1 ${nonnegative}, ${belowLen}`);
+        const rangeOk = B.newLabel("bytes.index.range");
+        const invalid = B.newLabel("bytes.index.invalid");
+        const valid = B.newLabel("bytes.index.valid");
+        B.condBr(inRange, rangeOk, invalid);
+        B.startBlock(rangeOk);
+        const idx = B.tmp();
+        const roundTrip = B.tmp();
+        const integral = B.tmp();
+        B.line(`${idx} = fptoui double ${index} to i64`);
+        B.line(`${roundTrip} = uitofp i64 ${idx} to double`);
+        B.line(`${integral} = fcmp oeq double ${roundTrip}, ${index}`);
+        B.condBr(integral, valid, invalid);
+        B.startBlock(invalid);
+        this.declare(`declare double @scr_bytes_get(ptr, double)`);
+        B.line(`call double @scr_bytes_get(ptr ${receiver}, double ${index})`);
+        B.terminate("unreachable");
+        B.startBlock(valid);
+        return idx;
+    }
+    /** Load the raw data pointer from ScrBytes after the bounds check. */
+    emitBytesData(receiver) {
+        const p = this.B.tmp();
+        const data = this.B.tmp();
+        this.B.line(`${p} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 3`);
+        this.B.line(`${data} = load ptr, ptr ${p}`);
+        return data;
+    }
+    /** Static typed-array length/byteLength load. */
+    emitBytesLength(elem, receiver, bytes) {
+        const B = this.B;
+        const p = B.tmp();
+        const len = B.tmp();
+        B.line(`${p} = getelementptr inbounds %ScrBytes, ptr ${receiver}, i64 0, i32 1`);
+        B.line(`${len} = load i64, ptr ${p}`);
+        const count = bytes && elem !== "u8" ? B.tmp() : len;
+        if (count !== len)
+            B.line(`${count} = shl i64 ${len}, 2`);
+        const out = B.tmp();
+        B.line(`${out} = uitofp i64 ${count} to double`);
+        return { name: out, type: F64 };
+    }
+    /** Kind-specialized typed-array load. */
+    emitBytesGet(elem, receiver, index) {
+        const B = this.B;
+        const idx = this.emitBytesIndex(receiver, index);
+        const data = this.emitBytesData(receiver);
+        const p = B.tmp();
+        if (elem === "u8") {
+            const raw = B.tmp();
+            const wide = B.tmp();
+            const out = B.tmp();
+            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, i64 ${idx}`);
+            B.line(`${raw} = load i8, ptr ${p}, align 1`);
+            B.line(`${wide} = zext i8 ${raw} to i32`);
+            B.line(`${out} = uitofp i32 ${wide} to double`);
+            return { name: out, type: F64 };
+        }
+        if (elem === "f32") {
+            const raw = B.tmp();
+            const out = B.tmp();
+            B.line(`${p} = getelementptr inbounds float, ptr ${data}, i64 ${idx}`);
+            B.line(`${raw} = load float, ptr ${p}, align 1`);
+            B.line(`${out} = fpext float ${raw} to double`);
+            return { name: out, type: F64 };
+        }
+        const raw = B.tmp();
+        const out = B.tmp();
+        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, i64 ${idx}`);
+        B.line(`${raw} = load i32, ptr ${p}, align 1`);
+        B.line(`${out} = ${elem === "i32" ? "sitofp" : "uitofp"} i32 ${raw} to double`);
+        return { name: out, type: F64 };
+    }
+    /** ToUint32/ToInt32 coercion with the overwhelmingly common finite,
+     * exactly-representable JS-number range on a cast-only path. Exceptional
+     * and huge values remain inline in the program TU so unrelated runtime
+     * binaries do not acquire another exported helper. */
+    emitBytesU32(value) {
+        const B = this.B;
+        const aboveMin = B.tmp();
+        const belowMax = B.tmp();
+        const fast = B.tmp();
+        B.line(`${aboveMin} = fcmp oge double ${value}, ${f64Lit(-9007199254740992)}`);
+        B.line(`${belowMax} = fcmp ole double ${value}, ${f64Lit(9007199254740992)}`);
+        B.line(`${fast} = and i1 ${aboveMin}, ${belowMax}`);
+        const fastLabel = B.newLabel("bytes.coerce.fast");
+        const slowLabel = B.newLabel("bytes.coerce.slow");
+        const done = B.newLabel("bytes.coerce.done");
+        B.condBr(fast, fastLabel, slowLabel);
+        B.startBlock(fastLabel);
+        const signed = B.tmp();
+        const fastU32 = B.tmp();
+        B.line(`${signed} = fptosi double ${value} to i64`);
+        B.line(`${fastU32} = trunc i64 ${signed} to i32`);
+        B.br(done);
+        B.startBlock(slowLabel);
+        const ordered = B.tmp();
+        const belowInf = B.tmp();
+        const aboveNegInf = B.tmp();
+        const finiteRange = B.tmp();
+        const finite = B.tmp();
+        B.line(`${ordered} = fcmp ord double ${value}, ${value}`);
+        B.line(`${belowInf} = fcmp olt double ${value}, ${F64_INF}`);
+        B.line(`${aboveNegInf} = fcmp ogt double ${value}, ${f64Lit(-Infinity)}`);
+        B.line(`${finiteRange} = and i1 ${belowInf}, ${aboveNegInf}`);
+        B.line(`${finite} = and i1 ${ordered}, ${finiteRange}`);
+        const finiteLabel = B.newLabel("bytes.coerce.finite");
+        const nonfiniteLabel = B.newLabel("bytes.coerce.nonfinite");
+        const slowDone = B.newLabel("bytes.coerce.slow.done");
+        B.condBr(finite, finiteLabel, nonfiniteLabel);
+        B.startBlock(finiteLabel);
+        this.declare(`declare double @llvm.trunc.f64(double)`);
+        const truncated = B.tmp();
+        const residue = B.tmp();
+        const negative = B.tmp();
+        const wrapped = B.tmp();
+        const normalized = B.tmp();
+        const finiteU32 = B.tmp();
+        B.line(`${truncated} = call double @llvm.trunc.f64(double ${value})`);
+        B.line(`${residue} = frem double ${truncated}, ${f64Lit(4294967296)}`);
+        B.line(`${negative} = fcmp olt double ${residue}, ${f64Lit(0)}`);
+        B.line(`${wrapped} = fadd double ${residue}, ${f64Lit(4294967296)}`);
+        B.line(`${normalized} = select i1 ${negative}, double ${wrapped}, double ${residue}`);
+        B.line(`${finiteU32} = fptoui double ${normalized} to i32`);
+        B.br(slowDone);
+        B.startBlock(nonfiniteLabel);
+        B.br(slowDone);
+        B.startBlock(slowDone);
+        const slowU32 = B.tmp();
+        B.line(`${slowU32} = phi i32 [ ${finiteU32}, %${finiteLabel} ], [ 0, %${nonfiniteLabel} ]`);
+        B.br(done);
+        B.startBlock(done);
+        const out = B.tmp();
+        B.line(`${out} = phi i32 [ ${fastU32}, %${fastLabel} ], [ ${slowU32}, %${slowDone} ]`);
+        return out;
+    }
+    /** Kind-specialized typed-array store. */
+    emitBytesSet(elem, receiver, index, value) {
+        const B = this.B;
+        const idx = this.emitBytesIndex(receiver, index);
+        const stored = elem === "f32" ? null : this.emitBytesU32(value);
+        const data = this.emitBytesData(receiver);
+        const p = B.tmp();
+        if (elem === "u8") {
+            const byte = B.tmp();
+            B.line(`${byte} = trunc i32 ${stored} to i8`);
+            B.line(`${p} = getelementptr inbounds i8, ptr ${data}, i64 ${idx}`);
+            B.line(`store i8 ${byte}, ptr ${p}, align 1`);
+            return;
+        }
+        if (elem === "f32") {
+            const narrowed = B.tmp();
+            B.line(`${narrowed} = fptrunc double ${value} to float`);
+            B.line(`${p} = getelementptr inbounds float, ptr ${data}, i64 ${idx}`);
+            B.line(`store float ${narrowed}, ptr ${p}, align 1`);
+            return;
+        }
+        B.line(`${p} = getelementptr inbounds i32, ptr ${data}, i64 ${idx}`);
+        B.line(`store i32 ${stored}, ptr ${p}, align 1`);
+    }
     /** The bytesIntrinsic surface (emit-exprs.ts's switch, .ll flavored).
      * Receiver and args are borrowed frame temps; string/bytes results come
      * back +1. The MAY_THROW methods get the standard pending check after
@@ -8672,18 +8943,30 @@ class LlEmitter {
                 ? call("scr_bytes_read_var", "double (ptr, double, double, i1 zeroext, i1 zeroext)", `ptr ${r0.name}, double ${rest[0].name}, double ${rest[1].name}, i1 ${spec.sign}, i1 ${spec.le}`, false, true)
                 : call("scr_bytes_write_var", "double (ptr, double, double, double, i1 zeroext, i1 zeroext)", `ptr ${r0.name}, double ${rest[0].name}, double ${rest[1].name}, double ${rest[2].name}, i1 ${spec.sign}, i1 ${spec.le}`, false, true);
         }
-        const r = this.emitExpr(e.receiver);
-        const args = e.args.map((a) => this.emitExpr(a));
         const method = e.method;
+        const directElementAccess = method === "length" || method === "byteLength" || method === "get";
+        const r = directElementAccess
+            ? this.emitBytesReceiver(e.receiver, e.args)
+            : this.emitExpr(e.receiver);
+        const args = e.args.map((a) => this.emitExpr(a));
         const NAN = f64Lit(NaN);
         switch (method) {
             case "length":
-                return call("scr_bytes_len", "double (ptr)", `ptr ${r.name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic length on non-bytes");
+                }
+                return this.emitBytesLength(e.receiver.type.elem, r.name, false);
             case "byteLength":
-                return call("scr_bytes_byte_len", "double (ptr)", `ptr ${r.name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic byteLength on non-bytes");
+                }
+                return this.emitBytesLength(e.receiver.type.elem, r.name, true);
             case "get":
                 // Any invalid index traps (the array runtime's discipline).
-                return call("scr_bytes_get", "double (ptr, double)", `ptr ${r.name}, double ${args[0].name}`, false, false);
+                if (e.receiver.type.kind !== "bytes") {
+                    throw new Error("llvm emitter bug: bytesIntrinsic get on non-bytes");
+                }
+                return this.emitBytesGet(e.receiver.type.elem, r.name, args[0].name);
             case "slice":
                 return call("scr_bytes_slice", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0]?.name ?? f64Lit(0)}, double ${args[1]?.name ?? F64_INF}`, true, false);
             case "subarray":