@fluffylabs/anan-as 1.2.0-c2b7f5a → 1.2.0-d27ef10

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/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/program-build.js

@@ -1,7 +1,7 @@
 import { Arguments, higNibble, lowNibble, REQUIRED_BYTES } from "./arguments";
 import { encodeVarU32 } from "./codec";
 import { INSTRUCTIONS, MISSING_INSTRUCTION } from "./instructions";
-import { minI32 } from "./math";
+import { IntMath } from "./math";
 /** Turn given bytecode into a valid program. Add JumpTable and Mask. */
 export function wrapAsProgram(bytecode) {
     const jumpTableLength = 0;
@@ -57,9 +57,9 @@ function skipBytes(kind, data) {
         case Arguments.TwoReg:
             return 1;
         case Arguments.TwoRegOneImm:
-            return 1 + minI32(4, data.length);
+            return 1 + IntMath.minI32(4, data.length);
         case Arguments.TwoRegOneOff:
-            return 1 + minI32(4, data.length);
+            return 1 + IntMath.minI32(4, data.length);
         case Arguments.TwoRegTwoImm: {
             const low = lowNibble(data[1]);
             const split = low + 1;
@@ -100,5 +100,5 @@ function immBytes(dataLength, required) {
     if (dataLength < required) {
         return 0;
     }
-    return minI32(4, dataLength - required);
+    return IntMath.minI32(4, dataLength - required);
 }

package/dist/build/js/assembly/program.js

@@ -1,7 +1,7 @@
 import { Args, Arguments, DECODERS, REQUIRED_BYTES } from "./arguments";
 import { Decoder } from "./codec";
 import { INSTRUCTIONS, MISSING_INSTRUCTION } from "./instructions";
-import { reg, u32SignExtend } from "./instructions/utils";
+import { Inst } from "./instructions/utils";
 import { portable } from "./portable";
 const MAX_SKIP = 24;
 export class CodeAndMetadata {
@@ -282,57 +282,57 @@ export function resolveArguments(argsRes, kind, code, offset, lim, registers) {
         case Arguments.Zero:
             return resolved;
         case Arguments.OneImm:
-            resolved.a = u32SignExtend(args.a);
+            resolved.a = Inst.u32SignExtend(args.a);
             return resolved;
         case Arguments.TwoImm:
-            resolved.a = u32SignExtend(args.a);
-            resolved.b = u32SignExtend(args.b);
+            resolved.a = Inst.u32SignExtend(args.a);
+            resolved.b = Inst.u32SignExtend(args.b);
             return resolved;
         case Arguments.OneOff:
-            resolved.a = u32SignExtend(args.a);
+            resolved.a = Inst.u32SignExtend(args.a);
             return resolved;
         case Arguments.OneRegOneImm:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = u32SignExtend(args.b);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = Inst.u32SignExtend(args.b);
             return resolved;
         case Arguments.OneRegOneExtImm:
-            resolved.a = registers[reg(u64(args.a))];
+            resolved.a = registers[Inst.reg(u64(args.a))];
             resolved.b = portable.u64_add(u64(args.a) << u64(32), u64(args.b));
             return resolved;
         case Arguments.OneRegTwoImm:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = u32SignExtend(args.b);
-            resolved.c = u32SignExtend(args.c);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = Inst.u32SignExtend(args.b);
+            resolved.c = Inst.u32SignExtend(args.c);
             return resolved;
         case Arguments.OneRegOneImmOneOff:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = u32SignExtend(args.b);
-            resolved.c = u32SignExtend(args.c);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = Inst.u32SignExtend(args.b);
+            resolved.c = Inst.u32SignExtend(args.c);
             return resolved;
         case Arguments.TwoReg:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
             return resolved;
         case Arguments.TwoRegOneImm:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
-            resolved.c = u32SignExtend(args.c);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
+            resolved.c = Inst.u32SignExtend(args.c);
             return resolved;
         case Arguments.TwoRegOneOff:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
-            resolved.c = u32SignExtend(args.c);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
+            resolved.c = Inst.u32SignExtend(args.c);
             return resolved;
         case Arguments.TwoRegTwoImm:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
-            resolved.c = u32SignExtend(args.c);
-            resolved.d = u32SignExtend(args.d);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
+            resolved.c = Inst.u32SignExtend(args.c);
+            resolved.d = Inst.u32SignExtend(args.d);
             return resolved;
         case Arguments.ThreeReg:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
-            resolved.c = registers[reg(u64(args.c))];
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
+            resolved.c = registers[Inst.reg(u64(args.c))];
             return resolved;
         default:
             throw new Error(`Unhandled arguments kind: ${kind}`);