From 2932d37fbdee96d8019f449c939df939a5cc403e Mon Sep 17 00:00:00 2001 From: Xiliang Chen Date: Wed, 28 Aug 2024 17:10:25 +1200 Subject: [PATCH 1/4] Recent history test (#85) * test refactor * add recent history jam test --- Blockchain/Sources/Blockchain/Runtime.swift | 50 +++++++------------ .../Blockchain/Types/RecentHistory.swift | 26 ++++++++++ Codec/Sources/Codec/JamDecoder.swift | 7 ++- JAMTests/Sources/JAMTests/TestLoader.swift | 12 ++++- JAMTests/Tests/JAMTests/PVMTests.swift | 13 ++--- .../Tests/JAMTests/RecentHistoryTests.swift | 44 ++++++++++++++++ JAMTests/Tests/JAMTests/SafroleTests.swift | 13 +---- JAMTests/Tests/JAMTests/TrieTests.swift | 13 ++--- JAMTests/jamtestvectors | 2 +- 9 files changed, 117 insertions(+), 63 deletions(-) create mode 100644 JAMTests/Tests/JAMTests/RecentHistoryTests.swift diff --git a/Blockchain/Sources/Blockchain/Runtime.swift b/Blockchain/Sources/Blockchain/Runtime.swift index 175080c9..73ac9233 100644 --- a/Blockchain/Sources/Blockchain/Runtime.swift +++ b/Blockchain/Sources/Blockchain/Runtime.swift @@ -73,20 +73,9 @@ public final class Runtime { var newState = prevState.value do { - newState.recentHistory = try updateRecentHistory(block: block, state: prevState) + try updateRecentHistory(block: block, state: &newState) - let safroleResult = try newState.updateSafrole( - config: config, slot: block.header.timeslot, entropy: newState.entropyPool.t0, extrinsics: block.extrinsic.tickets - ) - newState.mergeWith(postState: safroleResult.state) - - guard safroleResult.epochMark == block.header.epoch else { - throw Error.invalidHeaderEpochMarker - } - - guard safroleResult.ticketsMark == block.header.winningTickets else { - throw Error.invalidHeaderWinningTickets - } + try updateSafrole(block: block, state: &newState) newState.coreAuthorizationPool = try updateAuthorizationPool( block: block, state: prevState @@ -106,30 +95,29 @@ public final class Runtime { return StateRef(newState) } - public func updateRecentHistory(block: BlockRef, state: StateRef) throws -> RecentHistory { - var history = state.value.recentHistory - if history.items.count >= 0 { // if this is not block #0 - // write the state root of last block - history.items[history.items.endIndex - 1].stateRoot = state.stateRoot - } - - let workReportHashes = block.extrinsic.reports.guarantees.map(\.workReport.packageSpecification.workPackageHash) + public func updateSafrole(block: BlockRef, state newState: inout State) throws { + let safroleResult = try newState.updateSafrole( + config: config, slot: block.header.timeslot, entropy: newState.entropyPool.t0, extrinsics: block.extrinsic.tickets + ) + newState.mergeWith(postState: safroleResult.state) - let accumulationResult = Data32() // TODO: calculate accumulation result + guard safroleResult.epochMark == block.header.epoch else { + throw Error.invalidHeaderEpochMarker + } - var mmr = history.items.last?.mmr ?? .init([]) - mmr.append(accumulationResult, hasher: Keccak.self) + guard safroleResult.ticketsMark == block.header.winningTickets else { + throw Error.invalidHeaderWinningTickets + } + } - let newItem = try RecentHistory.HistoryItem( + public func updateRecentHistory(block: BlockRef, state newState: inout State) throws { + let workReportHashes = block.extrinsic.reports.guarantees.map(\.workReport.packageSpecification.workPackageHash) + try newState.recentHistory.update( headerHash: block.header.parentHash, - mmr: mmr, - stateRoot: Data32(), // empty and will be updated upon next block + parentStateRoot: block.header.priorStateRoot, + accumulateRoot: Data32(), // TODO: calculate accumulation result workReportHashes: ConfigLimitedSizeArray(config: config, array: workReportHashes) ) - - history.items.safeAppend(newItem) - - return history } // TODO: add tests diff --git a/Blockchain/Sources/Blockchain/Types/RecentHistory.swift b/Blockchain/Sources/Blockchain/Types/RecentHistory.swift index fc76ac0f..c8c12936 100644 --- a/Blockchain/Sources/Blockchain/Types/RecentHistory.swift +++ b/Blockchain/Sources/Blockchain/Types/RecentHistory.swift @@ -37,3 +37,29 @@ extension RecentHistory: Dummy { RecentHistory(items: try! ConfigLimitedSizeArray(config: config)) } } + +extension RecentHistory { + public mutating func update( + headerHash: Data32, + parentStateRoot: Data32, + accumulateRoot: Data32, + workReportHashes: ConfigLimitedSizeArray + ) { + if items.count > 0 { // if this is not block #0 + // write the state root of last block + items[items.endIndex - 1].stateRoot = parentStateRoot + } + + var mmr = items.last?.mmr ?? .init([]) + mmr.append(accumulateRoot, hasher: Keccak.self) + + let newItem = RecentHistory.HistoryItem( + headerHash: headerHash, + mmr: mmr, + stateRoot: Data32(), // empty and will be updated upon next block + workReportHashes: workReportHashes + ) + + items.safeAppend(newItem) + } +} diff --git a/Codec/Sources/Codec/JamDecoder.swift b/Codec/Sources/Codec/JamDecoder.swift index b6d9252d..0afd76bd 100644 --- a/Codec/Sources/Codec/JamDecoder.swift +++ b/Codec/Sources/Codec/JamDecoder.swift @@ -324,8 +324,11 @@ private struct JamUnkeyedDecodingContainer: UnkeyedDecodingContainer { let decoder: DecodeContext mutating func decodeNil() throws -> Bool { + guard let byte = decoder.data.next() else { + throw DecodingError.dataCorruptedError(in: self, debugDescription: "Unexpected end of data") + } currentIndex += 1 - return decoder.data.count > 0 + return byte == 0 } mutating func decode(_: Bool.Type) throws -> Bool { @@ -439,7 +442,7 @@ private struct JamSingleValueDecodingContainer: SingleValueDecodingContainer { let decoder: DecodeContext func decodeNil() -> Bool { - decoder.data.count > 0 + decoder.data.next() == 0 } func decode(_: Bool.Type) throws -> Bool { diff --git a/JAMTests/Sources/JAMTests/TestLoader.swift b/JAMTests/Sources/JAMTests/TestLoader.swift index 2c6b961b..9d5619b9 100644 --- a/JAMTests/Sources/JAMTests/TestLoader.swift +++ b/JAMTests/Sources/JAMTests/TestLoader.swift @@ -3,12 +3,20 @@ import Foundation // somehow without this the GH Actions CI fails extension Foundation.Bundle: @unchecked @retroactive Sendable {} +struct Testcase: CustomStringConvertible { + var description: String + var data: Data +} + enum TestLoader { - static func getTestFiles(path: String, extension ext: String) throws -> [(path: String, description: String)] { + static func getTestcases(path: String, extension ext: String) throws -> [Testcase] { let prefix = Bundle.module.resourcePath! + "/jamtestvectors/\(path)" let files = try FileManager.default.contentsOfDirectory(atPath: prefix) var filtered = files.filter { $0.hasSuffix(".\(ext)") } filtered.sort() - return filtered.map { (path: prefix + "/" + $0, description: $0) } + return try filtered.map { + let data = try Data(contentsOf: URL(fileURLWithPath: prefix + "/" + $0)) + return Testcase(description: $0, data: data) + } } } diff --git a/JAMTests/Tests/JAMTests/PVMTests.swift b/JAMTests/Tests/JAMTests/PVMTests.swift index 9ba9d051..0bbfa69e 100644 --- a/JAMTests/Tests/JAMTests/PVMTests.swift +++ b/JAMTests/Tests/JAMTests/PVMTests.swift @@ -62,17 +62,14 @@ struct PolkaVMTestcase: Codable, CustomStringConvertible { } struct PVMTests { - static func loadTests() throws -> [PolkaVMTestcase] { - let tests = try TestLoader.getTestFiles(path: "pvm/programs", extension: "json") - return try tests.map { - let data = try Data(contentsOf: URL(fileURLWithPath: $0.path)) - let decoder = JSONDecoder() - return try decoder.decode(PolkaVMTestcase.self, from: data) - } + static func loadTests() throws -> [Testcase] { + try TestLoader.getTestcases(path: "pvm/programs", extension: "json") } @Test(arguments: try loadTests()) - func testPVM(testCase: PolkaVMTestcase) throws { + func testPVM(testCase: Testcase) throws { + let decoder = JSONDecoder() + let testCase = try decoder.decode(PolkaVMTestcase.self, from: testCase.data) let program = try ProgramCode(Data(testCase.program)) let memory = Memory( pageMap: testCase.initialPageMap.map { (address: $0.address, length: $0.length, writable: $0.isWritable) }, diff --git a/JAMTests/Tests/JAMTests/RecentHistoryTests.swift b/JAMTests/Tests/JAMTests/RecentHistoryTests.swift new file mode 100644 index 00000000..67f3033c --- /dev/null +++ b/JAMTests/Tests/JAMTests/RecentHistoryTests.swift @@ -0,0 +1,44 @@ +import Blockchain +import Codec +import Foundation +import Testing +import Utils + +@testable import JAMTests + +struct RecentHistoryInput: Codable { + var headerHash: Data32 + var parentStateRoot: Data32 + var accumulateRoot: Data32 + var workPackages: [Data32] +} + +struct RecentHisoryTestcase: Codable { + var input: RecentHistoryInput + var preState: RecentHistory + var postState: RecentHistory +} + +struct RecentHistoryTests { + static func loadTests() throws -> [Testcase] { + try TestLoader.getTestcases(path: "history/data", extension: "scale") + } + + @Test(arguments: try loadTests()) + func recentHistory(_ testcase: Testcase) throws { + let config = ProtocolConfigRef.mainnet + let testcase = try JamDecoder.decode(RecentHisoryTestcase.self, from: testcase.data, withConfig: config) + + var state = testcase.preState + try state.update( + headerHash: testcase.input.headerHash, + parentStateRoot: testcase.input.parentStateRoot, + accumulateRoot: testcase.input.accumulateRoot, + workReportHashes: ConfigLimitedSizeArray(config: config, array: testcase.input.workPackages) + ) + + withKnownIssue("need to figure out why the hash generation doesn't match", isIntermittent: true) { + #expect(state == testcase.postState) + } + } +} diff --git a/JAMTests/Tests/JAMTests/SafroleTests.swift b/JAMTests/Tests/JAMTests/SafroleTests.swift index 77188945..12e95d86 100644 --- a/JAMTests/Tests/JAMTests/SafroleTests.swift +++ b/JAMTests/Tests/JAMTests/SafroleTests.swift @@ -93,11 +93,6 @@ struct SafroleTestcase: Codable { var postState: SafroleState } -struct Testcase: CustomStringConvertible { - var description: String - var data: Data -} - enum SafroleTestVariants: String, CaseIterable { case tiny case full @@ -121,13 +116,9 @@ enum SafroleTestVariants: String, CaseIterable { } } -final class SafroleTests { +struct SafroleTests { static func loadTests(variant: SafroleTestVariants) throws -> [Testcase] { - let tests = try TestLoader.getTestFiles(path: "safrole/\(variant)", extension: "scale") - return try tests.map { path, description in - let data = try Data(contentsOf: URL(fileURLWithPath: path)) - return Testcase(description: description, data: data) - } + try TestLoader.getTestcases(path: "safrole/\(variant)", extension: "scale") } func safroleTests(_ input: Testcase, variant: SafroleTestVariants) throws { diff --git a/JAMTests/Tests/JAMTests/TrieTests.swift b/JAMTests/Tests/JAMTests/TrieTests.swift index c0097526..b41ee45b 100644 --- a/JAMTests/Tests/JAMTests/TrieTests.swift +++ b/JAMTests/Tests/JAMTests/TrieTests.swift @@ -12,17 +12,14 @@ struct TrieElement: Codable { typealias TrieTestCase = [TrieElement] struct TrieTests { - static func loadTests() throws -> [TrieTestCase] { - let tests = try TestLoader.getTestFiles(path: "trie", extension: "json") - return try tests.map { - let data = try Data(contentsOf: URL(fileURLWithPath: $0.path)) - let decoder = JSONDecoder() - return try decoder.decode(TrieTestCase.self, from: data) - } + static func loadTests() throws -> [Testcase] { + try TestLoader.getTestcases(path: "trie", extension: "json") } @Test(arguments: try loadTests()) - func trieTests(_ testcase: TrieTestCase) throws { + func trieTests(_ testcase: Testcase) throws { + let decoder = JSONDecoder() + let testcase = try decoder.decode(TrieTestCase.self, from: testcase.data) for element in testcase { let kv = element.input.reduce(into: [Data32: Data]()) { result, entry in let keyData = Data(fromHexString: entry.key) diff --git a/JAMTests/jamtestvectors b/JAMTests/jamtestvectors index 2a633e73..35754a12 160000 --- a/JAMTests/jamtestvectors +++ b/JAMTests/jamtestvectors @@ -1 +1 @@ -Subproject commit 2a633e7398a29f2ccd167653591343dc6fc2ad90 +Subproject commit 35754a129961aaf7dd4578edb2d09d4b39f7bb5a From 691a6928984495b8c912a2274bccd0de44017aa5 Mon Sep 17 00:00:00 2001 From: Xiliang Chen Date: Wed, 28 Aug 2024 21:32:36 +1200 Subject: [PATCH 2/4] support offenders in safrole (#87) --- Blockchain/Sources/Blockchain/Runtime.swift | 6 +++- Blockchain/Sources/Blockchain/Safrole.swift | 35 ++++++++++++++++--- .../Blockchain/Types/ValidatorKey.swift | 14 ++++---- JAMTests/Tests/JAMTests/SafroleTests.swift | 2 ++ JAMTests/jamtestvectors | 2 +- 5 files changed, 47 insertions(+), 12 deletions(-) diff --git a/Blockchain/Sources/Blockchain/Runtime.swift b/Blockchain/Sources/Blockchain/Runtime.swift index 73ac9233..c068f11e 100644 --- a/Blockchain/Sources/Blockchain/Runtime.swift +++ b/Blockchain/Sources/Blockchain/Runtime.swift @@ -97,7 +97,11 @@ public final class Runtime { public func updateSafrole(block: BlockRef, state newState: inout State) throws { let safroleResult = try newState.updateSafrole( - config: config, slot: block.header.timeslot, entropy: newState.entropyPool.t0, extrinsics: block.extrinsic.tickets + config: config, + slot: block.header.timeslot, + entropy: newState.entropyPool.t0, + offenders: newState.judgements.punishSet, + extrinsics: block.extrinsic.tickets ) newState.mergeWith(postState: safroleResult.state) diff --git a/Blockchain/Sources/Blockchain/Safrole.swift b/Blockchain/Sources/Blockchain/Safrole.swift index 33867eca..6257e314 100644 --- a/Blockchain/Sources/Blockchain/Safrole.swift +++ b/Blockchain/Sources/Blockchain/Safrole.swift @@ -151,7 +151,13 @@ public protocol Safrole { > { get } var ticketsVerifier: BandersnatchRingVRFRoot { get } - func updateSafrole(config: ProtocolConfigRef, slot: TimeslotIndex, entropy: Data32, extrinsics: ExtrinsicTickets) throws(SafroleError) + func updateSafrole( + config: ProtocolConfigRef, + slot: TimeslotIndex, + entropy: Data32, + offenders: Set, + extrinsics: ExtrinsicTickets + ) throws(SafroleError) -> ( state: SafrolePostState, epochMark: EpochMarker?, @@ -207,9 +213,30 @@ func pickFallbackValidators( return indices.map { validators[$0].bandersnatch } } +func withoutOffenders( + offenders: Set, + validators: ConfigFixedSizeArray +) -> ConfigFixedSizeArray { + var validators = validators + + for i in validators.indices { + let validator = validators[i] + if offenders.contains(validator.ed25519) { + validators[i] = ValidatorKey() // replace to empty key + } + } + + return validators +} + extension Safrole { - public func updateSafrole(config: ProtocolConfigRef, slot: TimeslotIndex, entropy: Data32, - extrinsics: ExtrinsicTickets) throws(SafroleError) + public func updateSafrole( + config: ProtocolConfigRef, + slot: TimeslotIndex, + entropy: Data32, + offenders: Set, + extrinsics: ExtrinsicTickets + ) throws(SafroleError) -> ( state: SafrolePostState, epochMark: EpochMarker?, @@ -250,7 +277,7 @@ extension Safrole { let (newNextValidators, newCurrentValidators, newPreviousValidators, newTicketsVerifier) = isEpochChange ? ( - validatorQueue, // TODO: Φ filter out the one in the punishment set + withoutOffenders(offenders: offenders, validators: validatorQueue), nextValidators, currentValidators, newVerifier.ringRoot diff --git a/Blockchain/Sources/Blockchain/Types/ValidatorKey.swift b/Blockchain/Sources/Blockchain/Types/ValidatorKey.swift index d0ad46cf..9c9dde0a 100644 --- a/Blockchain/Sources/Blockchain/Types/ValidatorKey.swift +++ b/Blockchain/Sources/Blockchain/Types/ValidatorKey.swift @@ -17,16 +17,18 @@ public struct ValidatorKey: Sendable, Equatable, Codable { self.bls = bls self.metadata = metadata } + + public init() { + bandersnatch = BandersnatchPublicKey() + ed25519 = Ed25519PublicKey() + bls = BLSKey() + metadata = Data128() + } } extension ValidatorKey: Dummy { public typealias Config = ProtocolConfigRef public static func dummy(config _: Config) -> ValidatorKey { - ValidatorKey( - bandersnatch: BandersnatchPublicKey(), - ed25519: Ed25519PublicKey(), - bls: BLSKey(), - metadata: Data128() - ) + ValidatorKey() } } diff --git a/JAMTests/Tests/JAMTests/SafroleTests.swift b/JAMTests/Tests/JAMTests/SafroleTests.swift index 12e95d86..24d131a2 100644 --- a/JAMTests/Tests/JAMTests/SafroleTests.swift +++ b/JAMTests/Tests/JAMTests/SafroleTests.swift @@ -9,6 +9,7 @@ import Utils struct SafroleInput: Codable { var slot: UInt32 var entropy: Data32 + var offenders: [Ed25519PublicKey] var extrinsics: ExtrinsicTickets } @@ -130,6 +131,7 @@ struct SafroleTests { config: config, slot: testcase.input.slot, entropy: testcase.input.entropy, + offenders: Set(testcase.input.offenders), extrinsics: testcase.input.extrinsics ) } diff --git a/JAMTests/jamtestvectors b/JAMTests/jamtestvectors index 35754a12..a3f8d7af 160000 --- a/JAMTests/jamtestvectors +++ b/JAMTests/jamtestvectors @@ -1 +1 @@ -Subproject commit 35754a129961aaf7dd4578edb2d09d4b39f7bb5a +Subproject commit a3f8d7afe3954a1fe39cbcb284966b3247039a80 From f3f050172dda4700d3bf076c68252c00d31db3d7 Mon Sep 17 00:00:00 2001 From: Xiliang Chen Date: Wed, 28 Aug 2024 21:52:32 +1200 Subject: [PATCH 3/4] recent history tests are fixed now (#88) --- JAMTests/Tests/JAMTests/RecentHistoryTests.swift | 4 +--- JAMTests/jamtestvectors | 2 +- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/JAMTests/Tests/JAMTests/RecentHistoryTests.swift b/JAMTests/Tests/JAMTests/RecentHistoryTests.swift index 67f3033c..22487ac1 100644 --- a/JAMTests/Tests/JAMTests/RecentHistoryTests.swift +++ b/JAMTests/Tests/JAMTests/RecentHistoryTests.swift @@ -37,8 +37,6 @@ struct RecentHistoryTests { workReportHashes: ConfigLimitedSizeArray(config: config, array: testcase.input.workPackages) ) - withKnownIssue("need to figure out why the hash generation doesn't match", isIntermittent: true) { - #expect(state == testcase.postState) - } + #expect(state == testcase.postState) } } diff --git a/JAMTests/jamtestvectors b/JAMTests/jamtestvectors index a3f8d7af..2da1072f 160000 --- a/JAMTests/jamtestvectors +++ b/JAMTests/jamtestvectors @@ -1 +1 @@ -Subproject commit a3f8d7afe3954a1fe39cbcb284966b3247039a80 +Subproject commit 2da1072f733c2f8aec2d6a354d565410ad8dd059 From 624316df75fa14adc0c921234272fe085f7861bd Mon Sep 17 00:00:00 2001 From: Qiwei Yang Date: Thu, 29 Aug 2024 09:29:34 +0800 Subject: [PATCH 4/4] add pvm instructions 5.10, 5.11, 5.12 (#84) * fix name * add some instructions * add A.5.12 instructions * add to table * fix * add Pvm Config protocol * Update PolkaVM/Sources/PolkaVM/Instructions.swift Co-authored-by: Xiliang Chen * fix --------- Co-authored-by: Xiliang Chen --- Blockchain/Package.swift | 2 + .../Config/ProtocolConfig+Preset.swift | 4 +- .../Blockchain/Config/ProtocolConfig.swift | 5 +- PolkaVM/Sources/PolkaVM/Config.swift | 13 + PolkaVM/Sources/PolkaVM/Engine.swift | 6 - .../Sources/PolkaVM/InstructionTable.swift | 57 ++ PolkaVM/Sources/PolkaVM/Instructions.swift | 658 +++++++++++++++++- PolkaVM/Sources/PolkaVM/Registers.swift | 4 + 8 files changed, 716 insertions(+), 33 deletions(-) create mode 100644 PolkaVM/Sources/PolkaVM/Config.swift diff --git a/Blockchain/Package.swift b/Blockchain/Package.swift index 02c0abda..8263e990 100644 --- a/Blockchain/Package.swift +++ b/Blockchain/Package.swift @@ -19,6 +19,7 @@ let package = Package( .package(path: "../Codec"), .package(path: "../Utils"), .package(path: "../TracingUtils"), + .package(path: "../PolkaVM"), .package(url: "https://github.com/apple/swift-testing.git", branch: "0.10.0"), ], targets: [ @@ -29,6 +30,7 @@ let package = Package( dependencies: [ "Codec", "Utils", + "PolkaVM", "TracingUtils", ] ), diff --git a/Blockchain/Sources/Blockchain/Config/ProtocolConfig+Preset.swift b/Blockchain/Sources/Blockchain/Config/ProtocolConfig+Preset.swift index dc249393..9fe079f8 100644 --- a/Blockchain/Sources/Blockchain/Config/ProtocolConfig+Preset.swift +++ b/Blockchain/Sources/Blockchain/Config/ProtocolConfig+Preset.swift @@ -33,7 +33,7 @@ extension Ref where T == ProtocolConfig { maxEncodedWorkReportSize: 96 * 1 << 10, erasureCodedSegmentSize: 6, ticketSubmissionEndSlot: 500, - pvmDynamicAddressAlignmentFactor: 4, + pvmDynamicAddressAlignmentFactor: 2, pvmProgramInitInputDataSize: 1 << 24, pvmProgramInitPageSize: 1 << 14, pvmProgramInitSegmentSize: 1 << 16 @@ -70,7 +70,7 @@ extension Ref where T == ProtocolConfig { maxEncodedWorkReportSize: 96 * 1 << 10, erasureCodedSegmentSize: 6, ticketSubmissionEndSlot: 500, - pvmDynamicAddressAlignmentFactor: 4, + pvmDynamicAddressAlignmentFactor: 2, pvmProgramInitInputDataSize: 1 << 24, pvmProgramInitPageSize: 1 << 14, pvmProgramInitSegmentSize: 1 << 16 diff --git a/Blockchain/Sources/Blockchain/Config/ProtocolConfig.swift b/Blockchain/Sources/Blockchain/Config/ProtocolConfig.swift index c0ba1607..5f074c3b 100644 --- a/Blockchain/Sources/Blockchain/Config/ProtocolConfig.swift +++ b/Blockchain/Sources/Blockchain/Config/ProtocolConfig.swift @@ -1,3 +1,4 @@ +import PolkaVM import Utils // constants defined in the graypaper @@ -94,7 +95,7 @@ public struct ProtocolConfig: Sendable { // Y = 500: The number of slots into an epoch at which ticket-submission ends. public var ticketSubmissionEndSlot: Int - // ZA = 4: The pvm dynamic address alignment factor. + // ZA = 2: The pvm dynamic address alignment factor. public var pvmDynamicAddressAlignmentFactor: Int // ZI = 2^24: The standard pvm program initialization input data size. @@ -181,6 +182,8 @@ public struct ProtocolConfig: Sendable { public typealias ProtocolConfigRef = Ref +extension ProtocolConfig: PvmConfig {} + extension ProtocolConfig { public enum AuditTranchePeriod: ReadInt { public typealias TConfig = ProtocolConfigRef diff --git a/PolkaVM/Sources/PolkaVM/Config.swift b/PolkaVM/Sources/PolkaVM/Config.swift new file mode 100644 index 00000000..8828483d --- /dev/null +++ b/PolkaVM/Sources/PolkaVM/Config.swift @@ -0,0 +1,13 @@ +public protocol PvmConfig { + // ZA = 2: The pvm dynamic address alignment factor. + var pvmDynamicAddressAlignmentFactor: Int { get } + + // ZI = 2^24: The standard pvm program initialization input data size. + var pvmProgramInitInputDataSize: Int { get } + + // ZP = 2^14: The standard pvm program initialization page size. + var pvmProgramInitPageSize: Int { get } + + // ZQ = 2^16: The standard pvm program initialization segment size. + var pvmProgramInitSegmentSize: Int { get } +} diff --git a/PolkaVM/Sources/PolkaVM/Engine.swift b/PolkaVM/Sources/PolkaVM/Engine.swift index 5a247a0a..f9138f02 100644 --- a/PolkaVM/Sources/PolkaVM/Engine.swift +++ b/PolkaVM/Sources/PolkaVM/Engine.swift @@ -34,12 +34,6 @@ public class Engine { 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 .exit(.halt) - } - return res } } diff --git a/PolkaVM/Sources/PolkaVM/InstructionTable.swift b/PolkaVM/Sources/PolkaVM/InstructionTable.swift index 31673d04..7e5c830c 100644 --- a/PolkaVM/Sources/PolkaVM/InstructionTable.swift +++ b/PolkaVM/Sources/PolkaVM/InstructionTable.swift @@ -34,6 +34,63 @@ public class InstructionTable { Instructions.BranchLeSImm.self, Instructions.BranchGeSImm.self, Instructions.BranchGtSImm.self, + Instructions.MoveReg.self, + Instructions.Sbrk.self, + Instructions.StoreIndU8.self, + Instructions.StoreIndU16.self, + Instructions.StoreIndU32.self, + Instructions.LoadIndU8.self, + Instructions.LoadIndI8.self, + Instructions.LoadIndU16.self, + Instructions.LoadIndI16.self, + Instructions.LoadIndU32.self, + Instructions.AddImm.self, + Instructions.AndImm.self, + Instructions.XorImm.self, + Instructions.OrImm.self, + Instructions.MulImm.self, + Instructions.MulUpperSSImm.self, + Instructions.MulUpperUUImm.self, + Instructions.SetLtUImm.self, + Instructions.SetLtSImm.self, + Instructions.ShloLImm.self, + Instructions.ShloRImm.self, + Instructions.SharRImm.self, + Instructions.NegAddImm.self, + Instructions.SetGtUImm.self, + Instructions.SetGtSImm.self, + Instructions.ShloLImmAlt.self, + Instructions.ShloRImmAlt.self, + Instructions.SharRImmAlt.self, + Instructions.CmovIzImm.self, + Instructions.CmovNzImm.self, + Instructions.BranchEq.self, + Instructions.BranchNe.self, + Instructions.BranchLtU.self, + Instructions.BranchLtS.self, + Instructions.BranchGeU.self, + Instructions.BranchGeS.self, + Instructions.LoadImmJumpInd.self, + Instructions.Add.self, + Instructions.Sub.self, + Instructions.And.self, + Instructions.Xor.self, + Instructions.Or.self, + Instructions.Mul.self, + Instructions.MulUpperSS.self, + Instructions.MulUpperUU.self, + Instructions.MulUpperSU.self, + Instructions.DivU.self, + Instructions.DivS.self, + Instructions.RemU.self, + Instructions.RemS.self, + Instructions.SetLtU.self, + Instructions.SetLtS.self, + Instructions.ShloL.self, + Instructions.ShloR.self, + Instructions.SharR.self, + Instructions.CmovIz.self, + Instructions.CmovNz.self, ] var table: [Instruction.Type?] = Array(repeating: nil, count: 256) for i in 0 ..< insts.count { diff --git a/PolkaVM/Sources/PolkaVM/Instructions.swift b/PolkaVM/Sources/PolkaVM/Instructions.swift index 4d57f417..9fe0ebf2 100644 --- a/PolkaVM/Sources/PolkaVM/Instructions.swift +++ b/PolkaVM/Sources/PolkaVM/Instructions.swift @@ -7,14 +7,13 @@ public let BASIC_BLOCK_INSTRUCTIONS: Set = [ Instructions.Jump.opcode, Instructions.JumpInd.opcode, Instructions.LoadImmJump.opcode, - // TODO: uncomment after add more - // Instructions.LoadImmJumpInd.opcode, - // Instructions.BranchEq.opcode, - // Instructions.BranchNe.opcode, - // Instructions.BranchGeU.opcode, - // Instructions.BranchGeS.opcode, - // Instructions.BranchLtU.opcode, - // Instructions.BranchLtS.opcode, + Instructions.LoadImmJumpInd.opcode, + Instructions.BranchEq.opcode, + Instructions.BranchNe.opcode, + Instructions.BranchGeU.opcode, + Instructions.BranchGeS.opcode, + Instructions.BranchLtU.opcode, + Instructions.BranchLtS.opcode, Instructions.BranchEqImm.opcode, Instructions.BranchNeImm.opcode, Instructions.BranchLtUImm.opcode, @@ -28,6 +27,11 @@ public let BASIC_BLOCK_INSTRUCTIONS: Set = [ ] public enum Instructions { + public enum Constants { + public static let djumpHaltAddress: UInt32 = 0xFFFF_0000 + public static let djumpAddressAlignmentFactor: Int = 2 + } + static func decodeImmediate(_ data: Data) -> UInt32 { let len = min(data.count, 4) if len == 0 { @@ -44,10 +48,10 @@ public enum Instructions { return UInt32(bitPattern: Int32(bitPattern: value << shift) >> shift) } - static func decodeImmediate2(_ data: Data, divideBy: UInt8 = 1) throws -> (UInt32, UInt32) { + static func decodeImmediate2(_ data: Data, divideBy: UInt8 = 1, minus: Int = 1) throws -> (UInt32, UInt32) { let lX1 = try Int((data.at(relative: 0) / divideBy) & 0b111) let lX = min(4, lX1) - let lY = min(4, max(0, data.count - Int(lX) - 1)) + let lY = min(4, max(0, data.count - Int(lX) - minus)) let vX = try decodeImmediate(data.at(relative: 1 ..< 1 + lX)) let vY = try decodeImmediate(data.at(relative: (1 + lX) ..< (1 + lX + lY))) @@ -58,6 +62,35 @@ public enum Instructions { state.program.basicBlockIndices.contains(state.pc &+ offset) } + static func isDjumpValid(state: VMState, target a: UInt32, targetAligned: UInt32) -> Bool { + let za = Constants.djumpAddressAlignmentFactor + return !(a == 0 || + a > state.program.jumpTable.count * za || + Int(a) % za != 0 || + state.program.basicBlockIndices.contains(targetAligned)) + } + + static func djump(state: VMState, target: UInt32) -> ExecOutcome { + if target == Constants.djumpHaltAddress { + return .exit(.halt) + } + + let entrySize = Int(state.program.jumpTableEntrySize) + let start = ((Int(target) / Constants.djumpAddressAlignmentFactor) - 1) * entrySize + let end = start + entrySize + var targetAlignedData = state.program.jumpTable[relative: start ..< end] + guard let targetAligned = targetAlignedData.decode() else { + fatalError("unreachable: jump table entry should be valid") + } + + guard isDjumpValid(state: state, target: target, targetAligned: UInt32(truncatingIfNeeded: targetAligned)) else { + return .exit(.panic(.invalidDynamicJump)) + } + + state.updatePC(UInt32(targetAligned)) + return .continued + } + // MARK: Instructions without Arguments (5.1) public struct Trap: Instruction { @@ -195,8 +228,7 @@ public enum Instructions { public func updatePC(state: VMState, skip _: UInt32) -> ExecOutcome { let regVal = state.readRegister(register) - state.updatePC(regVal &+ offset) // wrapped add - return .continued + return Instructions.djump(state: state, target: regVal &+ offset) } } @@ -965,8 +997,8 @@ public enum Instructions { public func _executeImpl(state: VMState) -> ExecOutcome { let regVal = state.readRegister(rb) - let shift = value & 0x1F - state.writeRegister(ra, regVal << shift) + let shift = value & 0x20 + state.writeRegister(ra, UInt32(truncatingIfNeeded: regVal << shift)) return .continued } } @@ -986,7 +1018,7 @@ public enum Instructions { public func _executeImpl(state: VMState) -> ExecOutcome { let regVal = state.readRegister(rb) - let shift = value & 0x1F + let shift = value & 0x20 state.writeRegister(ra, regVal >> shift) return .continued } @@ -1007,7 +1039,7 @@ public enum Instructions { public func _executeImpl(state: VMState) -> ExecOutcome { let regVal = state.readRegister(rb) - let shift = value & 0x1F + let shift = value & 0x20 state.writeRegister(ra, UInt32(bitPattern: Int32(bitPattern: regVal) >> shift)) return .continued } @@ -1088,8 +1120,8 @@ public enum Instructions { public func _executeImpl(state: VMState) -> ExecOutcome { let regVal = state.readRegister(rb) - let shift = regVal & 0x1F - state.writeRegister(ra, value << shift) + let shift = regVal & 0x20 + state.writeRegister(ra, UInt32(truncatingIfNeeded: value << shift)) return .continued } } @@ -1109,7 +1141,7 @@ public enum Instructions { public func _executeImpl(state: VMState) -> ExecOutcome { let regVal = state.readRegister(rb) - let shift = regVal & 0x1F + let shift = regVal & 0x20 state.writeRegister(ra, value >> shift) return .continued } @@ -1130,13 +1162,13 @@ public enum Instructions { public func _executeImpl(state: VMState) -> ExecOutcome { let regVal = state.readRegister(rb) - let shift = regVal & 0x1F + let shift = regVal & 0x20 state.writeRegister(ra, UInt32(bitPattern: Int32(bitPattern: value) >> shift)) return .continued } } - public struct CmovIZImm: Instruction { + public struct CmovIzImm: Instruction { public static var opcode: UInt8 { 81 } public let ra: Registers.Index @@ -1156,7 +1188,7 @@ public enum Instructions { } } - public struct CmovNIImm: Instruction { + public struct CmovNzImm: Instruction { public static var opcode: UInt8 { 82 } public let ra: Registers.Index @@ -1175,6 +1207,544 @@ public enum Instructions { return .continued } } + + // MARK: Instructions with Arguments of Two Registers & One Offset (5.10) + + public struct BranchEq: BranchInstructionBase2 { + public static var opcode: UInt8 { 24 } + typealias Compare = CompareEq + + var r1: Registers.Index + var r2: Registers.Index + var offset: UInt32 + public init(data: Data) throws { (r1, r2, offset) = try Self.parse(data: data) } + } + + public struct BranchNe: BranchInstructionBase2 { + public static var opcode: UInt8 { 30 } + typealias Compare = CompareNe + + var r1: Registers.Index + var r2: Registers.Index + var offset: UInt32 + public init(data: Data) throws { (r1, r2, offset) = try Self.parse(data: data) } + } + + public struct BranchLtU: BranchInstructionBase2 { + public static var opcode: UInt8 { 47 } + typealias Compare = CompareLt + + var r1: Registers.Index + var r2: Registers.Index + var offset: UInt32 + public init(data: Data) throws { (r1, r2, offset) = try Self.parse(data: data) } + } + + public struct BranchLtS: BranchInstructionBase2 { + public static var opcode: UInt8 { 48 } + typealias Compare = CompareLt + + var r1: Registers.Index + var r2: Registers.Index + var offset: UInt32 + public init(data: Data) throws { (r1, r2, offset) = try Self.parse(data: data) } + } + + public struct BranchGeU: BranchInstructionBase2 { + public static var opcode: UInt8 { 41 } + typealias Compare = CompareGe + + var r1: Registers.Index + var r2: Registers.Index + var offset: UInt32 + public init(data: Data) throws { (r1, r2, offset) = try Self.parse(data: data) } + } + + public struct BranchGeS: BranchInstructionBase2 { + public static var opcode: UInt8 { 43 } + typealias Compare = CompareGe + + var r1: Registers.Index + var r2: Registers.Index + var offset: UInt32 + public init(data: Data) throws { (r1, r2, offset) = try Self.parse(data: data) } + } + + // MARK: Instruction with Arguments of Two Registers and Two Immediates (5.11) + + public struct LoadImmJumpInd: Instruction { + public static var opcode: UInt8 { 10 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let value: UInt32 + public let offset: UInt32 + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + (value, offset) = try Instructions.decodeImmediate2(data[relative: 1...], divideBy: 1, minus: 2) + } + + public func _executeImpl(state: VMState) throws -> ExecOutcome { + state.writeRegister(ra, value) + return .continued + } + + public func updatePC(state: VMState, skip _: UInt32) -> ExecOutcome { + let rbVal = state.readRegister(rb) + return Instructions.djump(state: state, target: rbVal &+ offset) + } + } + + // MARK: Instructions with Arguments of Three Registers (5.12) + + public struct Add: Instruction { + public static var opcode: UInt8 { 8 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, raVal &+ rbVal) + return .continued + } + } + + public struct Sub: Instruction { + public static var opcode: UInt8 { 20 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, raVal &- rbVal) + return .continued + } + } + + public struct And: Instruction { + public static var opcode: UInt8 { 23 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, raVal & rbVal) + return .continued + } + } + + public struct Xor: Instruction { + public static var opcode: UInt8 { 28 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, raVal ^ rbVal) + return .continued + } + } + + public struct Or: Instruction { + public static var opcode: UInt8 { 12 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, raVal | rbVal) + return .continued + } + } + + public struct Mul: Instruction { + public static var opcode: UInt8 { 34 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, raVal &* rbVal) + return .continued + } + } + + public struct MulUpperSS: Instruction { + public static var opcode: UInt8 { 67 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, UInt32(bitPattern: Int32((Int64(Int32(bitPattern: raVal)) * Int64(Int32(bitPattern: rbVal))) >> 32))) + return .continued + } + } + + public struct MulUpperUU: Instruction { + public static var opcode: UInt8 { 57 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, UInt32((UInt64(raVal) * UInt64(rbVal)) >> 32)) + return .continued + } + } + + public struct MulUpperSU: Instruction { + public static var opcode: UInt8 { 81 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, UInt32(bitPattern: Int32((Int64(Int32(bitPattern: raVal)) * Int64(Int32(bitPattern: rbVal))) >> 32))) + return .continued + } + } + + public struct DivU: Instruction { + public static var opcode: UInt8 { 68 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + if rbVal == 0 { + state.writeRegister(rd, UInt32.max) + } else { + state.writeRegister(rd, raVal / rbVal) + } + return .continued + } + } + + public struct DivS: Instruction { + public static var opcode: UInt8 { 64 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + if rbVal == 0 { + state.writeRegister(rd, UInt32.max) + } else if Int32(bitPattern: raVal) == Int32.min, Int32(bitPattern: rbVal) == -1 { + state.writeRegister(rd, raVal) + } else { + state.writeRegister(rd, UInt32(bitPattern: Int32(bitPattern: raVal) / Int32(bitPattern: rbVal))) + } + return .continued + } + } + + public struct RemU: Instruction { + public static var opcode: UInt8 { 73 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + if rbVal == 0 { + state.writeRegister(rd, raVal) + } else { + state.writeRegister(rd, raVal % rbVal) + } + return .continued + } + } + + public struct RemS: Instruction { + public static var opcode: UInt8 { 70 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + if rbVal == 0 { + state.writeRegister(rd, raVal) + } else if Int32(bitPattern: raVal) == Int32.min, Int32(bitPattern: rbVal) == -1 { + state.writeRegister(rd, 0) + } else { + state.writeRegister(rd, UInt32(bitPattern: Int32(bitPattern: raVal) % Int32(bitPattern: rbVal))) + } + return .continued + } + } + + public struct SetLtU: Instruction { + public static var opcode: UInt8 { 36 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, raVal < rbVal ? 1 : 0) + return .continued + } + } + + public struct SetLtS: Instruction { + public static var opcode: UInt8 { 58 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + state.writeRegister(rd, Int32(bitPattern: raVal) < Int32(bitPattern: rbVal) ? 1 : 0) + return .continued + } + } + + public struct ShloL: Instruction { + public static var opcode: UInt8 { 55 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + let shift = rbVal & 0x20 + state.writeRegister(rd, UInt32(truncatingIfNeeded: raVal << shift)) + return .continued + } + } + + public struct ShloR: Instruction { + public static var opcode: UInt8 { 51 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + let shift = rbVal & 0x20 + state.writeRegister(rd, raVal >> shift) + return .continued + } + } + + public struct SharR: Instruction { + public static var opcode: UInt8 { 77 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + let shift = rbVal & 0x20 + state.writeRegister(rd, UInt32(bitPattern: Int32(bitPattern: raVal) >> shift)) + return .continued + } + } + + public struct CmovIz: Instruction { + public static var opcode: UInt8 { 83 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + if rbVal == 0 { + state.writeRegister(rd, raVal) + } + return .continued + } + } + + public struct CmovNz: Instruction { + public static var opcode: UInt8 { 84 } + + public let ra: Registers.Index + public let rb: Registers.Index + public let rd: Registers.Index + + public init(data: Data) throws { + ra = try Registers.Index(ra: data.at(relative: 0)) + rb = try Registers.Index(rb: data.at(relative: 0)) + rd = try Registers.Index(rd: data.at(relative: 1)) + } + + public func _executeImpl(state: VMState) -> ExecOutcome { + let raVal = state.readRegister(ra) + let rbVal = state.readRegister(rb) + if rbVal != 0 { + state.writeRegister(rd, raVal) + } + return .continued + } + } } // MARK: Branch Helpers @@ -1192,9 +1762,7 @@ protocol BranchInstructionBase: Instruction { var offset: UInt32 { get set } func _executeImpl(state _: VMState) throws -> ExecOutcome - func updatePC(state: VMState, skip: UInt32) -> ExecOutcome - func condition(state: VMState) -> Bool } @@ -1225,6 +1793,48 @@ extension BranchInstructionBase { } } +// for branch in A.5.10 +protocol BranchInstructionBase2: Instruction { + associatedtype Compare: BranchCompare + + var r1: Registers.Index { get set } + var r2: Registers.Index { get set } + var offset: UInt32 { get set } + + func _executeImpl(state _: VMState) throws -> ExecOutcome + func updatePC(state: VMState, skip: UInt32) -> ExecOutcome + func condition(state: VMState) -> Bool +} + +extension BranchInstructionBase2 { + public static func parse(data: Data) throws -> (Registers.Index, Registers.Index, UInt32) { + let offset = try Instructions.decodeImmediate(data.at(relative: 1...)) + let r1 = try Registers.Index(ra: data.at(relative: 0)) + let r2 = try Registers.Index(rb: data.at(relative: 0)) + return (r1, r2, offset) + } + + public func _executeImpl(state _: VMState) throws -> ExecOutcome { .continued } + + public func updatePC(state: VMState, skip: UInt32) -> ExecOutcome { + guard Instructions.isBranchValid(state: state, offset: offset) else { + return .exit(.panic(.invalidBranch)) + } + if condition(state: state) { + state.increasePC(offset) + } else { + state.increasePC(skip + 1) + } + return .continued + } + + public func condition(state: VMState) -> Bool { + let r1Val = state.readRegister(r1) + let r2Val = state.readRegister(r2) + return Compare.compare(a: r1Val, b: r2Val) + } +} + public struct CompareEq: BranchCompare { public static func compare(a: UInt32, b: UInt32) -> Bool { Int32(bitPattern: a) == Int32(bitPattern: b) diff --git a/PolkaVM/Sources/PolkaVM/Registers.swift b/PolkaVM/Sources/PolkaVM/Registers.swift index dd9a047f..91180624 100644 --- a/PolkaVM/Sources/PolkaVM/Registers.swift +++ b/PolkaVM/Sources/PolkaVM/Registers.swift @@ -8,6 +8,10 @@ public struct Registers: Equatable { public init(rb: UInt8) { value = min(rb >> 4, 12) } + + public init(rd: UInt8) { + value = min(rd, 12) + } } public var reg1: UInt32 = 0