more PVM instructions (#47)

* jump

* more instructions

* fix lint

.swiftlint.yml

@@ -7,6 +7,7 @@ disabled_rules:
     - opening_brace
     - cyclomatic_complexity
     - blanket_disable_command
+    - type_body_length
 
 excluded:
     - "**/.build"

JAMTests/Tests/JAMTests/PVMTests.swift

@@ -96,15 +96,15 @@ struct PVMTests {
 
         withKnownIssue("not yet implemented", isIntermittent: true) {
             #expect(exitReason2 == testCase.expectedStatus)
-            #expect(vmState.registers == Registers(testCase.expectedRegs))
+            #expect(vmState.getRegisters() == Registers(testCase.expectedRegs))
             #expect(vmState.pc == testCase.expectedPC)
             for chunk in testCase.expectedMemory {
                 for (offset, byte) in chunk.contents.enumerated() {
-                    let value = try vmState.memory.read(chunk.address + UInt32(offset))
+                    let value = try vmState.getMemory().read(address: chunk.address + UInt32(offset))
                     #expect(value == byte)
                 }
             }
-            #expect(vmState.gas == testCase.expectedGas)
+            #expect(vmState.getGas() == testCase.expectedGas)
         }
     }
 }

PolkaVM/Sources/PolkaVM/Engine.swift

@@ -1,11 +1,15 @@
 import Foundation
 
 public class Engine {
+    public enum Constants {
+        public static let exitAddress: UInt32 = 0xFFFF_0000
+    }
+
     public init() {}
 
     public func execute(program: ProgramCode, state: VMState) -> ExitReason {
         while true {
-            guard state.gas > 0 else {
+            guard state.getGas() > 0 else {
                 return .outOfGas
             }
             if let exitReason = step(program: program, state: state) {
@@ -30,6 +34,14 @@ public class Engine {
             return .panic(.invalidInstruction)
         }
 
-        return inst.execute(state: state, skip: skip)
+        let res = inst.execute(state: state, skip: skip)
+
+        if state.pc == Constants.exitAddress {
+            // TODO: GP only defined this for `djump` but not `branch`
+            // so need to confirm this is correct
+            return .halt
+        }
+
+        return res
     }
 }

PolkaVM/Sources/PolkaVM/Instruction.swift

@@ -3,10 +3,10 @@ import Foundation
 public protocol Instruction {
     static var opcode: UInt8 { get }
 
-    init?(data: Data)
+    init(data: Data) throws
 
     func execute(state: VMState, skip: UInt32) -> ExitReason?
-    func executeImpl(state: VMState) -> ExitReason?
+    func executeImpl(state: VMState) throws -> ExitReason?
 
     func gasCost() -> UInt64
     func updatePC(state: VMState, skip: UInt32)
@@ -15,11 +15,19 @@ public protocol Instruction {
 extension Instruction {
     public func execute(state: VMState, skip: UInt32) -> ExitReason? {
         state.consumeGas(gasCost())
-        let res = executeImpl(state: state)
-        if res == nil {
-            state.updatePC(state.pc + skip + 1)
+        do {
+            let res = try executeImpl(state: state)
+            if res == nil {
+                updatePC(state: state, skip: skip)
+            }
+            return res
+        } catch let e as Memory.Error {
+            return .pageFault(e.address)
+        } catch {
+            // other unknown errors
+            // TODO: log details
+            return .panic(.trap)
         }
-        return res
     }
 
     public func gasCost() -> UInt64 {

PolkaVM/Sources/PolkaVM/InstructionTable.swift

@@ -1,4 +1,5 @@
 import Foundation
+import Utils
 
 public class InstructionTable {
     public static let table: [Instruction.Type?] = {
@@ -9,6 +10,16 @@ public class InstructionTable {
             Instructions.StoreImmU8.self,
             Instructions.StoreImmU16.self,
             Instructions.StoreImmU32.self,
+            Instructions.JumpInd.self,
+            Instructions.LoadImm.self,
+            Instructions.LoadU8.self,
+            Instructions.LoadI8.self,
+            Instructions.LoadU16.self,
+            Instructions.LoadI16.self,
+            Instructions.LoadU32.self,
+            Instructions.StoreU8.self,
+            Instructions.StoreU16.self,
+            Instructions.StoreU32.self,
         ]
         var table: [Instruction.Type?] = Array(repeating: nil, count: 256)
         for i in 0 ..< insts.count {
@@ -25,6 +36,7 @@ public class InstructionTable {
         guard let instType = table[Int(opcode)] else {
             return nil
         }
-        return instType.init(data: data)
+        // TODO: log errors
+        return try? instType.init(data: data[relative: 1...])
     }
 }