@fluffylabs/anan-as 1.2.0 → 1.3.0-39d3435

package/dist/build/js/assembly/interpreter.js

@@ -0,0 +1,221 @@
+import { Args } from "./arguments";
+import { gasCounter } from "./gas";
+import { INSTRUCTIONS, MISSING_INSTRUCTION } from "./instructions";
+import { Outcome, OutcomeData, Result } from "./instructions/outcome";
+import { RUN } from "./instructions-exe";
+import { MemoryBuilder } from "./memory";
+import { RESERVED_MEMORY } from "./memory-page";
+import { portable } from "./portable";
+import { decodeArguments } from "./program";
+export var Status;
+(function (Status) {
+    Status[Status["OK"] = -1] = "OK";
+    Status[Status["HALT"] = 0] = "HALT";
+    Status[Status["PANIC"] = 1] = "PANIC";
+    Status[Status["FAULT"] = 2] = "FAULT";
+    Status[Status["HOST"] = 3] = "HOST";
+    Status[Status["OOG"] = 4] = "OOG";
+})(Status || (Status = {}));
+var DjumpStatus;
+(function (DjumpStatus) {
+    DjumpStatus[DjumpStatus["OK"] = 0] = "OK";
+    DjumpStatus[DjumpStatus["HALT"] = 1] = "HALT";
+    DjumpStatus[DjumpStatus["PANIC"] = 2] = "PANIC";
+})(DjumpStatus || (DjumpStatus = {}));
+// @unmanaged
+class DjumpResult {
+    constructor() {
+        this.status = DjumpStatus.OK;
+        this.newPc = 0;
+    }
+}
+// @unmanaged
+class BranchResult {
+    constructor() {
+        this.isOkay = false;
+        this.newPc = 0;
+    }
+}
+export class Interpreter {
+    constructor(program, registers, memory = new MemoryBuilder().build(0)) {
+        this.djumpRes = new DjumpResult();
+        this.argsRes = new Args();
+        this.outcomeRes = new OutcomeData();
+        this.branchRes = new BranchResult();
+        this.program = program;
+        this.registers = registers;
+        this.memory = memory;
+        this.gas = gasCounter(i64(0));
+        this.pc = 0;
+        this.status = Status.OK;
+        this.exitCode = 0;
+        this.nextPc = 0;
+    }
+    nextSteps(nSteps = 1) {
+        // resuming after host call
+        if (this.status === Status.HOST) {
+            // let's assume all is good and move on :)
+            this.status = Status.OK;
+            // apply the nextPc, but don't stop, rather continue
+            // executing right away.
+            this.pc = this.nextPc;
+            this.nextPc = -1;
+        }
+        if (this.status !== Status.OK) {
+            return false;
+        }
+        // TODO [ToDr] Some weird pre-init step for the debugger?
+        if (this.nextPc !== -1) {
+            this.pc = this.nextPc;
+            this.nextPc = -1;
+            return true;
+        }
+        const code = this.program.code;
+        const mask = this.program.mask;
+        const gasCosts = this.program.gasCosts.codeAndGas;
+        const basicBlocks = this.program.basicBlocks;
+        const jumpTable = this.program.jumpTable;
+        const argsRes = this.argsRes;
+        const outcomeRes = this.outcomeRes;
+        for (let i = 0; i < nSteps; i++) {
+            // reset some stuff at start
+            this.exitCode = 0;
+            outcomeRes.result = Result.PANIC;
+            outcomeRes.outcome = Outcome.Ok;
+            const pc = this.pc;
+            // check if we are at the right location
+            if (!mask.isInstruction(pc)) {
+                // TODO [ToDr] Potential edge case here?
+                if (this.gas.sub(MISSING_INSTRUCTION.gas)) {
+                    this.status = Status.OOG;
+                }
+                else {
+                    this.status = Status.PANIC;
+                }
+                return false;
+            }
+            // check gas via pre-computed cost table (per-instruction or per-block)
+            const codeAndGas = portable.staticArrayAt(gasCosts, pc);
+            const instruction = codeAndGas & 0xff;
+            const gasCost = codeAndGas >> 8;
+            const iData = instruction < INSTRUCTIONS.length ? unchecked(INSTRUCTIONS[instruction]) : MISSING_INSTRUCTION;
+            if (gasCost > 0 && this.gas.sub(gasCost)) {
+                this.status = Status.OOG;
+                return false;
+            }
+            if (iData === MISSING_INSTRUCTION) {
+                this.status = Status.PANIC;
+                return false;
+            }
+            // get args and invoke instruction
+            const skipBytes = mask.skipBytesToNextInstruction(pc);
+            const args = decodeArguments(argsRes, iData.kind, code, pc + 1, skipBytes);
+            const exe = unchecked(RUN[instruction]);
+            const outcome = exe(outcomeRes, args, this.registers, this.memory);
+            // Fast path: Ok is the most common outcome (~70%+ of instructions)
+            if (outcome.outcome === Outcome.Ok) {
+                this.pc += 1 + skipBytes;
+                continue;
+            }
+            switch (outcome.outcome) {
+                case Outcome.StaticJump: {
+                    const branchResult = branch(this.branchRes, basicBlocks, pc, outcome.staticJump);
+                    if (!branchResult.isOkay) {
+                        this.status = Status.PANIC;
+                        return false;
+                    }
+                    this.pc = branchResult.newPc;
+                    continue;
+                }
+                case Outcome.DynamicJump: {
+                    const res = dJump(this.djumpRes, jumpTable, outcome.dJump);
+                    if (res.status === DjumpStatus.HALT) {
+                        this.status = Status.HALT;
+                        return false;
+                    }
+                    if (res.status === DjumpStatus.PANIC) {
+                        this.status = Status.PANIC;
+                        return false;
+                    }
+                    const branchResult = branch(this.branchRes, basicBlocks, res.newPc, 0);
+                    if (!branchResult.isOkay) {
+                        this.status = Status.PANIC;
+                        return false;
+                    }
+                    this.pc = branchResult.newPc;
+                    continue;
+                }
+                case Outcome.Result: {
+                    if (outcome.result === Result.HOST) {
+                        this.status = Status.HOST;
+                        this.exitCode = outcome.exitCode;
+                        // set the next PC after the host call is called.
+                        this.nextPc = this.pc + 1 + skipBytes;
+                        return false;
+                    }
+                    if (outcome.result === Result.FAULT) {
+                        // access to reserved memory should end with a panic.
+                        if (outcome.exitCode < RESERVED_MEMORY) {
+                            this.status = Status.PANIC;
+                        }
+                        else {
+                            this.status = Status.FAULT;
+                            this.exitCode = outcome.exitCode;
+                        }
+                        return false;
+                    }
+                    if (outcome.result === Result.FAULT_ACCESS) {
+                        this.status = Status.PANIC;
+                        // this.exitCode = outcome.exitCode;
+                        return false;
+                    }
+                    if (outcome.result === Result.PANIC) {
+                        this.status = Status.PANIC;
+                        this.exitCode = outcome.exitCode;
+                        return false;
+                    }
+                    throw new Error("Unknown result");
+                }
+            }
+        }
+        return true;
+    }
+}
+function branch(r, basicBlocks, pc, offset) {
+    const newPc = pc + offset;
+    if (basicBlocks.isStart(newPc)) {
+        r.isOkay = true;
+        r.newPc = newPc;
+    }
+    else {
+        r.isOkay = false;
+        r.newPc = 0;
+    }
+    return r;
+}
+const EXIT = 4294901760;
+const JUMP_ALIGMENT_FACTOR = 2;
+function dJump(r, jumpTable, address) {
+    if (address === EXIT) {
+        r.status = DjumpStatus.HALT;
+        return r;
+    }
+    if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {
+        r.status = DjumpStatus.PANIC;
+        return r;
+    }
+    const index = u32(address / JUMP_ALIGMENT_FACTOR) - 1;
+    if (index >= jumpTable.jumps.length) {
+        r.status = DjumpStatus.PANIC;
+        return r;
+    }
+    const newPc = portable.staticArrayAt(jumpTable.jumps, index);
+    if (newPc >= MAX_U32) {
+        r.status = DjumpStatus.PANIC;
+        return r;
+    }
+    r.status = DjumpStatus.OK;
+    r.newPc = u32(newPc);
+    return r;
+}
+const MAX_U32 = u64(4294967296);

package/dist/build/js/assembly/math.d.ts

@@ -0,0 +1,6 @@
+export declare class IntMath {
+    /** Integer minimum of two i32 values. */
+    static minI32(a: i32, b: i32): i32;
+    /** Unsigned integer minimum of two u32 values. */
+    static minU32(a: u32, b: u32): u32;
+}

package/dist/build/js/assembly/math.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+export class IntMath {
+    /** Integer minimum of two i32 values. */
+    static minI32(a, b) {
+        return a < b ? a : b;
+    }
+    /** Unsigned integer minimum of two u32 values. */
+    static minU32(a, b) {
+        return a < b ? a : b;
+    }
+}
+__decorate([
+    inline
+], IntMath, "minI32", null);
+__decorate([
+    inline
+], IntMath, "minU32", null);

package/dist/build/js/assembly/memory-page.d.ts

@@ -0,0 +1,36 @@
+export type PageIndex = u32;
+export type ArenaId = u32;
+/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */
+export declare const PAGE_SIZE: u32;
+export declare const PAGE_SIZE_SHIFT: u32;
+/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */
+export declare const SEGMENT_SIZE: u32;
+export declare const SEGMENT_SIZE_SHIFT: u32;
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */
+export declare const RESERVED_MEMORY: u32;
+export declare const RESERVED_PAGES: u32;
+export declare enum Access {
+    None = 0,
+    Read = 1,
+    Write = 2
+}
+export declare class Page {
+    readonly access: Access;
+    readonly raw: RawPage;
+    constructor(access: Access, raw: RawPage);
+    can(access: Access): boolean;
+}
+export declare class RawPage {
+    readonly id: ArenaId;
+    page: Uint8Array;
+    constructor(id: ArenaId, page: Uint8Array);
+    get data(): Uint8Array;
+}
+export declare class Arena {
+    private free;
+    private readonly arenaBytes;
+    private extraPageIndex;
+    constructor(pageCount: u32);
+    acquire(): RawPage;
+    release(page: RawPage): void;
+}

package/dist/build/js/assembly/memory-page.js

@@ -0,0 +1,74 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { portable } from "./portable";
+/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */
+export const PAGE_SIZE = 2 ** 12; // 4_096
+export const PAGE_SIZE_SHIFT = 12;
+/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */
+export const SEGMENT_SIZE = 2 ** 16; //65_536
+export const SEGMENT_SIZE_SHIFT = 16;
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */
+export const RESERVED_MEMORY = 2 ** 16;
+export const RESERVED_PAGES = RESERVED_MEMORY / PAGE_SIZE; // 16
+export var Access;
+(function (Access) {
+    Access[Access["None"] = 0] = "None";
+    Access[Access["Read"] = 1] = "Read";
+    Access[Access["Write"] = 2] = "Write";
+})(Access || (Access = {}));
+export class Page {
+    constructor(access, raw) {
+        this.access = access;
+        this.raw = raw;
+    }
+    can(access) {
+        return this.access === Access.Write || this.access === access;
+    }
+}
+__decorate([
+    inline
+], Page.prototype, "can", null);
+export class RawPage {
+    constructor(id, page) {
+        this.id = id;
+        this.page = page;
+    }
+    get data() {
+        return this.page;
+    }
+}
+__decorate([
+    inline
+], RawPage.prototype, "data", null);
+export class Arena {
+    constructor(pageCount) {
+        this.arenaBytes = PAGE_SIZE * pageCount;
+        this.free = [];
+        this.extraPageIndex = pageCount;
+        const data = new ArrayBuffer(this.arenaBytes);
+        for (let i = 0; i < pageCount; i++) {
+            this.free.unshift(new RawPage(i, portable.uint8ArrayView(data, i * PAGE_SIZE, PAGE_SIZE)));
+        }
+    }
+    acquire() {
+        if (this.free.length > 0) {
+            return this.free.pop();
+        }
+        // no pages!
+        const allocatedMemory = this.extraPageIndex * PAGE_SIZE;
+        // print warning only once
+        if (allocatedMemory === this.arenaBytes) {
+            console.log("Warning: Run out of pages! Allocating.");
+        }
+        const data = new Uint8Array(PAGE_SIZE);
+        this.extraPageIndex += 1;
+        return new RawPage(this.extraPageIndex, data);
+    }
+    release(page) {
+        this.free.push(page);
+    }
+}

package/dist/build/js/assembly/memory.d.ts

@@ -0,0 +1,83 @@
+import { Access, Arena, Page, PageIndex } from "./memory-page";
+export declare class MaybePageFault {
+    /** Accessing memory triggered a page fault. */
+    isFault: boolean;
+    /** The page fault was caused by invalid memory access (i.e. writing to read-only memory). */
+    isAccess: boolean;
+    /** Start memory index of a page that triggered the fault. */
+    fault: u32;
+}
+export declare class MemoryBuilder {
+    private readonly pages;
+    private readonly arena;
+    constructor(preAllocatePages?: u32);
+    /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */
+    setEmpty(access: Access, address: u32, len: u32): MemoryBuilder;
+    /** Allocates memory pages with given `access`, for given `address` and writes there `data` */
+    setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder;
+    /** Returns memory page for given address (creates if not exists) */
+    getOrCreatePageForAddress(access: Access, address: u32): Page;
+    build(sbrkAddress?: u32, maxHeapPointer?: u32): Memory;
+}
+export declare class Memory {
+    private readonly arena;
+    readonly pages: Map<PageIndex, Page>;
+    private sbrkAddress;
+    private lastAllocatedPage;
+    private pageResult;
+    private chunksResult;
+    private maxHeapPointer;
+    private cache;
+    constructor(arena: Arena, pages?: Map<PageIndex, Page>, sbrkAddress?: u32, maxHeapPointer?: u32);
+    pageDump(index: PageIndex): Uint8Array | null;
+    /**
+     * Returns the WASM linear memory pointer (byte offset) for the backing buffer of the page at `pageIndex`.
+     *
+     * Returns `0` if the page does not exist or is not readable (page/access fault).
+     *
+     * This enables efficient memory reading on the JS side without extra WASM allocations:
+     * ```ts
+     * let pagesRead = 0;
+     * for (let address = start; address < end; address += PAGE_SIZE) {
+     *   const page = address >> PAGE_SIZE_SHIFT;
+     *   const ptr = getPagePointer(page);
+     *   if (ptr === 0) {
+     *     throw new Error(`Page fault at ${page << PAGE_SIZE_SHIFT}`);
+     *   }
+     *   destination.set(
+     *     new Uint8Array(wasm.instance.exports.memory.buffer, ptr, Math.min(end - address, PAGE_SIZE)),
+     *     pagesRead << PAGE_SIZE_SHIFT,
+     *   );
+     *   pagesRead += 1;
+     * }
+     * ```
+     */
+    getPagePointer(pageIndex: u32): usize;
+    free(): void;
+    sbrk(faultRes: MaybePageFault, amount: u32): u64;
+    getU8(faultRes: MaybePageFault, address: u32): u64;
+    getU16(faultRes: MaybePageFault, address: u32): u64;
+    getU32(faultRes: MaybePageFault, address: u32): u64;
+    getU64(faultRes: MaybePageFault, address: u32): u64;
+    getI8(faultRes: MaybePageFault, address: u32): u64;
+    getI16(faultRes: MaybePageFault, address: u32): u64;
+    getI32(faultRes: MaybePageFault, address: u32): u64;
+    setU8(faultRes: MaybePageFault, address: u32, value: u8): void;
+    setU16(faultRes: MaybePageFault, address: u32, value: u16): void;
+    setU32(faultRes: MaybePageFault, address: u32, value: u32): void;
+    setU64(faultRes: MaybePageFault, address: u32, value: u64): void;
+    /**
+     * DO NOT USE.
+     *
+     * @deprecated exposed temporarily for debugger/typeberry API.
+     */
+    getMemory(fault: MaybePageFault, address: u32, length: u32): Uint8Array | null;
+    bytesRead(faultRes: MaybePageFault, address: u32, destination: Uint8Array, destinationOffset: u32): void;
+    /** Write bytes from given `source` (with `sourceOffset`) at given `address`. */
+    bytesWrite(faultRes: MaybePageFault, address: u32, source: Uint8Array, sourceOffset: u32): void;
+    private getPage;
+    private getChunks;
+    /** Write some bytes to at most 2 pages. */
+    private setBytes;
+    private getBytesReversed;
+}