@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/core/pvm-interpreter/ops/dynamic-jump-ops.test.js

@@ -0,0 +1,85 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { BitVec } from "#@typeberry/bytes";
+import { ImmediateDecoder } from "../args-decoder/decoders/immediate-decoder.js";
+import { BasicBlocks } from "../basic-blocks/index.js";
+import { Instruction } from "../instruction.js";
+import { InstructionResult } from "../instruction-result.js";
+import { JumpTable } from "../program-decoder/jump-table.js";
+import { Mask } from "../program-decoder/mask.js";
+import { Registers } from "../registers.js";
+import { Result } from "../result.js";
+import { bigintToUint8ArrayLE } from "../test-utils.js";
+import { DynamicJumpOps } from "./dynamic-jump-ops.js";
+describe("DynamicJumpOps", () => {
+    function prepareData(firstValue, secondValue) {
+        const regs = new Registers();
+        const jumpTable = new JumpTable(1, new Uint8Array([0, 3]));
+        const instructionResult = new InstructionResult();
+        const code = new Uint8Array([Instruction.TRAP, Instruction.TRAP, Instruction.TRAP, Instruction.ADD_32, 5, 6]);
+        const mask = new Mask(BitVec.fromBlob(new Uint8Array([0b0000_1111]), code.length));
+        const basicBlocks = new BasicBlocks();
+        basicBlocks.reset(code, mask);
+        const dynamicJumpOps = new DynamicJumpOps(regs, jumpTable, instructionResult, basicBlocks);
+        const registerIndex = 0;
+        regs.setU64(registerIndex, firstValue);
+        const immediate = new ImmediateDecoder();
+        immediate.setBytes(bigintToUint8ArrayLE(secondValue));
+        return {
+            dynamicJumpOps,
+            instructionResult,
+            registerIndex,
+            immediate,
+        };
+    }
+    it("should set correct nextPc", () => {
+        const { dynamicJumpOps, instructionResult, registerIndex, immediate } = prepareData(3n, 1n);
+        const address = dynamicJumpOps.caluclateJumpAddress(immediate, registerIndex);
+        dynamicJumpOps.jumpInd(address);
+        assert.strictEqual(instructionResult.nextPc, 3);
+        assert.strictEqual(instructionResult.status, null);
+    });
+    it("should set correct nextPc (address overflow)", () => {
+        const { dynamicJumpOps, instructionResult, registerIndex, immediate } = prepareData(2n ** 32n - 1n, 5n);
+        const address = dynamicJumpOps.caluclateJumpAddress(immediate, registerIndex);
+        dynamicJumpOps.jumpInd(address);
+        assert.strictEqual(instructionResult.nextPc, 3);
+        assert.strictEqual(instructionResult.status, null);
+    });
+    it("should change status to HALT", () => {
+        const { dynamicJumpOps, instructionResult, registerIndex, immediate } = prepareData(0xffff0000n, 0n);
+        const address = dynamicJumpOps.caluclateJumpAddress(immediate, registerIndex);
+        dynamicJumpOps.jumpInd(address);
+        assert.strictEqual(instructionResult.status, Result.HALT);
+    });
+    it("should change status to PANIC because dynamic address is equal to 0 ", () => {
+        const { dynamicJumpOps, instructionResult, registerIndex, immediate } = prepareData(0n, 0n);
+        const address = dynamicJumpOps.caluclateJumpAddress(immediate, registerIndex);
+        dynamicJumpOps.jumpInd(address);
+        assert.strictEqual(instructionResult.status, Result.PANIC);
+    });
+    it("should change status to PANIC because dynamic address does not exist in jump table", () => {
+        const { dynamicJumpOps, instructionResult, registerIndex, immediate } = prepareData(11n, 5n);
+        const address = dynamicJumpOps.caluclateJumpAddress(immediate, registerIndex);
+        dynamicJumpOps.jumpInd(address);
+        assert.strictEqual(instructionResult.status, Result.PANIC);
+    });
+    it("should change status to PANIC because dynamic address is not a multiple of jump aligment factor (that is equal to 4) ", () => {
+        const { dynamicJumpOps, instructionResult, registerIndex, immediate } = prepareData(4n, 5n);
+        const address = dynamicJumpOps.caluclateJumpAddress(immediate, registerIndex);
+        dynamicJumpOps.jumpInd(address);
+        assert.strictEqual(instructionResult.status, Result.PANIC);
+    });
+    it("should change status to PANIC because destination is not an instrction", () => {
+        const { dynamicJumpOps, instructionResult, registerIndex, immediate } = prepareData(3n, 5n);
+        const address = dynamicJumpOps.caluclateJumpAddress(immediate, registerIndex);
+        dynamicJumpOps.jumpInd(address);
+        assert.strictEqual(instructionResult.status, Result.PANIC);
+    });
+    it("should change status to PANIC because destination is not an instruction that is the beginning of basic block", () => {
+        const { dynamicJumpOps, instructionResult, registerIndex, immediate } = prepareData(3n, 5n);
+        const address = dynamicJumpOps.caluclateJumpAddress(immediate, registerIndex);
+        dynamicJumpOps.jumpInd(address);
+        assert.strictEqual(instructionResult.status, Result.PANIC);
+    });
+});

package/packages/core/pvm-interpreter/ops/host-call-ops.d.ts

@@ -0,0 +1,8 @@
+import type { ImmediateDecoder } from "../args-decoder/decoders/immediate-decoder.js";
+import type { InstructionResult } from "../instruction-result.js";
+export declare class HostCallOps {
+    private instructionResult;
+    constructor(instructionResult: InstructionResult);
+    hostCall(immediateDecoder: ImmediateDecoder): void;
+}
+//# sourceMappingURL=host-call-ops.d.ts.map

package/packages/core/pvm-interpreter/ops/host-call-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-call-ops.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/host-call-ops.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,qBAAa,WAAW;IACV,OAAO,CAAC,iBAAiB;gBAAjB,iBAAiB,EAAE,iBAAiB;IAExD,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB;CAI5C"}

package/packages/core/pvm-interpreter/ops/host-call-ops.js

@@ -0,0 +1,11 @@
+import { Result } from "../result.js";
+export class HostCallOps {
+    instructionResult;
+    constructor(instructionResult) {
+        this.instructionResult = instructionResult;
+    }
+    hostCall(immediateDecoder) {
+        this.instructionResult.status = Result.HOST;
+        this.instructionResult.exitParam = immediateDecoder.getUnsigned();
+    }
+}

package/packages/core/pvm-interpreter/ops/host-call-ops.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=host-call-ops.test.d.ts.map

package/packages/core/pvm-interpreter/ops/host-call-ops.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-call-ops.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/host-call-ops.test.ts"],"names":[],"mappings":""}

package/packages/core/pvm-interpreter/ops/host-call-ops.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { ImmediateDecoder } from "../args-decoder/decoders/immediate-decoder.js";
+import { InstructionResult } from "../instruction-result.js";
+import { Result } from "../result.js";
+import { bigintToUint8ArrayLE } from "../test-utils.js";
+import { HostCallOps } from "./host-call-ops.js";
+describe("HostCallOps", () => {
+    function prepareData(immediateValue) {
+        const instructionResult = new InstructionResult();
+        const hostCallOps = new HostCallOps(instructionResult);
+        const immediate = new ImmediateDecoder();
+        immediate.setBytes(bigintToUint8ArrayLE(immediateValue));
+        return { hostCallOps, instructionResult, immediate };
+    }
+    it("should set correct status", () => {
+        const { hostCallOps, instructionResult, immediate } = prepareData(0n);
+        hostCallOps.hostCall(immediate);
+        assert.strictEqual(instructionResult.status, Result.HOST);
+    });
+    it("should set correct exitParam", () => {
+        const value = 0x7f;
+        const { hostCallOps, instructionResult, immediate } = prepareData(BigInt(value));
+        hostCallOps.hostCall(immediate);
+        assert.strictEqual(instructionResult.exitParam, value);
+    });
+});

package/packages/core/pvm-interpreter/ops/index.d.ts

@@ -0,0 +1,14 @@
+export { BitOps } from "./bit-ops.js";
+export { BitRotationOps } from "./bit-rotation-ops.js";
+export { BooleanOps } from "./boolean-ops.js";
+export { BranchOps } from "./branch-ops.js";
+export { DynamicJumpOps } from "./dynamic-jump-ops.js";
+export { HostCallOps } from "./host-call-ops.js";
+export { LoadOps } from "./load-ops.js";
+export { MathOps } from "./math-ops.js";
+export { MemoryOps } from "./memory-ops.js";
+export { MoveOps } from "./move-ops.js";
+export { NoArgsOps } from "./no-args-ops.js";
+export { ShiftOps } from "./shift-ops.js";
+export { StoreOps } from "./store-ops.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/core/pvm-interpreter/ops/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/packages/core/pvm-interpreter/ops/index.js

@@ -0,0 +1,13 @@
+export { BitOps } from "./bit-ops.js";
+export { BitRotationOps } from "./bit-rotation-ops.js";
+export { BooleanOps } from "./boolean-ops.js";
+export { BranchOps } from "./branch-ops.js";
+export { DynamicJumpOps } from "./dynamic-jump-ops.js";
+export { HostCallOps } from "./host-call-ops.js";
+export { LoadOps } from "./load-ops.js";
+export { MathOps } from "./math-ops.js";
+export { MemoryOps } from "./memory-ops.js";
+export { MoveOps } from "./move-ops.js";
+export { NoArgsOps } from "./no-args-ops.js";
+export { ShiftOps } from "./shift-ops.js";
+export { StoreOps } from "./store-ops.js";

package/packages/core/pvm-interpreter/ops/load-ops.d.ts

@@ -0,0 +1,30 @@
+import type { ExtendedWitdthImmediateDecoder } from "../args-decoder/decoders/extended-with-immediate-decoder.js";
+import type { ImmediateDecoder } from "../args-decoder/decoders/immediate-decoder.js";
+import type { InstructionResult } from "../instruction-result.js";
+import type { Memory } from "../memory/index.js";
+import type { Registers } from "../registers.js";
+export declare class LoadOps {
+    private regs;
+    private memory;
+    private instructionResult;
+    constructor(regs: Registers, memory: Memory, instructionResult: InstructionResult);
+    loadImmediate(registerIndex: number, immediate: ImmediateDecoder): void;
+    loadImmediateU64(registerIndex: number, immediate: ExtendedWitdthImmediateDecoder): void;
+    private loadNumber;
+    private loadSignedNumber;
+    loadU8(address: number, registerIndex: number): void;
+    loadU16(address: number, registerIndex: number): void;
+    loadU32(address: number, registerIndex: number): void;
+    loadU64(address: number, registerIndex: number): void;
+    loadI8(address: number, registerIndex: number): void;
+    loadI16(address: number, registerIndex: number): void;
+    loadI32(address: number, registerIndex: number): void;
+    loadIndU8(firstRegisterIndex: number, secondRegisterIndex: number, immediateDecoder: ImmediateDecoder): void;
+    loadIndU16(firstRegisterIndex: number, secondRegisterIndex: number, immediateDecoder: ImmediateDecoder): void;
+    loadIndU32(firstRegisterIndex: number, secondRegisterIndex: number, immediateDecoder: ImmediateDecoder): void;
+    loadIndU64(firstRegisterIndex: number, secondRegisterIndex: number, immediateDecoder: ImmediateDecoder): void;
+    loadIndI8(firstRegisterIndex: number, secondRegisterIndex: number, immediateDecoder: ImmediateDecoder): void;
+    loadIndI16(firstRegisterIndex: number, secondRegisterIndex: number, immediateDecoder: ImmediateDecoder): void;
+    loadIndI32(firstRegisterIndex: number, secondRegisterIndex: number, immediateDecoder: ImmediateDecoder): void;
+}
+//# sourceMappingURL=load-ops.d.ts.map

package/packages/core/pvm-interpreter/ops/load-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-ops.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/load-ops.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,6DAA6D,CAAC;AAClH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,qBAAa,OAAO;IAEhB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,iBAAiB;gBAFjB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,iBAAiB;IAG9C,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB;IAIhE,gBAAgB,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,8BAA8B;IAIjF,OAAO,CAAC,UAAU;IAkBlB,OAAO,CAAC,gBAAgB;IAwBxB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAI7C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAI9C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAI9C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAI9C,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAI7C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAI9C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAI9C,SAAS,CAAC,kBAAkB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;IAKrG,UAAU,CAAC,kBAAkB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;IAKtG,UAAU,CAAC,kBAAkB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;IAKtG,UAAU,CAAC,kBAAkB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;IAKtG,SAAS,CAAC,kBAAkB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;IAKrG,UAAU,CAAC,kBAAkB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;IAKtG,UAAU,CAAC,kBAAkB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;CAIvG"}

package/packages/core/pvm-interpreter/ops/load-ops.js

@@ -0,0 +1,106 @@
+import { tryAsMemoryIndex } from "../memory/memory-index.js";
+import { Result } from "../result.js";
+import { addWithOverflowU32 } from "./math-utils.js";
+const REG_SIZE_BYTES = 8;
+export class LoadOps {
+    regs;
+    memory;
+    instructionResult;
+    constructor(regs, memory, instructionResult) {
+        this.regs = regs;
+        this.memory = memory;
+        this.instructionResult = instructionResult;
+    }
+    loadImmediate(registerIndex, immediate) {
+        this.regs.setU64(registerIndex, immediate.getU64());
+    }
+    loadImmediateU64(registerIndex, immediate) {
+        this.regs.setU64(registerIndex, immediate.getValue());
+    }
+    loadNumber(address, registerIndex, numberLength) {
+        const registerBytes = this.regs.getBytesAsLittleEndian(registerIndex, REG_SIZE_BYTES);
+        const loadResult = this.memory.loadInto(registerBytes.subarray(0, numberLength), tryAsMemoryIndex(address));
+        if (loadResult.isError) {
+            if (loadResult.error.isAccessFault) {
+                this.instructionResult.status = Result.FAULT_ACCESS;
+            }
+            else {
+                this.instructionResult.status = Result.FAULT;
+                this.instructionResult.exitParam = address;
+            }
+            return;
+        }
+        registerBytes.fill(0, numberLength);
+    }
+    loadSignedNumber(address, registerIndex, numberLength) {
+        // load all bytes from register to correctly handle the sign.
+        const registerBytes = this.regs.getBytesAsLittleEndian(registerIndex, REG_SIZE_BYTES);
+        const loadResult = this.memory.loadInto(registerBytes.subarray(0, numberLength), tryAsMemoryIndex(address));
+        if (loadResult.isError) {
+            if (loadResult.error.isAccessFault) {
+                this.instructionResult.status = Result.FAULT_ACCESS;
+            }
+            else {
+                this.instructionResult.status = Result.FAULT;
+                this.instructionResult.exitParam = address;
+            }
+            return;
+        }
+        const msb = registerBytes[numberLength - 1] & 0x80;
+        if (msb > 0) {
+            registerBytes.fill(0xff, numberLength);
+        }
+        else {
+            registerBytes.fill(0x00, numberLength);
+        }
+    }
+    loadU8(address, registerIndex) {
+        this.loadNumber(address, registerIndex, 1);
+    }
+    loadU16(address, registerIndex) {
+        this.loadNumber(address, registerIndex, 2);
+    }
+    loadU32(address, registerIndex) {
+        this.loadNumber(address, registerIndex, 4);
+    }
+    loadU64(address, registerIndex) {
+        this.loadNumber(address, registerIndex, 8);
+    }
+    loadI8(address, registerIndex) {
+        this.loadSignedNumber(address, registerIndex, 1);
+    }
+    loadI16(address, registerIndex) {
+        this.loadSignedNumber(address, registerIndex, 2);
+    }
+    loadI32(address, registerIndex) {
+        this.loadSignedNumber(address, registerIndex, 4);
+    }
+    loadIndU8(firstRegisterIndex, secondRegisterIndex, immediateDecoder) {
+        const address = addWithOverflowU32(this.regs.getLowerU32(secondRegisterIndex), immediateDecoder.getU32());
+        this.loadNumber(address, firstRegisterIndex, 1);
+    }
+    loadIndU16(firstRegisterIndex, secondRegisterIndex, immediateDecoder) {
+        const address = addWithOverflowU32(this.regs.getLowerU32(secondRegisterIndex), immediateDecoder.getU32());
+        this.loadNumber(address, firstRegisterIndex, 2);
+    }
+    loadIndU32(firstRegisterIndex, secondRegisterIndex, immediateDecoder) {
+        const address = addWithOverflowU32(this.regs.getLowerU32(secondRegisterIndex), immediateDecoder.getU32());
+        this.loadNumber(address, firstRegisterIndex, 4);
+    }
+    loadIndU64(firstRegisterIndex, secondRegisterIndex, immediateDecoder) {
+        const address = addWithOverflowU32(this.regs.getLowerU32(secondRegisterIndex), immediateDecoder.getU32());
+        this.loadNumber(address, firstRegisterIndex, 8);
+    }
+    loadIndI8(firstRegisterIndex, secondRegisterIndex, immediateDecoder) {
+        const address = addWithOverflowU32(this.regs.getLowerU32(secondRegisterIndex), immediateDecoder.getU32());
+        this.loadSignedNumber(address, firstRegisterIndex, 1);
+    }
+    loadIndI16(firstRegisterIndex, secondRegisterIndex, immediateDecoder) {
+        const address = addWithOverflowU32(this.regs.getLowerU32(secondRegisterIndex), immediateDecoder.getU32());
+        this.loadSignedNumber(address, firstRegisterIndex, 2);
+    }
+    loadIndI32(firstRegisterIndex, secondRegisterIndex, immediateDecoder) {
+        const address = addWithOverflowU32(this.regs.getLowerU32(secondRegisterIndex), immediateDecoder.getU32());
+        this.loadSignedNumber(address, firstRegisterIndex, 4);
+    }
+}

package/packages/core/pvm-interpreter/ops/load-ops.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=load-ops.test.d.ts.map

package/packages/core/pvm-interpreter/ops/load-ops.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-ops.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/load-ops.test.ts"],"names":[],"mappings":""}

package/packages/core/pvm-interpreter/ops/load-ops.test.js

@@ -0,0 +1,241 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { ImmediateDecoder } from "../args-decoder/decoders/immediate-decoder.js";
+import { InstructionResult } from "../instruction-result.js";
+import { Memory, MemoryBuilder } from "../memory/index.js";
+import { PAGE_SIZE, RESERVED_NUMBER_OF_PAGES } from "../memory/memory-consts.js";
+import { tryAsMemoryIndex, tryAsSbrkIndex } from "../memory/memory-index.js";
+import { getStartPageIndex } from "../memory/memory-utils.js";
+import { Registers } from "../registers.js";
+import { bigintToUint8ArrayLE } from "../test-utils.js";
+import { LoadOps } from "./load-ops.js";
+describe("LoadOps", () => {
+    describe("loadImmediate", () => {
+        function prepareLoadImmediateData(numberToLoad) {
+            const instructionResult = new InstructionResult();
+            const registers = new Registers();
+            const memory = new Memory();
+            const loadOps = new LoadOps(registers, memory, instructionResult);
+            const immediateDecoder = new ImmediateDecoder();
+            immediateDecoder.setBytes(bigintToUint8ArrayLE(numberToLoad));
+            return {
+                registers,
+                loadOps,
+                immediateDecoder,
+                resultRegister: 12,
+            };
+        }
+        it("should load positive number into register", () => {
+            const numberToLoad = 15n;
+            const { resultRegister, loadOps, registers, immediateDecoder } = prepareLoadImmediateData(numberToLoad);
+            loadOps.loadImmediate(resultRegister, immediateDecoder);
+            assert.strictEqual(registers.getI64(resultRegister), numberToLoad);
+            assert.strictEqual(registers.getU64(resultRegister), numberToLoad);
+        });
+        it("should load negative number into register", () => {
+            const numberToLoad = -1n;
+            const { resultRegister, loadOps, registers, immediateDecoder } = prepareLoadImmediateData(numberToLoad);
+            const expectedUnsignedNumber = 2n ** 64n - 1n;
+            loadOps.loadImmediate(resultRegister, immediateDecoder);
+            assert.strictEqual(registers.getI64(resultRegister), numberToLoad);
+            assert.strictEqual(registers.getU64(resultRegister), expectedUnsignedNumber);
+        });
+    });
+    function prepareLoadData(address, data) {
+        const instructionResult = new InstructionResult();
+        const memory = new MemoryBuilder()
+            .setWriteablePages(getStartPageIndex(address), tryAsMemoryIndex(getStartPageIndex(address) + PAGE_SIZE), data)
+            .finalize(tryAsMemoryIndex(20 * PAGE_SIZE), tryAsSbrkIndex(30 * PAGE_SIZE));
+        const registers = new Registers();
+        const loadOps = new LoadOps(registers, memory, instructionResult);
+        const registerIndex = 0;
+        registers.setU64(registerIndex, 0x1122334455667788n);
+        return {
+            loadOps,
+            registers,
+            registerIndex,
+        };
+    }
+    describe("load (U8, U16, U32 and U64)", () => {
+        it("should load u8 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0xff, 0xee, 0xdd, 0xcc]);
+            const { loadOps, registers, registerIndex } = prepareLoadData(address, data);
+            const expectedValue = 0xffn;
+            loadOps.loadU8(address, registerIndex);
+            assert.deepStrictEqual(registers.getI64(registerIndex), expectedValue);
+            assert.deepStrictEqual(registers.getU64(registerIndex), expectedValue);
+        });
+        it("should load u16 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0xff, 0xee, 0xdd, 0xcc]);
+            const { loadOps, registers, registerIndex } = prepareLoadData(address, data);
+            const expectedValue = 61183n;
+            loadOps.loadU16(address, registerIndex);
+            assert.deepStrictEqual(registers.getI64(registerIndex), expectedValue);
+            assert.deepStrictEqual(registers.getU64(registerIndex), expectedValue);
+        });
+        it("should load u32 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0xff, 0xee, 0xdd, 0x0c]);
+            const { loadOps, registers, registerIndex } = prepareLoadData(address, data);
+            const expectedValue = 215871231n;
+            loadOps.loadU32(address, registerIndex);
+            assert.deepStrictEqual(registers.getI64(registerIndex), expectedValue);
+            assert.deepStrictEqual(registers.getU64(registerIndex), expectedValue);
+        });
+        it("should load u64 from memory to register (negative number)", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
+            const { loadOps, registers, registerIndex } = prepareLoadData(address, data);
+            const expectedSignedValue = -1n;
+            const expectedUnsignedValue = 2n ** 64n - 1n;
+            loadOps.loadU64(address, registerIndex);
+            assert.deepStrictEqual(registers.getI64(registerIndex), expectedSignedValue);
+            assert.deepStrictEqual(registers.getU64(registerIndex), expectedUnsignedValue);
+        });
+        it("should load u64 from memory to register", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x08]);
+            const { loadOps, registers, registerIndex } = prepareLoadData(address, data);
+            const expectedValue = 0x0899aabbccddeeffn;
+            loadOps.loadU64(address, registerIndex);
+            assert.deepStrictEqual(registers.getI64(registerIndex), expectedValue);
+            assert.deepStrictEqual(registers.getU64(registerIndex), expectedValue);
+        });
+    });
+    describe("load (I8, I16 and I32)", () => {
+        it("should load i8 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0xcc, 0xff, 0xff, 0xff]);
+            const { loadOps, registers, registerIndex } = prepareLoadData(address, data);
+            const expectedSignedValue = -52n;
+            const expectedUnsignedValue = 18446744073709551564n;
+            loadOps.loadI8(address, registerIndex);
+            assert.deepStrictEqual(registers.getU64(registerIndex), expectedUnsignedValue);
+            assert.deepStrictEqual(registers.getI64(registerIndex), expectedSignedValue);
+        });
+        it("should load i16 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0xcc, 0xdd, 0xff, 0xff]);
+            const { loadOps, registers, registerIndex } = prepareLoadData(address, data);
+            const expectedSignedValue = -8756n;
+            const expectedUnsignedValue = 18446744073709542860n;
+            loadOps.loadI16(address, registerIndex);
+            assert.deepStrictEqual(registers.getU64(registerIndex), expectedUnsignedValue);
+            assert.deepStrictEqual(registers.getI64(registerIndex), expectedSignedValue);
+        });
+        it("should load i32 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0xcc, 0xdd, 0xff, 0xff]);
+            const { loadOps, registers, registerIndex } = prepareLoadData(address, data);
+            const expectedSignedValue = -8756n;
+            const expectedUnsignedValue = 18446744073709542860n;
+            loadOps.loadI32(address, registerIndex);
+            assert.deepStrictEqual(registers.getU64(registerIndex), expectedUnsignedValue);
+            assert.deepStrictEqual(registers.getI64(registerIndex), expectedSignedValue);
+        });
+    });
+    function prepareLoadIndData(address, data, registerValue, immediateValue) {
+        const instructionResult = new InstructionResult();
+        const memory = new MemoryBuilder()
+            .setWriteablePages(getStartPageIndex(address), tryAsMemoryIndex(getStartPageIndex(address) + PAGE_SIZE), data)
+            .finalize(tryAsMemoryIndex(20 * PAGE_SIZE), tryAsSbrkIndex(30 * PAGE_SIZE));
+        const registers = new Registers();
+        const loadOps = new LoadOps(registers, memory, instructionResult);
+        const addressRegisterIndex = 1;
+        const resultRegisterIndex = 0;
+        registers.setU64(addressRegisterIndex, registerValue);
+        const immediate = new ImmediateDecoder();
+        immediate.setBytes(bigintToUint8ArrayLE(immediateValue));
+        return {
+            loadOps,
+            registers,
+            addressRegisterIndex,
+            resultRegisterIndex,
+            immediate,
+        };
+    }
+    describe("loadInd (I8 I16 and I32)", () => {
+        it("should load i8 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0x11, 0xcc, 0xff, 0xff, 0xff]);
+            const { loadOps, registers, resultRegisterIndex, addressRegisterIndex, immediate } = prepareLoadIndData(address, data, 1n + 16n * BigInt(PAGE_SIZE), 1n);
+            const expectedSignedValue = -52n;
+            const expectedUnsignedValue = 18446744073709551564n;
+            loadOps.loadIndI8(resultRegisterIndex, addressRegisterIndex, immediate);
+            assert.deepStrictEqual(registers.getU64(resultRegisterIndex), expectedUnsignedValue);
+            assert.deepStrictEqual(registers.getI64(resultRegisterIndex), expectedSignedValue);
+        });
+        it("should load i16 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0x11, 0xcc, 0xdd, 0xff, 0xff]);
+            const { loadOps, registers, resultRegisterIndex, addressRegisterIndex, immediate } = prepareLoadIndData(address, data, 1n + 16n * BigInt(PAGE_SIZE), 1n);
+            const expectedSignedValue = -8756n;
+            const expectedUnsignedValue = 18446744073709542860n;
+            const immediateDecoder = new ImmediateDecoder();
+            immediateDecoder.setBytes(new Uint8Array([1]));
+            loadOps.loadIndI16(resultRegisterIndex, addressRegisterIndex, immediate);
+            assert.deepStrictEqual(registers.getU64(resultRegisterIndex), expectedUnsignedValue);
+            assert.deepStrictEqual(registers.getI64(resultRegisterIndex), expectedSignedValue);
+        });
+        it("should load i32 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0x11, 0xcc, 0xdd, 0xff, 0xff]);
+            const { loadOps, registers, resultRegisterIndex, addressRegisterIndex, immediate } = prepareLoadIndData(address, data, 1n + 16n * BigInt(PAGE_SIZE), 1n);
+            const expectedSignedValue = -8756n;
+            const expectedUnsignedValue = 18446744073709542860n;
+            loadOps.loadIndI32(resultRegisterIndex, addressRegisterIndex, immediate);
+            assert.deepStrictEqual(registers.getU64(resultRegisterIndex), expectedUnsignedValue);
+            assert.deepStrictEqual(registers.getI64(resultRegisterIndex), expectedSignedValue);
+        });
+    });
+    describe("loadInd (U8, U16 and U32)", () => {
+        it("should load u8 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0x11, 0xff, 0xee, 0xdd, 0xcc]);
+            const { loadOps, registers, resultRegisterIndex, addressRegisterIndex, immediate } = prepareLoadIndData(address, data, 1n + 16n * BigInt(PAGE_SIZE), 1n);
+            const expectedValue = 0xffn;
+            loadOps.loadIndU8(resultRegisterIndex, addressRegisterIndex, immediate);
+            assert.deepStrictEqual(registers.getU64(resultRegisterIndex), expectedValue);
+            assert.deepStrictEqual(registers.getI64(resultRegisterIndex), expectedValue);
+        });
+        it("should load u16 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0x11, 0xff, 0xee, 0xdd, 0xcc]);
+            const { loadOps, registers, resultRegisterIndex, addressRegisterIndex, immediate } = prepareLoadIndData(address, data, 1n + 16n * BigInt(PAGE_SIZE), 1n);
+            const expectedValue = 61183n;
+            loadOps.loadIndU16(resultRegisterIndex, addressRegisterIndex, immediate);
+            assert.deepStrictEqual(registers.getU64(resultRegisterIndex), expectedValue);
+            assert.deepStrictEqual(registers.getI64(resultRegisterIndex), expectedValue);
+        });
+        it("should load u32 from memory to register and extend the number to the register size", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0x11, 0xff, 0xee, 0xdd, 0x0c]);
+            const { loadOps, registers, resultRegisterIndex, addressRegisterIndex, immediate } = prepareLoadIndData(address, data, 1n + 16n * BigInt(PAGE_SIZE), 1n);
+            const expectedValue = 215871231n;
+            loadOps.loadIndU32(resultRegisterIndex, addressRegisterIndex, immediate);
+            assert.deepStrictEqual(registers.getU64(resultRegisterIndex), expectedValue);
+            assert.deepStrictEqual(registers.getI64(resultRegisterIndex), expectedValue);
+        });
+        it("should load u64 from memory to register", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0x11, 0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x08]);
+            const { loadOps, registers, resultRegisterIndex, addressRegisterIndex, immediate } = prepareLoadIndData(address, data, 1n + 16n * BigInt(PAGE_SIZE), 1n);
+            const expectedValue = 619714147312856831n;
+            loadOps.loadIndU64(resultRegisterIndex, addressRegisterIndex, immediate);
+            assert.deepStrictEqual(registers.getU64(resultRegisterIndex), expectedValue);
+            assert.deepStrictEqual(registers.getI64(resultRegisterIndex), expectedValue);
+        });
+        it("should load u64 from memory to register (negative number)", () => {
+            const address = tryAsMemoryIndex(1 + RESERVED_NUMBER_OF_PAGES * PAGE_SIZE);
+            const data = new Uint8Array([0x11, 0x11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
+            const { loadOps, registers, resultRegisterIndex, addressRegisterIndex, immediate } = prepareLoadIndData(address, data, 1n + 16n * BigInt(PAGE_SIZE), 1n);
+            const expectedSignedValue = -1n;
+            const expectedUnsignedValue = 2n ** 64n - 1n;
+            loadOps.loadIndU64(resultRegisterIndex, addressRegisterIndex, immediate);
+            assert.deepStrictEqual(registers.getU64(resultRegisterIndex), expectedUnsignedValue);
+            assert.deepStrictEqual(registers.getI64(resultRegisterIndex), expectedSignedValue);
+        });
+    });
+});

package/packages/core/pvm-interpreter/ops/math-consts.d.ts

@@ -0,0 +1,6 @@
+export declare const MAX_VALUE = 4294967295;
+export declare const MAX_VALUE_U64: bigint;
+export declare const MIN_VALUE: number;
+export declare const MAX_SHIFT_U32 = 32;
+export declare const MAX_SHIFT_U64 = 64n;
+//# sourceMappingURL=math-consts.d.ts.map

package/packages/core/pvm-interpreter/ops/math-consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math-consts.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/math-consts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,aAAa,CAAC;AACpC,eAAO,MAAM,aAAa,QAAY,CAAC;AACvC,eAAO,MAAM,SAAS,QAAa,CAAC;AACpC,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,aAAa,MAAM,CAAC"}

package/packages/core/pvm-interpreter/ops/math-consts.js

@@ -0,0 +1,5 @@
+export const MAX_VALUE = 4294967295;
+export const MAX_VALUE_U64 = 2n ** 63n;
+export const MIN_VALUE = -(2 ** 31);
+export const MAX_SHIFT_U32 = 32;
+export const MAX_SHIFT_U64 = 64n;

package/packages/core/pvm-interpreter/ops/math-ops.d.ts

@@ -0,0 +1,36 @@
+import type { ImmediateDecoder } from "../args-decoder/decoders/immediate-decoder.js";
+import { type Registers } from "../registers.js";
+export declare class MathOps {
+    private regs;
+    constructor(regs: Registers);
+    addU32(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    addU64(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    addImmediateU32(firstIndex: number, immediate: ImmediateDecoder, resultIndex: number): void;
+    addImmediateU64(firstIndex: number, immediate: ImmediateDecoder, resultIndex: number): void;
+    mulU32(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    mulU64(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    mulUpperUU(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    mulUpperSS(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    mulUpperSU(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    mulImmediateU32(firstIndex: number, immediate: ImmediateDecoder, resultIndex: number): void;
+    mulImmediateU64(firstIndex: number, immediate: ImmediateDecoder, resultIndex: number): void;
+    mulUpperSSImmediate(firstIndex: number, immediate: ImmediateDecoder, resultIndex: number): void;
+    mulUpperUUImmediate(firstIndex: number, immediate: ImmediateDecoder, resultIndex: number): void;
+    subU32(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    subU64(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    negAddImmediateU32(firstIndex: number, immediate: ImmediateDecoder, resultIndex: number): void;
+    negAddImmediateU64(firstIndex: number, immediate: ImmediateDecoder, resultIndex: number): void;
+    divSignedU32(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    divSignedU64(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    divUnsignedU32(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    divUnsignedU64(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    remSignedU32(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    remSignedU64(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    remUnsignedU32(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    remUnsignedU64(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    max(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    maxU(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    min(firstIndex: number, secondIndex: number, resultIndex: number): void;
+    minU(firstIndex: number, secondIndex: number, resultIndex: number): void;
+}
+//# sourceMappingURL=math-ops.d.ts.map

package/packages/core/pvm-interpreter/ops/math-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math-ops.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/pvm-interpreter/ops/math-ops.ts"],"names":[],"mappings":"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"}