@fluffylabs/anan-as 1.2.0-41e43f6 → 1.2.0-5196d29

package/dist/build/js/assembly/instructions/shift.js

@@ -1,121 +1,121 @@
-import { ok } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 const MAX_SHIFT_64 = 64;
 const MAX_SHIFT_32 = 32;
 // SHLO_L_IMM_32
 export const shlo_l_imm_32 = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_32);
-    const value = u32(registers[reg(args.a)]);
-    registers[reg(args.b)] = u32SignExtend(value << shift);
-    return ok(r);
+    const value = u32(registers[Inst.reg(args.a)]);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(value << shift);
+    return OutcomeData.ok(r);
 };
 // SHLO_R_IMM_32
 export const shlo_r_imm_32 = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_32);
-    const value = u32(registers[reg(args.a)]);
-    registers[reg(args.b)] = u32SignExtend(value >>> shift);
-    return ok(r);
+    const value = u32(registers[Inst.reg(args.a)]);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(value >>> shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_IMM_32
 export const shar_r_imm_32 = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_32);
-    const value = u32SignExtend(u32(registers[reg(args.a)]));
-    registers[reg(args.b)] = u64(i64(value) >> i64(shift));
-    return ok(r);
+    const value = Inst.u32SignExtend(u32(registers[Inst.reg(args.a)]));
+    registers[Inst.reg(args.b)] = u64(i64(value) >> i64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_L_IMM_ALT_32
 export const shlo_l_imm_alt_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    registers[reg(args.b)] = u32SignExtend(args.c << shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c << shift);
+    return OutcomeData.ok(r);
 };
 // SHLO_R_IMM_ALT_32
 export const shlo_r_imm_alt_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    registers[reg(args.b)] = u32SignExtend(args.c >>> shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c >>> shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_IMM_ALT_32
 export const shar_r_imm_alt_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    const imm = u32SignExtend(args.c);
-    registers[reg(args.b)] = u32SignExtend(u32(i64(imm) >> i64(shift)));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    const imm = Inst.u32SignExtend(args.c);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(i64(imm) >> i64(shift)));
+    return OutcomeData.ok(r);
 };
 // SHLO_L_IMM
 export const shlo_l_imm = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_64);
-    registers[reg(args.b)] = u64(registers[reg(args.a)] << u64(shift));
-    return ok(r);
+    registers[Inst.reg(args.b)] = u64(registers[Inst.reg(args.a)] << u64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_R_IMM
 export const shlo_r_imm = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_64);
-    registers[reg(args.b)] = registers[reg(args.a)] >> u64(shift);
-    return ok(r);
+    registers[Inst.reg(args.b)] = registers[Inst.reg(args.a)] >> u64(shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_IMM
 export const shar_r_imm = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_64);
-    const value = i64(registers[reg(args.a)]);
-    registers[reg(args.b)] = u64(value >> i64(shift));
-    return ok(r);
+    const value = i64(registers[Inst.reg(args.a)]);
+    registers[Inst.reg(args.b)] = u64(value >> i64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_L_IMM_ALT
 export const shlo_l_imm_alt = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.b)] = u64(u32SignExtend(args.c) << i64(shift));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.b)] = u64(Inst.u32SignExtend(args.c) << i64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_R_IMM_ALT
 export const shlo_r_imm_alt = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.b)] = u64(u32SignExtend(args.c)) >> u64(shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.b)] = u64(Inst.u32SignExtend(args.c)) >> u64(shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_IMM_ALT
 export const shar_r_imm_alt = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    const value = u32SignExtend(args.c);
-    registers[reg(args.b)] = u32SignExtend(u32(value >> i64(shift)));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    const value = Inst.u32SignExtend(args.c);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(value >> i64(shift)));
+    return OutcomeData.ok(r);
 };
 // SHLO_L_32
 export const shlo_l_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    const value = u32(registers[reg(args.b)]);
-    registers[reg(args.c)] = u32SignExtend(value << shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    const value = u32(registers[Inst.reg(args.b)]);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(value << shift);
+    return OutcomeData.ok(r);
 };
 // SHLO_R_32
 export const shlo_r_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    const value = u32(registers[reg(args.b)]);
-    registers[reg(args.c)] = u32SignExtend(value >>> shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    const value = u32(registers[Inst.reg(args.b)]);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(value >>> shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_32
 export const shar_r_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    const regValue = u32SignExtend(u32(registers[reg(args.b)]));
-    registers[reg(args.c)] = u32SignExtend(u32(i64(regValue) >> i64(shift)));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    const regValue = Inst.u32SignExtend(u32(registers[Inst.reg(args.b)]));
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(u32(i64(regValue) >> i64(shift)));
+    return OutcomeData.ok(r);
 };
 // SHLO_L
 export const shlo_l = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.c)] = u64(registers[reg(args.b)] << u64(shift));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.c)] = u64(registers[Inst.reg(args.b)] << u64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_R
 export const shlo_r = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.c)] = registers[reg(args.b)] >> u64(shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] >> u64(shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R
 export const shar_r = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.c)] = u64(i64(registers[reg(args.b)]) >> i64(shift));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.c)] = u64(i64(registers[Inst.reg(args.b)]) >> i64(shift));
+    return OutcomeData.ok(r);
 };

package/dist/build/js/assembly/instructions/store.js

@@ -1,101 +1,101 @@
 import { MaybePageFault } from "../memory";
 import { portable } from "../portable";
-import { okOrFault } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 const faultRes = new MaybePageFault();
 // Helper function to compute effective address from base register and signed 32-bit offset
 function effectiveAddress(registers, baseReg, offset) {
-    return u32(portable.u64_add(registers[reg(u64(baseReg))], u32SignExtend(offset)));
+    return u32(portable.u64_add(registers[Inst.reg(u64(baseReg))], Inst.u32SignExtend(offset)));
 }
 // STORE_IMM_U8
 export const store_imm_u8 = (r, args, _registers, memory) => {
     const address = args.a;
     memory.setU8(faultRes, address, (args.b & 0xff));
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_U16
 export const store_imm_u16 = (r, args, _registers, memory) => {
     const address = args.a;
     memory.setU16(faultRes, address, (args.b & 65535));
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_U32
 export const store_imm_u32 = (r, args, _registers, memory) => {
     const address = args.a;
     memory.setU32(faultRes, address, args.b);
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_U64
 export const store_imm_u64 = (r, args, _registers, memory) => {
     const address = args.a;
-    memory.setU64(faultRes, address, u32SignExtend(args.b));
-    return okOrFault(r, faultRes);
+    memory.setU64(faultRes, address, Inst.u32SignExtend(args.b));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_U8
 export const store_u8 = (r, args, registers, memory) => {
-    memory.setU8(faultRes, args.b, (registers[reg(args.a)] & u64(0xff)));
-    return okOrFault(r, faultRes);
+    memory.setU8(faultRes, args.b, (registers[Inst.reg(args.a)] & u64(0xff)));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_U16
 export const store_u16 = (r, args, registers, memory) => {
-    memory.setU16(faultRes, args.b, (registers[reg(args.a)] & u64(65535)));
-    return okOrFault(r, faultRes);
+    memory.setU16(faultRes, args.b, (registers[Inst.reg(args.a)] & u64(65535)));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_U32
 export const store_u32 = (r, args, registers, memory) => {
-    memory.setU32(faultRes, args.b, u32(registers[reg(args.a)]));
-    return okOrFault(r, faultRes);
+    memory.setU32(faultRes, args.b, u32(registers[Inst.reg(args.a)]));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_U64
 export const store_u64 = (r, args, registers, memory) => {
-    memory.setU64(faultRes, args.b, registers[reg(args.a)]);
-    return okOrFault(r, faultRes);
+    memory.setU64(faultRes, args.b, registers[Inst.reg(args.a)]);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_IND_U8
 export const store_imm_ind_u8 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.b);
     memory.setU8(faultRes, address, (args.c & 0xff));
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_IND_U16
 export const store_imm_ind_u16 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.b);
     memory.setU16(faultRes, address, (args.c & 65535));
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_IND_U32
 export const store_imm_ind_u32 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.b);
     memory.setU32(faultRes, address, args.c);
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_IND_U64
 export const store_imm_ind_u64 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.b);
-    memory.setU64(faultRes, address, u32SignExtend(args.c));
-    return okOrFault(r, faultRes);
+    memory.setU64(faultRes, address, Inst.u32SignExtend(args.c));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IND_U8
 export const store_ind_u8 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.c);
-    memory.setU8(faultRes, address, (registers[reg(args.b)] & u64(0xff)));
-    return okOrFault(r, faultRes);
+    memory.setU8(faultRes, address, (registers[Inst.reg(args.b)] & u64(0xff)));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IND_U16
 export const store_ind_u16 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.c);
-    memory.setU16(faultRes, address, (registers[reg(args.b)] & u64(65535)));
-    return okOrFault(r, faultRes);
+    memory.setU16(faultRes, address, (registers[Inst.reg(args.b)] & u64(65535)));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IND_U32
 export const store_ind_u32 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.c);
-    memory.setU32(faultRes, address, u32(registers[reg(args.b)]));
-    return okOrFault(r, faultRes);
+    memory.setU32(faultRes, address, u32(registers[Inst.reg(args.b)]));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IND_U64
 export const store_ind_u64 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.c);
-    memory.setU64(faultRes, address, registers[reg(args.b)]);
-    return okOrFault(r, faultRes);
+    memory.setU64(faultRes, address, registers[Inst.reg(args.b)]);
+    return OutcomeData.okOrFault(r, faultRes);
 };

package/dist/build/js/assembly/instructions/utils.d.ts

@@ -17,7 +17,9 @@ export declare function mulUpperUnsigned(a: u64, b: u64): u64;
  */
 export declare function mulUpperSigned(a: i64, b: i64): u64;
 export declare function mulUpperSignedUnsigned(a: i64, b: u64): u64;
-export declare function u8SignExtend(v: u8): i64;
-export declare function u16SignExtend(v: u16): i64;
-export declare function u32SignExtend(v: u32): i64;
-export declare function reg(v: u64): u32;
+export declare class Inst {
+    static u8SignExtend(v: u8): i64;
+    static u16SignExtend(v: u16): i64;
+    static u32SignExtend(v: u32): i64;
+    static reg(v: u64): u32;
+}

package/dist/build/js/assembly/instructions/utils.js

@@ -1,3 +1,9 @@
+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";
 import { NO_OF_REGISTERS } from "../registers";
 /**
@@ -56,20 +62,30 @@ export function mulUpperSignedUnsigned(a, b) {
     }
     return mulUpperUnsigned(a, b);
 }
-// @inline
-export function u8SignExtend(v) {
-    // u64 wrap ensures unsigned representation in JS BigInt (no-op in AS)
-    return u64(i64(i32(i16(i8(v)))));
-}
-// @inline
-export function u16SignExtend(v) {
-    return u64(i64(i32(i16(v))));
-}
-// @inline
-export function u32SignExtend(v) {
-    return u64(i64(i32(v)));
-}
-// @inline
-export function reg(v) {
-    return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);
+export class Inst {
+    static u8SignExtend(v) {
+        // u64 wrap ensures unsigned representation in JS BigInt (no-op in AS)
+        return u64(i64(i32(i16(i8(v)))));
+    }
+    static u16SignExtend(v) {
+        return u64(i64(i32(i16(v))));
+    }
+    static u32SignExtend(v) {
+        return u64(i64(i32(v)));
+    }
+    static reg(v) {
+        return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);
+    }
 }
+__decorate([
+    inline
+], Inst, "u8SignExtend", null);
+__decorate([
+    inline
+], Inst, "u16SignExtend", null);
+__decorate([
+    inline
+], Inst, "u32SignExtend", null);
+__decorate([
+    inline
+], Inst, "reg", null);

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

@@ -1,11 +1,10 @@
 import { Arguments } from "./arguments";
-import { Gas } from "./gas";
 export declare class Instruction {
     name: string;
     kind: Arguments;
-    gas: Gas;
+    gas: u32;
     isTerminating: boolean;
 }
 export declare const MISSING_INSTRUCTION: Instruction;
 export declare const SBRK: Instruction;
-export declare const INSTRUCTIONS: Instruction[];
+export declare const INSTRUCTIONS: StaticArray<Instruction>;

package/dist/build/js/assembly/instructions.js

@@ -3,7 +3,7 @@ export class Instruction {
     constructor() {
         this.name = "";
         this.kind = Arguments.Zero;
-        this.gas = u64(0);
+        this.gas = u32(0);
         this.isTerminating = false;
     }
 }
@@ -11,13 +11,13 @@ function instruction(name, kind, gas, isTerminating = false) {
     const i = new Instruction();
     i.name = name;
     i.kind = kind;
-    i.gas = u64(gas);
+    i.gas = u32(gas);
     i.isTerminating = isTerminating;
     return i;
 }
 export const MISSING_INSTRUCTION = instruction("INVALID", Arguments.Zero, 1, false);
 export const SBRK = instruction("SBRK", Arguments.TwoReg, 1);
-export const INSTRUCTIONS = [
+export const INSTRUCTIONS = StaticArray.fromArray([
     /* 000 */ instruction("TRAP", Arguments.Zero, 1, true),
     /* 001 */ instruction("FALLTHROUGH", Arguments.Zero, 1, true),
     MISSING_INSTRUCTION,
@@ -249,4 +249,4 @@ export const INSTRUCTIONS = [
     /* 228 */ instruction("MAX_U", Arguments.ThreeReg, 1),
     /* 229 */ instruction("MIN", Arguments.ThreeReg, 1),
     /* 230 */ instruction("MIN_U", Arguments.ThreeReg, 1),
-];
+]);

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

@@ -19,7 +19,6 @@ export declare class Interpreter {
     status: Status;
     exitCode: u32;
     nextPc: u32;
-    useSbrkGas: boolean;
     private djumpRes;
     private argsRes;
     private outcomeRes;

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

@@ -1,11 +1,10 @@
 import { Args } from "./arguments";
 import { gasCounter } from "./gas";
-import { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from "./instructions";
+import { INSTRUCTIONS, MISSING_INSTRUCTION } from "./instructions";
 import { Outcome, OutcomeData, Result } from "./instructions/outcome";
-import { reg } from "./instructions/utils";
 import { RUN } from "./instructions-exe";
 import { MemoryBuilder } from "./memory";
-import { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from "./memory-page";
+import { RESERVED_MEMORY } from "./memory-page";
 import { portable } from "./portable";
 import { decodeArguments } from "./program";
 export var Status;
@@ -51,7 +50,6 @@ export class Interpreter {
         this.status = Status.OK;
         this.exitCode = 0;
         this.nextPc = 0;
-        this.useSbrkGas = false;
     }
     nextSteps(nSteps = 1) {
         // resuming after host call
@@ -72,9 +70,11 @@ export class Interpreter {
             this.nextPc = -1;
             return true;
         }
-        const program = this.program;
-        const code = program.code;
-        const mask = program.mask;
+        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++) {
@@ -94,10 +94,12 @@ export class Interpreter {
                 }
                 return false;
             }
-            const instruction = unchecked(code[pc]);
+            // 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;
-            // check gas (might be done for each block instead).
-            if (this.gas.sub(iData.gas)) {
+            if (gasCost > 0 && this.gas.sub(gasCost)) {
                 this.status = Status.OOG;
                 return false;
             }
@@ -108,15 +110,6 @@ export class Interpreter {
             // get args and invoke instruction
             const skipBytes = mask.skipBytesToNextInstruction(pc);
             const args = decodeArguments(argsRes, iData.kind, code, pc + 1, skipBytes);
-            // additional gas cost of sbrk
-            if (iData === SBRK && this.useSbrkGas) {
-                const alloc = u64(u32(this.registers[reg(u64(args.a))]));
-                const gas = portable.u64_mul(portable.u64_sub(portable.u64_add(alloc, u64(PAGE_SIZE)), u64(1)) >> u64(PAGE_SIZE_SHIFT), u64(16));
-                if (this.gas.sub(gas)) {
-                    this.status = Status.OOG;
-                    return false;
-                }
-            }
             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)
@@ -126,7 +119,7 @@ export class Interpreter {
             }
             switch (outcome.outcome) {
                 case Outcome.StaticJump: {
-                    const branchResult = branch(this.branchRes, program.basicBlocks, pc, outcome.staticJump);
+                    const branchResult = branch(this.branchRes, basicBlocks, pc, outcome.staticJump);
                     if (!branchResult.isOkay) {
                         this.status = Status.PANIC;
                         return false;
@@ -135,7 +128,7 @@ export class Interpreter {
                     continue;
                 }
                 case Outcome.DynamicJump: {
-                    const res = dJump(this.djumpRes, program.jumpTable, outcome.dJump);
+                    const res = dJump(this.djumpRes, jumpTable, outcome.dJump);
                     if (res.status === DjumpStatus.HALT) {
                         this.status = Status.HALT;
                         return false;
@@ -144,7 +137,7 @@ export class Interpreter {
                         this.status = Status.PANIC;
                         return false;
                     }
-                    const branchResult = branch(this.branchRes, program.basicBlocks, res.newPc, 0);
+                    const branchResult = branch(this.branchRes, basicBlocks, res.newPc, 0);
                     if (!branchResult.isOkay) {
                         this.status = Status.PANIC;
                         return false;

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

@@ -1,8 +1,6 @@
-/**
- * Integer minimum of two i32 values.
- */
-export declare function minI32(a: i32, b: i32): i32;
-/**
- * Unsigned integer minimum of two u32 values.
- */
-export declare function minU32(a: u32, b: u32): u32;
+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

@@ -1,14 +1,22 @@
-/**
- * Integer minimum of two i32 values.
- */
-// @inline
-export function minI32(a, b) {
-    return a < b ? a : b;
-}
-/**
- * Unsigned integer minimum of two u32 values.
- */
-// @inline
-export function minU32(a, b) {
-    return a < b ? a : b;
+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.js

@@ -4,8 +4,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { u8SignExtend, u16SignExtend, u32SignExtend } from "./instructions/utils";
-import { minU32 } from "./math";
+import { Inst } from "./instructions/utils";
+import { IntMath } from "./math";
 import { Access, Arena, PAGE_SIZE, PAGE_SIZE_SHIFT, Page, RawPage, RESERVED_MEMORY, RESERVED_PAGES, } from "./memory-page";
 import { portable } from "./portable";
 // @unmanaged
@@ -223,6 +223,7 @@ export class Memory {
         this.sbrkAddress = u32(newSbrk);
         const pageIdx = i32(portable.u64_sub(newSbrk, u64(1)) >> u64(PAGE_SIZE_SHIFT));
         if (pageIdx === this.lastAllocatedPage) {
+            faultRes.isFault = false;
             return freeMemoryStart;
         }
         for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {
@@ -232,6 +233,7 @@ export class Memory {
             this.cache.insert(i, page);
         }
         this.lastAllocatedPage = pageIdx;
+        faultRes.isFault = false;
         return freeMemoryStart;
     }
     getU8(faultRes, address) {
@@ -247,13 +249,13 @@ export class Memory {
         return portable.bswap_u64(this.getBytesReversed(faultRes, Access.Read, address, 8));
     }
     getI8(faultRes, address) {
-        return u8SignExtend(u8(this.getU8(faultRes, address)));
+        return Inst.u8SignExtend(u8(this.getU8(faultRes, address)));
     }
     getI16(faultRes, address) {
-        return u16SignExtend(u16(this.getU16(faultRes, address)));
+        return Inst.u16SignExtend(u16(this.getU16(faultRes, address)));
     }
     getI32(faultRes, address) {
-        return u32SignExtend(u32(this.getU32(faultRes, address)));
+        return Inst.u32SignExtend(u32(this.getU32(faultRes, address)));
     }
     setU8(faultRes, address, value) {
         this.setBytes(faultRes, address, value, 1);
@@ -443,7 +445,7 @@ export class Memory {
         }
         let bytesLeft = u64(value);
         // write to first page
-        const firstPageEnd = minU32(PAGE_SIZE, r.firstPageOffset + bytes);
+        const firstPageEnd = IntMath.minU32(PAGE_SIZE, r.firstPageOffset + bytes);
         for (let i = r.firstPageOffset; i < firstPageEnd; i++) {
             r.firstPageData[i] = u8(bytesLeft);
             bytesLeft >>= u64(8);
@@ -461,7 +463,7 @@ export class Memory {
         }
         // result (bytes in reverse order)
         let r = u64(0);
-        const firstPageEnd = minU32(PAGE_SIZE, this.chunksResult.firstPageOffset + bytes);
+        const firstPageEnd = IntMath.minU32(PAGE_SIZE, this.chunksResult.firstPageOffset + bytes);
         // read from first page
         for (let i = this.chunksResult.firstPageOffset; i < firstPageEnd; i++) {
             r = (r << u64(8)) | u64(this.chunksResult.firstPageData[i]);

package/dist/build/js/assembly/portable.js

@@ -24,6 +24,7 @@ export class portable {
             arr.fill(0);
             return arr;
         };
+        g.StaticArray.fromArray = (x) => x;
         g.ASC_TARGET = 0;
         g.i8 = (value) => {
             const n = typeof value === "bigint" ? Number(value) : value;