@fluffylabs/anan-as 1.2.0-69743c7 → 1.2.0-c2b7f5a

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

@@ -0,0 +1,22 @@
+import { MaybePageFault } from "../memory";
+import { hostCall, ok, okOrFault, panic } from "./outcome";
+import { reg } from "./utils";
+const faultRes = new MaybePageFault();
+// INVALID
+export const INVALID = (r) => panic(r);
+// TRAP
+export const trap = (r) => panic(r);
+// FALLTHROUGH
+export const fallthrough = (r) => ok(r);
+// ECALLI
+export const ecalli = (r, args) => hostCall(r, args.a);
+// SBRK
+export const sbrk = (r, args, registers, memory) => {
+    const res = memory.sbrk(faultRes, u32(registers[reg(args.a)]));
+    // out of memory
+    if (faultRes.isFault) {
+        return okOrFault(r, faultRes);
+    }
+    registers[reg(args.b)] = res;
+    return ok(r);
+};

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

@@ -0,0 +1,6 @@
+import { InstructionRun } from "./outcome";
+export declare const move_reg: InstructionRun;
+export declare const cmov_iz_imm: InstructionRun;
+export declare const cmov_nz_imm: InstructionRun;
+export declare const cmov_iz: InstructionRun;
+export declare const cmov_nz: InstructionRun;

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

@@ -0,0 +1,35 @@
+import { ok } from "./outcome";
+import { reg, u32SignExtend } from "./utils";
+// MOVE_REG
+export const move_reg = (r, args, registers) => {
+    registers[reg(args.b)] = registers[reg(args.a)];
+    return ok(r);
+};
+// CMOV_IZ_IMM
+export const cmov_iz_imm = (r, args, registers) => {
+    if (registers[reg(args.a)] === u64(0)) {
+        registers[reg(args.b)] = u32SignExtend(args.c);
+    }
+    return ok(r);
+};
+// CMOV_NZ_IMM
+export const cmov_nz_imm = (r, args, registers) => {
+    if (registers[reg(args.a)] !== u64(0)) {
+        registers[reg(args.b)] = u32SignExtend(args.c);
+    }
+    return ok(r);
+};
+// CMOV_IZ
+export const cmov_iz = (r, args, registers) => {
+    if (registers[reg(args.a)] === u64(0)) {
+        registers[reg(args.c)] = registers[reg(args.b)];
+    }
+    return ok(r);
+};
+// CMOV_NZ
+export const cmov_nz = (r, args, registers) => {
+    if (registers[reg(args.a)] !== u64(0)) {
+        registers[reg(args.c)] = registers[reg(args.b)];
+    }
+    return ok(r);
+};

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

@@ -0,0 +1,30 @@
+import { Args } from "../arguments";
+import { MaybePageFault, Memory } from "../memory";
+import { Registers } from "../registers";
+export type InstructionRun = (o: OutcomeData, args: Args, registers: Registers, memory: Memory) => OutcomeData;
+export declare enum Result {
+    PANIC = 0,
+    FAULT = 1,
+    FAULT_ACCESS = 2,
+    HOST = 3
+}
+export declare enum Outcome {
+    Ok = 0,
+    StaticJump = 1,
+    DynamicJump = 2,
+    Result = 3
+}
+export declare class OutcomeData {
+    outcome: Outcome;
+    staticJump: i32;
+    dJump: u32;
+    result: Result;
+    exitCode: u32;
+}
+export declare function status(r: OutcomeData, result: Result): OutcomeData;
+export declare function staticJump(r: OutcomeData, offset: i32): OutcomeData;
+export declare function dJump(r: OutcomeData, address: u32): OutcomeData;
+export declare function ok(r: OutcomeData): OutcomeData;
+export declare function panic(r: OutcomeData): OutcomeData;
+export declare function hostCall(r: OutcomeData, id: u32): OutcomeData;
+export declare function okOrFault(r: OutcomeData, pageFault: MaybePageFault): OutcomeData;

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

@@ -0,0 +1,61 @@
+export var Result;
+(function (Result) {
+    Result[Result["PANIC"] = 0] = "PANIC";
+    Result[Result["FAULT"] = 1] = "FAULT";
+    Result[Result["FAULT_ACCESS"] = 2] = "FAULT_ACCESS";
+    Result[Result["HOST"] = 3] = "HOST";
+})(Result || (Result = {}));
+export var Outcome;
+(function (Outcome) {
+    Outcome[Outcome["Ok"] = 0] = "Ok";
+    Outcome[Outcome["StaticJump"] = 1] = "StaticJump";
+    Outcome[Outcome["DynamicJump"] = 2] = "DynamicJump";
+    Outcome[Outcome["Result"] = 3] = "Result";
+})(Outcome || (Outcome = {}));
+export class OutcomeData {
+    constructor() {
+        this.outcome = Outcome.Ok;
+        this.staticJump = 0;
+        this.dJump = 0;
+        this.result = Result.PANIC;
+        this.exitCode = 0;
+    }
+}
+export function status(r, result) {
+    r.outcome = Outcome.Result;
+    r.result = result;
+    return r;
+}
+export function staticJump(r, offset) {
+    r.outcome = Outcome.StaticJump;
+    r.staticJump = offset;
+    return r;
+}
+export function dJump(r, address) {
+    r.outcome = Outcome.DynamicJump;
+    r.dJump = address;
+    return r;
+}
+export function ok(r) {
+    // outcome is already pre-set to Ok by the interpreter loop
+    return r;
+}
+export function panic(r) {
+    return status(r, Result.PANIC);
+}
+export function hostCall(r, id) {
+    r.outcome = Outcome.Result;
+    r.result = Result.HOST;
+    r.exitCode = id;
+    return r;
+}
+export function okOrFault(r, pageFault) {
+    if (pageFault.isFault) {
+        r.outcome = Outcome.Result;
+        // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP
+        // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.
+        r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;
+        r.exitCode = pageFault.fault;
+    }
+    return r;
+}

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

@@ -0,0 +1,15 @@
+import { InstructionRun } from "./outcome";
+export declare const rot_r_64_imm: InstructionRun;
+export declare const rot_r_64_imm_alt: InstructionRun;
+export declare const rot_r_32_imm: InstructionRun;
+export declare const rot_r_32_imm_alt: InstructionRun;
+export declare const rot_l_64: InstructionRun;
+export declare const rot_l_32: InstructionRun;
+export declare const rot_r_64: InstructionRun;
+export declare const rot_r_32: InstructionRun;
+export declare namespace math {
+    function rot_r(v: u64, shift: u64): u64;
+    function rot_r_32(v: u32, shift: u32): u32;
+    function rot_l(v: u64, shift: u64): u64;
+    function rot_l_32(v: u32, shift: u32): u32;
+}

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

@@ -0,0 +1,66 @@
+import { portable } from "../portable";
+import { ok } from "./outcome";
+import { reg, u32SignExtend } from "./utils";
+// ROT_R_64_IMM
+export const rot_r_64_imm = (r, args, regs) => {
+    regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));
+    return ok(r);
+};
+// ROT_R_64_IMM_ALT
+export const rot_r_64_imm_alt = (r, args, regs) => {
+    regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);
+    return ok(r);
+};
+// ROT_R_32_IMM
+export const rot_r_32_imm = (r, args, regs) => {
+    regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));
+    return ok(r);
+};
+// ROT_R_32_IMM_ALT
+export const rot_r_32_imm_alt = (r, args, regs) => {
+    regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));
+    return ok(r);
+};
+// ROT_L_64
+export const rot_l_64 = (r, args, regs) => {
+    regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);
+    return ok(r);
+};
+// ROT_L_32
+export const rot_l_32 = (r, args, regs) => {
+    regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));
+    return ok(r);
+};
+// ROT_R_64
+export const rot_r_64 = (r, args, regs) => {
+    regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);
+    return ok(r);
+};
+// ROT_R_32
+export const rot_r_32 = (r, args, regs) => {
+    regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));
+    return ok(r);
+};
+export var math;
+(function (math) {
+    // @inline
+    function rot_r(v, shift) {
+        return portable.rotr_u64(v, shift);
+    }
+    math.rot_r = rot_r;
+    // @inline
+    function rot_r_32(v, shift) {
+        return portable.rotr_u32(v, shift);
+    }
+    math.rot_r_32 = rot_r_32;
+    // @inline
+    function rot_l(v, shift) {
+        return portable.rotl_u64(v, shift);
+    }
+    math.rot_l = rot_l;
+    // @inline
+    function rot_l_32(v, shift) {
+        return portable.rotl_u32(v, shift);
+    }
+    math.rot_l_32 = rot_l_32;
+})(math || (math = {}));

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

@@ -0,0 +1,7 @@
+import { InstructionRun } from "./outcome";
+export declare const set_lt_u_imm: InstructionRun;
+export declare const set_lt_s_imm: InstructionRun;
+export declare const set_gt_u_imm: InstructionRun;
+export declare const set_gt_s_imm: InstructionRun;
+export declare const set_lt_u: InstructionRun;
+export declare const set_lt_s: InstructionRun;

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

@@ -0,0 +1,36 @@
+import { ok } from "./outcome";
+import { reg, u32SignExtend } from "./utils";
+// SET_LT_U_IMM
+export const set_lt_u_imm = (r, args, registers) => {
+    const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));
+    registers[reg(args.b)] = cond ? u64(1) : u64(0);
+    return ok(r);
+};
+// SET_LT_S_IMM
+export const set_lt_s_imm = (r, args, registers) => {
+    const cond = i64(registers[reg(args.a)]) < i64(u32SignExtend(args.c));
+    registers[reg(args.b)] = cond ? u64(1) : u64(0);
+    return ok(r);
+};
+// SET_GT_U_IMM
+export const set_gt_u_imm = (r, args, registers) => {
+    const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));
+    registers[reg(args.b)] = cond ? u64(1) : u64(0);
+    return ok(r);
+};
+// SET_GT_S_IMM
+export const set_gt_s_imm = (r, args, registers) => {
+    const cond = i64(registers[reg(args.a)]) > i64(u32SignExtend(args.c));
+    registers[reg(args.b)] = cond ? u64(1) : u64(0);
+    return ok(r);
+};
+// SET_LT_U
+export const set_lt_u = (r, args, registers) => {
+    registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? u64(1) : u64(0);
+    return ok(r);
+};
+// SET_LT_S
+export const set_lt_s = (r, args, registers) => {
+    registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? u64(1) : u64(0);
+    return ok(r);
+};

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

@@ -0,0 +1,19 @@
+import { InstructionRun } from "./outcome";
+export declare const shlo_l_imm_32: InstructionRun;
+export declare const shlo_r_imm_32: InstructionRun;
+export declare const shar_r_imm_32: InstructionRun;
+export declare const shlo_l_imm_alt_32: InstructionRun;
+export declare const shlo_r_imm_alt_32: InstructionRun;
+export declare const shar_r_imm_alt_32: InstructionRun;
+export declare const shlo_l_imm: InstructionRun;
+export declare const shlo_r_imm: InstructionRun;
+export declare const shar_r_imm: InstructionRun;
+export declare const shlo_l_imm_alt: InstructionRun;
+export declare const shlo_r_imm_alt: InstructionRun;
+export declare const shar_r_imm_alt: InstructionRun;
+export declare const shlo_l_32: InstructionRun;
+export declare const shlo_r_32: InstructionRun;
+export declare const shar_r_32: InstructionRun;
+export declare const shlo_l: InstructionRun;
+export declare const shlo_r: InstructionRun;
+export declare const shar_r: InstructionRun;

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

@@ -0,0 +1,121 @@
+import { ok } from "./outcome";
+import { reg, u32SignExtend } 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};

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

@@ -0,0 +1,17 @@
+import { InstructionRun } from "./outcome";
+export declare const store_imm_u8: InstructionRun;
+export declare const store_imm_u16: InstructionRun;
+export declare const store_imm_u32: InstructionRun;
+export declare const store_imm_u64: InstructionRun;
+export declare const store_u8: InstructionRun;
+export declare const store_u16: InstructionRun;
+export declare const store_u32: InstructionRun;
+export declare const store_u64: InstructionRun;
+export declare const store_imm_ind_u8: InstructionRun;
+export declare const store_imm_ind_u16: InstructionRun;
+export declare const store_imm_ind_u32: InstructionRun;
+export declare const store_imm_ind_u64: InstructionRun;
+export declare const store_ind_u8: InstructionRun;
+export declare const store_ind_u16: InstructionRun;
+export declare const store_ind_u32: InstructionRun;
+export declare const store_ind_u64: InstructionRun;

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

@@ -0,0 +1,101 @@
+import { MaybePageFault } from "../memory";
+import { portable } from "../portable";
+import { okOrFault } from "./outcome";
+import { reg, u32SignExtend } 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)));
+}
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// STORE_U32
+export const store_u32 = (r, args, registers, memory) => {
+    memory.setU32(faultRes, args.b, u32(registers[reg(args.a)]));
+    return 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};
+// 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);
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.
+ *
+ * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.
+ * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:
+
+ * |   32-bits  |   32-bits  |
+ * +------------+------------+
+ * |    upper   |    lower   |
+ * | 0xfffffffe | 0x00000001 |
+ *
+ * So `0xfffffffe` is returned.
+ */
+export declare function mulUpperUnsigned(a: u64, b: u64): u64;
+/**
+ * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.
+ */
+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;

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

@@ -0,0 +1,75 @@
+import { portable } from "../portable";
+import { NO_OF_REGISTERS } from "../registers";
+/**
+ * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.
+ *
+ * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.
+ * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:
+
+ * |   32-bits  |   32-bits  |
+ * +------------+------------+
+ * |    upper   |    lower   |
+ * | 0xfffffffe | 0x00000001 |
+ *
+ * So `0xfffffffe` is returned.
+ */
+export function mulUpperUnsigned(a, b) {
+    const aHigh = a >> u64(32);
+    const aLow = a & u64(4294967295);
+    const bHigh = b >> u64(32);
+    const bLow = b & u64(4294967295);
+    const lowLow = portable.u64_mul(aLow, bLow);
+    const lowHigh = portable.u64_mul(aLow, bHigh);
+    const highLow = portable.u64_mul(aHigh, bLow);
+    const highHigh = portable.u64_mul(aHigh, bHigh);
+    const carry = portable.u64_add(portable.u64_add(lowLow >> u64(32), lowHigh & u64(4294967295)), highLow & u64(4294967295));
+    return portable.u64_add(portable.u64_add(portable.u64_add(highHigh, lowHigh >> u64(32)), highLow >> u64(32)), carry >> u64(32));
+}
+/**
+ * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.
+ */
+export function mulUpperSigned(a, b) {
+    let isResultNegative = false;
+    let aAbs = a;
+    let bAbs = b;
+    if (a < i64(0)) {
+        isResultNegative = !isResultNegative;
+        aAbs = portable.u64_add(~a, i64(1));
+    }
+    if (b < i64(0)) {
+        isResultNegative = !isResultNegative;
+        bAbs = portable.u64_add(~b, i64(1));
+    }
+    if (isResultNegative) {
+        const upper = mulUpperUnsigned(aAbs, bAbs);
+        const lower = portable.u64_mul(aAbs, bAbs);
+        return portable.u64_add(~upper, lower === u64(0) ? u64(1) : u64(0));
+    }
+    return mulUpperUnsigned(aAbs, bAbs);
+}
+export function mulUpperSignedUnsigned(a, b) {
+    if (a < i64(0)) {
+        const aAbs = portable.u64_add(~a, u64(1));
+        const upper = mulUpperUnsigned(aAbs, b);
+        const lower = portable.u64_mul(aAbs, b);
+        return portable.u64_add(~upper, lower === u64(0) ? u64(1) : u64(0));
+    }
+    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);
+}

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

@@ -0,0 +1,2 @@
+import { InstructionRun } from "./instructions/outcome";
+export declare const RUN: InstructionRun[];