wasm-idle 0.2.5 → 0.3.1

package/dist/clang/app.d.ts

@@ -1,10 +1,46 @@
+import type { DebugFrame, DebugVariable, DebugVariableMetadata } from '../playground/options';
 import { Memory, type MemFS } from './memory';
+interface DebugSession {
+    buffer?: Int32Array;
+    interruptBuffer?: Uint8Array;
+    breakpoints: Set<number>;
+    pauseOnEntry: boolean;
+    stepArmed: boolean;
+    nextLineArmed: boolean;
+    stepOutArmed: boolean;
+    callDepth: number;
+    stepOutDepth: number;
+    currentFunctionId: number;
+    currentLine: number;
+    resumeSkipActive: boolean;
+    resumeSkipFunctionId: number;
+    resumeSkipLine: number;
+    nextLineFunctionId: number;
+    nextLineLine: number;
+    variableMetadata: Record<number, DebugVariableMetadata[]>;
+    functionMetadata: Record<number, string>;
+    frames: Array<{
+        functionId: number;
+        functionName: string;
+        line: number;
+        values: Map<number, string>;
+    }>;
+    onPause?: (event: {
+        type: 'pause';
+        line: number;
+        reason: string;
+        locals: DebugVariable[];
+        callStack: DebugFrame[];
+    }) => void;
+}
 export default class App {
     ready: Promise<void>;
     mem: Memory;
     memfs: MemFS;
     instance: WebAssembly.Instance;
     exports: any;
+    trace: (message: string) => void;
+    debugSession?: DebugSession;
     argv: string[];
     environ: {
         [key: string]: string;
@@ -14,6 +50,13 @@ export default class App {
     constructor(module: WebAssembly.Module, memfs: MemFS, name: string, ...args: string[]);
     run(): Promise<boolean | undefined>;
     proc_exit(code: number): void;
+    __wasm_idle_debug_enter(functionId: number): number;
+    __wasm_idle_debug_leave(functionId: number): number;
+    __wasm_idle_debug_value_num(functionId: number, slot: number, value: number): number;
+    __wasm_idle_debug_value_bool(functionId: number, slot: number, value: number): number;
+    __wasm_idle_debug_value_addr(functionId: number, slot: number, value: number): number;
+    __wasm_idle_debug_value_text(functionId: number, slot: number, ptr: number, len: number): number;
+    __wasm_idle_debug_line(functionId: number, line: number): number;
     environ_sizes_get(environ_count_out: number, environ_buf_size_out: number): number;
     environ_get(environ_ptrs: number, environ_buf: number): number;
     args_sizes_get(argc_out: number, argv_buf_size_out: number): number;
@@ -22,3 +65,4 @@ export default class App {
     clock_time_get(): void;
     poll_oneoff(): void;
 }
+export {};

package/dist/clang/app.js

@@ -1,7 +1,7 @@
 import { bindNew } from './apply';
 import { Memory } from './memory';
 import { getInstance } from './wasm';
-import { NotImplemented, ProcExit } from './error';
+import { AbortError, NotImplemented, ProcExit } from './error';
 const ESUCCESS = 0;
 const RAF_PROC_EXIT_CODE = 0xc0c0a;
 export default class App {
@@ -10,6 +10,8 @@ export default class App {
     memfs;
     instance = null;
     exports;
+    trace = () => { };
+    debugSession;
     argv;
     environ;
     handles = new Map();
@@ -18,7 +20,7 @@ export default class App {
         this.argv = [name, ...args];
         this.environ = { USER: 'jungol' };
         this.memfs = memfs;
-        const env = bindNew(this);
+        const env = bindNew(this, '__wasm_idle_debug_enter', '__wasm_idle_debug_leave', '__wasm_idle_debug_line', '__wasm_idle_debug_value_num', '__wasm_idle_debug_value_bool', '__wasm_idle_debug_value_addr', '__wasm_idle_debug_value_text');
         const wasi_unstable = {
             ...bindNew(this, 'proc_exit', 'environ_sizes_get', 'environ_get', 'args_sizes_get', 'args_get', 'random_get', 'clock_time_get', 'poll_oneoff'),
             ...this.memfs.exports
@@ -32,12 +34,14 @@ export default class App {
     }
     async run() {
         await this.ready;
+        this.trace(`start(argv=${JSON.stringify(this.argv)}, exports=${JSON.stringify(Object.keys(this.exports || {}))})`);
         try {
             this.exports._start();
         }
         catch (exn) {
             let writeStack = true;
             if (exn instanceof ProcExit) {
+                this.trace(`proc_exit(code=${exn.code})`);
                 if (exn.code === RAF_PROC_EXIT_CODE) {
                     console.log('Allowing rAF after exit.');
                     return true;
@@ -48,6 +52,8 @@ export default class App {
                     return false;
                 writeStack = false;
             }
+            if (exn instanceof NotImplemented)
+                this.trace(`not_implemented(${exn.message})`);
             // Write error message.
             let msg = `\x1b[91mError: ${exn.message}`;
             if (writeStack)
@@ -57,10 +63,272 @@ export default class App {
             // Propagate error.
             throw exn;
         }
+        this.trace('start() returned without proc_exit');
     }
     proc_exit(code) {
         throw new ProcExit(code);
     }
+    __wasm_idle_debug_enter(functionId) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        session.callDepth += 1;
+        session.currentFunctionId = functionId;
+        session.frames.push({
+            functionId,
+            functionName: session.functionMetadata[functionId] || `fn_${functionId}`,
+            line: 0,
+            values: new Map()
+        });
+        this.trace(`enter(function=${functionId}, depth=${session.callDepth})`);
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_leave(functionId) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        this.trace(`leave(function=${functionId}, depth=${session.callDepth})`);
+        session.callDepth = Math.max(0, session.callDepth - 1);
+        if (session.currentFunctionId === functionId)
+            session.currentFunctionId = 0;
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            if (session.frames[index]?.functionId === functionId) {
+                session.frames.splice(index, 1);
+                break;
+            }
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_num(functionId, slot, value) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            const frame = session.frames[index];
+            if (frame?.functionId !== functionId)
+                continue;
+            frame.values.set(slot, Number.isInteger(value) ? String(value) : `${value}`);
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_bool(functionId, slot, value) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            const frame = session.frames[index];
+            if (frame?.functionId !== functionId)
+                continue;
+            frame.values.set(slot, value ? 'true' : 'false');
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_addr(functionId, slot, value) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            const frame = session.frames[index];
+            if (frame?.functionId !== functionId)
+                continue;
+            frame.values.set(slot, String(value >>> 0));
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_text(functionId, slot, ptr, len) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        this.mem?.check?.();
+        const text = this.mem?.readStr ? this.mem.readStr(ptr, len) : '?';
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            const frame = session.frames[index];
+            if (frame?.functionId !== functionId)
+                continue;
+            frame.values.set(slot, text);
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_line(functionId, line) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        if (session.resumeSkipActive) {
+            if (functionId === session.resumeSkipFunctionId && line === session.resumeSkipLine) {
+                return ESUCCESS;
+            }
+            session.resumeSkipActive = false;
+            session.resumeSkipFunctionId = 0;
+            session.resumeSkipLine = 0;
+        }
+        let reason = '';
+        if (session.pauseOnEntry)
+            reason = 'entry';
+        else if (session.breakpoints.has(line))
+            reason = 'breakpoint';
+        else if (session.stepArmed)
+            reason = 'step';
+        else if (session.nextLineArmed &&
+            functionId === session.nextLineFunctionId &&
+            line !== session.nextLineLine) {
+            reason = 'nextLine';
+        }
+        else if (session.stepOutArmed && session.callDepth <= session.stepOutDepth) {
+            reason = 'stepOut';
+        }
+        if (!reason)
+            return ESUCCESS;
+        session.currentFunctionId = functionId;
+        session.currentLine = line;
+        const frame = [...session.frames].reverse().find((candidate) => candidate.functionId === functionId);
+        if (frame)
+            frame.line = line;
+        session.pauseOnEntry = false;
+        session.stepArmed = false;
+        session.nextLineArmed = false;
+        session.stepOutArmed = false;
+        this.trace(`pause(function=${functionId}, line=${line}, reason=${reason})`);
+        const locals = session.variableMetadata[functionId]?.flatMap((variable) => {
+            if (line < variable.fromLine || line > variable.toLine)
+                return [];
+            if (variable.kind === 'array') {
+                this.mem?.check?.();
+                const address = Number(frame?.values.get(variable.slot) ?? Number.NaN);
+                const dimensions = variable.dimensions?.length
+                    ? variable.dimensions
+                    : variable.length
+                        ? [variable.length]
+                        : [];
+                if (!Number.isFinite(address) || address <= 0 || !dimensions.length || !variable.elementKind) {
+                    return [{ name: variable.name, value: '?' }];
+                }
+                const elementStride = variable.elementKind === 'double'
+                    ? 8
+                    : variable.elementKind === 'bool' || variable.elementKind === 'char'
+                        ? 1
+                        : 4;
+                if (dimensions.length === 2) {
+                    const previewRows = Math.min(dimensions[0], 4);
+                    const previewCols = Math.min(dimensions[1], 8);
+                    const rows = [];
+                    for (let row = 0; row < previewRows; row += 1) {
+                        const values = [];
+                        for (let col = 0; col < previewCols; col += 1) {
+                            const offset = address + (row * dimensions[1] + col) * elementStride;
+                            if (variable.elementKind === 'bool') {
+                                values.push(this.mem.read8(offset) ? 'true' : 'false');
+                                continue;
+                            }
+                            if (variable.elementKind === 'char') {
+                                const charCode = this.mem.read8(offset);
+                                values.push(charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`);
+                                continue;
+                            }
+                            if (variable.elementKind === 'float') {
+                                values.push(`${this.mem.readFloat32(offset)}`);
+                                continue;
+                            }
+                            if (variable.elementKind === 'double') {
+                                values.push(`${this.mem.readFloat64(offset)}`);
+                                continue;
+                            }
+                            values.push(`${this.mem.readInt32(offset)}`);
+                        }
+                        rows.push(`[${values.join(', ')}${dimensions[1] > previewCols ? ', ...' : ''}]`);
+                    }
+                    return [
+                        {
+                            name: variable.name,
+                            value: `[${rows.join(', ')}${dimensions[0] > previewRows ? ', ...' : ''}]`
+                        }
+                    ];
+                }
+                const previewLength = Math.min(dimensions[0], 8);
+                const values = [];
+                for (let index = 0; index < previewLength; index += 1) {
+                    const offset = address + index * elementStride;
+                    if (variable.elementKind === 'bool') {
+                        values.push(this.mem.read8(offset) ? 'true' : 'false');
+                        continue;
+                    }
+                    if (variable.elementKind === 'char') {
+                        const charCode = this.mem.read8(offset);
+                        values.push(charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`);
+                        continue;
+                    }
+                    if (variable.elementKind === 'float') {
+                        values.push(`${this.mem.readFloat32(offset)}`);
+                        continue;
+                    }
+                    if (variable.elementKind === 'double') {
+                        values.push(`${this.mem.readFloat64(offset)}`);
+                        continue;
+                    }
+                    values.push(`${this.mem.readInt32(offset)}`);
+                }
+                return [
+                    {
+                        name: variable.name,
+                        value: `[${values.join(', ')}${dimensions[0] > previewLength ? ', ...' : ''}]`
+                    }
+                ];
+            }
+            const value = frame?.values.get(variable.slot) ?? '?';
+            return [{ name: variable.name, value }];
+        }) || [];
+        session.onPause?.({
+            type: 'pause',
+            line,
+            reason,
+            locals,
+            callStack: [...session.frames]
+                .reverse()
+                .map((stackFrame) => ({ functionName: stackFrame.functionName, line: stackFrame.line }))
+        });
+        const sequence = Atomics.load(session.buffer, 0);
+        while (true) {
+            if (session.interruptBuffer?.[0] === 2)
+                throw new AbortError();
+            Atomics.wait(session.buffer, 0, sequence, 100);
+            if (session.interruptBuffer?.[0] === 2)
+                throw new AbortError();
+            const command = Atomics.exchange(session.buffer, 1, 0);
+            if (command === 1) {
+                session.resumeSkipActive = true;
+                session.resumeSkipFunctionId = session.currentFunctionId;
+                session.resumeSkipLine = session.currentLine;
+                return ESUCCESS;
+            }
+            if (command === 2) {
+                session.stepArmed = true;
+                session.resumeSkipActive = true;
+                session.resumeSkipFunctionId = session.currentFunctionId;
+                session.resumeSkipLine = session.currentLine;
+                return ESUCCESS;
+            }
+            if (command === 3) {
+                session.nextLineArmed = true;
+                session.nextLineFunctionId = session.currentFunctionId;
+                session.nextLineLine = session.currentLine;
+                session.resumeSkipActive = true;
+                session.resumeSkipFunctionId = session.currentFunctionId;
+                session.resumeSkipLine = session.currentLine;
+                return ESUCCESS;
+            }
+            if (command === 4) {
+                session.stepOutArmed = true;
+                session.stepOutDepth = Math.max(0, session.callDepth - 1);
+                session.resumeSkipActive = true;
+                session.resumeSkipFunctionId = session.currentFunctionId;
+                session.resumeSkipLine = session.currentLine;
+                return ESUCCESS;
+            }
+        }
+    }
     environ_sizes_get(environ_count_out, environ_buf_size_out) {
         this.mem.check();
         let size = 0;

package/dist/clang/index.d.ts

@@ -1,3 +1,4 @@
+import type { DebugVariable, DebugVariableMetadata } from '../playground/options';
 import App from './app';
 import { MemFS } from './memory';
 import { type Writable } from 'svelte/store';
@@ -5,10 +6,24 @@ interface APIOption {
     stdin: () => string;
     stdout: (str: string) => void;
     progress: (value: number) => void;
+    onDebugEvent?: (event: {
+        type: 'pause';
+        line: number;
+        reason: string;
+        locals: DebugVariable[];
+    }) => void;
     log?: boolean;
     showTiming?: boolean;
     path: string;
 }
+interface DebugRunOptions {
+    args?: string[];
+    debug?: boolean;
+    breakpoints?: number[];
+    pauseOnEntry?: boolean;
+    debugBuffer?: Int32Array;
+    interruptBuffer?: Uint8Array;
+}
 export default class Clang {
     ready: Promise<void>;
     memfs: MemFS;
@@ -18,9 +33,27 @@ export default class Clang {
     };
     showTiming: boolean;
     log: boolean;
-    lastCode: string;
+    debug: boolean;
+    debugBreakpoints: Set<number>;
+    debugPauseOnEntry: boolean;
+    debugBuffer?: Int32Array;
+    debugInterruptBuffer?: Uint8Array;
+    onDebugEvent?: (event: {
+        type: 'pause';
+        line: number;
+        reason: string;
+        locals: DebugVariable[];
+        callStack: {
+            functionName: string;
+            line: number;
+        }[];
+    }) => void;
+    debugVariableMetadata: Record<number, DebugVariableMetadata[]>;
+    debugFunctionMetadata: Record<number, string>;
+    lastBuildKey: string;
     path: string;
-    wasm?: WebAssembly.Instance;
+    wasm?: WebAssembly.Module;
+    traceStartedAt: number;
     progress: {
         clang: Writable<number>;
         lld: Writable<number>;
@@ -28,16 +61,14 @@ export default class Clang {
     };
     constructor(options: APIOption);
     hostLog(message: string): void;
+    beginTrace(debug: boolean): void;
+    trace(message: string): void;
     hostLogAsync(message: string, promise: Promise<any>): Promise<any>;
     getModule(name: string, progress?: Writable<number>): Promise<any>;
     compile(options: any): Promise<App | null>;
-    link(obj: string, wasm: string): Promise<App | null>;
+    link(obj: string, wasm: string, debug?: boolean): Promise<App | null>;
     run(module: WebAssembly.Module, out: boolean, ...args: string[]): Promise<App | null>;
-    compileLink(code: string, { args }?: {
-        args?: never[] | undefined;
-    }): Promise<any>;
-    compileLinkRun(code: string, { args }?: {
-        args?: never[] | undefined;
-    }): Promise<App | null>;
+    compileLink(code: string, options?: DebugRunOptions): Promise<any>;
+    compileLinkRun(code: string, options?: DebugRunOptions): Promise<App | null>;
 }
 export {};