@scriptc/compiler 0.1.5 → 0.1.7

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

@@ -1,6 +1,8 @@
 import type { IrModule } from "../../ir/ir.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 export interface LlvmTargetOptions {
+    /** Exact frontend sources for dev-build locations and variable metadata. */
+    debugSources?: ReadonlyMap<string, string>;
     /** Pointer width of the target C ABI. Native targets are 64-bit today. */
     pointerBits?: 32 | 64;
     /** Select the WASI libc entry-point convention. */

package/dist/backend/llvm/emitter.js

@@ -74,6 +74,7 @@ import { RUNTIME_ABI_MARKER } from "../runtime-abi.js";
 import { computeMayThrow } from "../c/may-throw.js";
 import { mangleArgPack, mangleAsyncSpawn, mangleClassObj, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
+import { LlvmDebugInfo } from "./debug-info.js";
 import { f64Lit, ffiNativeTypeLl, llvmCommentText } from "./common.js";
 import { emitLiteralExpr, emitOperatorExpr, emitStringExpr, emitContainerExpr, emitRecordExpr } from "./expr-primitives.js";
 import { emitControlExpr } from "./expr-control.js";
@@ -114,7 +115,8 @@ function ffiCallbackDummyLl(callback) {
     }
 }
 export function emitLlvmModule(mod, options = {}) {
-    return new LlEmitter(scalarizeNumericRecords(mod), options).emit();
+    // Keep source storage intact for debugger inspection in dev builds.
+    return new LlEmitter(options.debugSources === undefined ? scalarizeNumericRecords(mod) : mod, options).emit();
 }
 /** LLVM c"..." payload for a UTF-8 literal, NUL-terminated like the C
  * emitter's flexible-array-member initializer. */
@@ -133,6 +135,8 @@ function llStrBytes(text) {
 }
 class LlEmitter {
     mod;
+    debug;
+    debugScope = null;
     sizeType;
     cycleColorOffset;
     wasi;
@@ -285,6 +289,7 @@ class LlEmitter {
     logArgSlots = 0;
     constructor(mod, options) {
         this.mod = mod;
+        this.debug = options.debugSources === undefined ? null : new LlvmDebugInfo(mod.sourceFile, options.debugSources, options.pointerBits, mod.unions);
         this.constantNumericTables = findConstantNumericTables(mod);
         this.sizeType = options.pointerBits === 32 ? "i32" : "i64";
         this.wasi = options.wasi === true;
@@ -1060,7 +1065,8 @@ class LlEmitter {
         for (const g of globals) {
             const ty = this.llType(g.type);
             const zero = ty === "double" ? f64Lit(0) : ty === "ptr" ? "null" : "false";
-            out.push(`@${mangleGlobal(g.id)} = internal ${tl}global ${ty} ${zero} ; ${g.name}`);
+            const debug = this.debug?.global(g);
+            out.push(`@${mangleGlobal(g.id)} = internal ${tl}global ${ty} ${zero}${debug ? `, !dbg ${debug}` : ""} ; ${g.name}`);
         }
         if (globals.length > 0)
             out.push(``);
@@ -1128,6 +1134,8 @@ class LlEmitter {
             if (hasNoInlineRecordClone)
                 out.push(`attributes #2 = { noinline sanitize_address }`);
             out.push(``);
+            if (this.debug !== null)
+                out.push(this.debug.render());
             return out.join("\n");
         }
         out.push(`define i32 @${this.wasi ? "__main_argc_argv" : "main"}(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, ...(this.runtimeAbiMarker ? [`  call void @${RUNTIME_ABI_MARKER}()`] : []), `  call void @scr_init()`, ...stamps, 
@@ -1230,6 +1238,8 @@ class LlEmitter {
         // lane's -fsanitize=address link activates instrumentation over the
         // emitted functions too (the runtime TUs get theirs from clang).
         `attributes #0 = { sanitize_address }`, ...(this.wasi ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ...(hasNoInlineRecordClone ? [`attributes #2 = { noinline sanitize_address }`] : []), ``);
+        if (this.debug !== null)
+            out.push(this.debug.render());
         return out.join("\n");
     }
     /** LIBRARY mode: the profile-declared external definitions — the
@@ -2015,6 +2025,20 @@ class LlEmitter {
             this.declare(`declare void @scr_throw_obj(ptr, ptr, ptr, ptr)`);
             B.line(`call void @scr_throw_obj(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, t)})`);
         }
+        else if (t.kind === "symbol" || t.kind === "bigint" || t.kind === "func" || t.kind === "classval") {
+            const rc = vAdapters(this, t);
+            this.declare(`declare void @scr_throw_primitive_ref(ptr, ptr, ptr, ptr)`);
+            B.line(`call void @scr_throw_primitive_ref(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr null)`);
+        }
+        else if (t.kind === "dyn" || t.kind === "jsval") {
+            const rc = vAdapters(this, t);
+            const test = t.kind === "dyn" ? "scr_dyn_is_object" : "scr_jsval_is_object";
+            this.declare(`declare zeroext i1 @${test}(ptr)`);
+            this.declare(`declare void @scr_throw_ref_classified(ptr, ptr, ptr, ptr, i1 zeroext)`);
+            const object = B.tmp();
+            B.line(`${object} = call zeroext i1 @${test}(ptr ${v.name})`);
+            B.line(`call void @scr_throw_ref_classified(ptr ${v.name}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(this, t)}, i1 zeroext ${object})`);
+        }
         else {
             const rc = vAdapters(this, t);
             this.declare(`declare void @scr_throw_ref(ptr, ptr, ptr, ptr)`);
@@ -2341,6 +2365,13 @@ class LlEmitter {
             throw new InternalCompilerError(`llvm emitter bug: unknown binding ${id}`);
         return { kind: "global", slot: `@${mangleGlobal(id)}`, type: g };
     }
+    emitDebugLocal(local, slot, arg = 0, captured = false) {
+        const debug = this.debug?.local(local, this.debugScope, arg, captured);
+        if (!debug)
+            return;
+        this.declare("declare void @llvm.dbg.declare(metadata, metadata, metadata)");
+        this.B.entryAllocas.push(`call void @llvm.dbg.declare(metadata ptr ${slot}, metadata ${debug.variable}, metadata ${debug.expression}), !dbg ${debug.location}`);
+    }
     /** Loads a boxed binding's box pointer out of its slot. */
     loadBox(slot) {
         const b = this.B.tmp();
@@ -2541,6 +2572,8 @@ class LlEmitter {
     emitFunction(fn) {
         const B = new BlockBuilder();
         this.B = B;
+        this.debugScope = this.debug?.function(fn) ?? null;
+        B.debugLocation = this.debug?.location(fn.loc, this.debugScope) ?? null;
         this.frames = [];
         this.scopes = [];
         this.jumpTargets = [];
@@ -2598,6 +2631,7 @@ class LlEmitter {
                 ? "ptr"
                 : this.llType(local.type);
             B.entryAllocas.push(`%${mangleLocal(local.id)} = alloca ${slotTy} ; ${local.name}`);
+            this.emitDebugLocal(local, `%${mangleLocal(local.id)}`, fn.params.findIndex((p) => p.localId === local.id) + 1, this.captureIds.has(local.id));
             // Refcounted/boxed locals start NULL (the C prologue's `= NULL`):
             // scope-exit releases run whether or not an assign ever did.
             if (paramIds.has(local.id) || this.captureIds.has(local.id))
@@ -2697,7 +2731,8 @@ class LlEmitter {
             params.unshift("ptr %sc_env");
         const ret = this.llType(fn.returnType);
         const attrs = coro !== null ? "#1" : FN_ATTRS;
-        return `define internal ${ret} @${mangleFunction(fn.name)}(${params.join(", ")}) ${attrs} { ; ${fn.name}\n${B.render()}\n}`;
+        const debug = this.debugScope === null ? "" : ` !dbg ${this.debugScope}`;
+        return `define internal ${ret} @${mangleFunction(fn.name)}(${params.join(", ")}) ${attrs}${debug} { ; ${fn.name}\n${B.render()}\n}`;
     }
     // ── statements ──────────────────────────────────────────────────────────
     emitStmts(stmts) {
@@ -2726,6 +2761,16 @@ class LlEmitter {
             this.releaseScope(scope);
     }
     emitStmt(s) {
+        const previous = this.B.debugLocation;
+        this.B.debugLocation = this.debug?.location(s.loc, this.debugScope) ?? null;
+        try {
+            this.emitStmtBody(s);
+        }
+        finally {
+            this.B.debugLocation = previous;
+        }
+    }
+    emitStmtBody(s) {
         const B = this.B;
         this.frames.push([]);
         switch (s.kind) {
@@ -3123,7 +3168,7 @@ class LlEmitter {
             case "for": {
                 // The init's scope wraps the whole loop (break/continue must NOT
                 // release it — scopeDepth captured after the push, C parity).
-                const integerLoop = matchIntegerBytesForLoop(s, this.currentLocals);
+                const integerLoop = this.debug === null ? matchIntegerBytesForLoop(s, this.currentLocals) : null;
                 this.scopes.push([]);
                 let integerSlot = null;
                 if (integerLoop) {