Rename rawIndex to opcodeID in the instruction model

Author: kateinoigakukun

Sources/WasmKit/Execution/DispatchInstruction.swift

@@ -2257,6 +2257,6 @@ extension Instruction {
 
     @inline(never)
     var handler: UInt64 {
-        return Self.handlers[rawIndex]
+        return Self.handlers[Int(self.opcodeID)]
     }
 }

Sources/WasmKit/Execution/Execution.swift

@@ -238,7 +238,7 @@ func executeWasm(
             case .direct:
                 rootISeq[0] = Instruction.endOfExecution.handler
             case .token:
-                rootISeq[0] = UInt64(Instruction.endOfExecution.rawIndex)
+                rootISeq[0] = UInt64(Instruction.endOfExecution.opcodeID)
             }
             try stack.execute(
                 sp: sp,
@@ -381,8 +381,8 @@ extension Execution {
         private var buffer = CircularBuffer<UInt64>(capacity: 3)
 
         /// Tracks the given instruction index. This function is called for each instruction execution.
-        mutating func track(_ rawIndex: UInt64) {
-            buffer.append(rawIndex)
+        mutating func track(_ opcode: UInt64) {
+            buffer.append(opcode)
             if let a = buffer[0], let b = buffer[1], let c = buffer[2] {
                 let trigram = Trigram(a: a, b: b, c: c)
                 countByTrigram[trigram, default: 0] += 1
@@ -392,7 +392,7 @@ extension Execution {
         func dump<TargetStream: TextOutputStream>(target: inout TargetStream, limit: Int) {
             print("Instruction statistics:", to: &target)
             for (trigram, count) in countByTrigram.sorted(by: { $0.value > $1.value }).prefix(limit) {
-                print("  \(Instruction.name(rawIndex: trigram.a)) -> \(Instruction.name(rawIndex: trigram.b)) -> \(Instruction.name(rawIndex: trigram.c)) = \(count)", to: &target)
+                print("  \(Instruction.name(opcode: trigram.a)) -> \(Instruction.name(opcode: trigram.b)) -> \(Instruction.name(opcode: trigram.c)) = \(count)", to: &target)
             }
         }
 
@@ -412,12 +412,12 @@ extension Execution {
         var stats = StatsCollector()
         defer { stats.dump() }
 #endif
-        var inst = pc.read(UInt64.self)
+        var opcode = pc.read(OpcodeID.self)
         while true {
 #if EngineStats
             stats.track(inst)
 #endif
-            inst = try doExecute(inst, sp: &sp, pc: &pc, md: &md, ms: &ms)
+            opcode = try doExecute(opcode, sp: &sp, pc: &pc, md: &md, ms: &ms)
         }
     }
 

Sources/WasmKit/Execution/Instructions/Control.swift

@@ -108,7 +108,7 @@ extension Execution {
         case .direct:
             discriminatorPc.pointee = replaced.handler
         case .token:
-            discriminatorPc.pointee = UInt64(replaced.rawIndex)
+            discriminatorPc.pointee = UInt64(replaced.opcodeID)
         }
         try _internalCall(sp: &sp, pc: &pc, callee: callee, internalCallOperand: immediate)
         return pc.next()

Sources/WasmKit/Execution/Instructions/Instruction.swift

@@ -1020,7 +1020,8 @@ extension Instruction {
 
 
 extension Instruction {
-    var rawIndex: Int {
+    /// The opcode ID of the instruction.
+    var opcodeID: OpcodeID {
         switch self {
         case .copyStack: return 0
         case .globalGet: return 1
@@ -1227,8 +1228,8 @@ extension Instruction {
     /// - Returns: The instruction read from the program counter.
     /// - Precondition: The instruction sequence must be compiled with token threading model.
     static func load(from pc: inout Pc) -> Instruction {
-        let rawIndex = pc.read(UInt64.self)
-        switch rawIndex {
+        let opcode = pc.read(UInt64.self)
+        switch opcode {
         case 0: return .copyStack(Instruction.CopyStackOperand.load(from: &pc))
         case 1: return .globalGet(Instruction.GlobalAndVRegOperand.load(from: &pc))
         case 2: return .globalSet(Instruction.GlobalAndVRegOperand.load(from: &pc))
@@ -1425,20 +1426,20 @@ extension Instruction {
         case 193: return .tableElementDrop(Instruction.TableElementDropOperand.load(from: &pc))
         case 194: return .onEnter(Instruction.OnEnterOperand.load(from: &pc))
         case 195: return .onExit(Instruction.OnExitOperand.load(from: &pc))
-        default: fatalError("Unknown instruction index: \(rawIndex)")
+        default: fatalError("Unknown instruction opcode: \(opcode)")
         }
     }
 }
 
 #if EngineStats
 extension Instruction {
     /// The name of the instruction.
-    /// - Parameter rawIndex: The raw index of the instruction.
+    /// - Parameter opcode: The opcode ID of the instruction.
     /// - Returns: The name of the instruction.
     ///
     /// NOTE: This function is used for debugging purposes.
-    static func name(rawIndex: UInt64) -> String {
-        switch rawIndex {
+    static func name(opcode: OpcodeID) -> String {
+        switch opcode {
         case 0: return "copyStack"
         case 1: return "globalGet"
         case 2: return "globalSet"
@@ -1635,7 +1636,7 @@ extension Instruction {
         case 193: return "tableElementDrop"
         case 194: return "onEnter"
         case 195: return "onExit"
-        default: fatalError("Unknown instruction index: \(rawIndex)")
+        default: fatalError("Unknown instruction index: \(opcode)")
         }
     }
 }

Sources/WasmKit/Execution/Instructions/InstructionSupport.swift

@@ -210,6 +210,9 @@ extension Instruction {
     typealias OnExitOperand = FunctionIndex
 }
 
+/// The type of an opcode identifier.
+typealias OpcodeID = UInt64
+
 struct InstructionPrintingContext {
     let shouldColor: Bool
     let function: Function

Sources/WasmKit/Translator.swift

@@ -590,7 +590,7 @@ struct InstructionTranslator<Context: TranslatorContext>: InstructionVisitor {
             case .direct:
                 headSlot = instruction.handler
             case .token:
-                headSlot = UInt64(instruction.rawIndex)
+                headSlot = UInt64(instruction.opcodeID)
             }
             trace("        [\(index)] = 0x\(String(headSlot, radix: 16))")
             self.instructions[index] = headSlot
@@ -640,7 +640,7 @@ struct InstructionTranslator<Context: TranslatorContext>: InstructionVisitor {
             case .direct:
                 emitSlot(instruction.handler)
             case .token:
-                emitSlot(UInt64(instruction.rawIndex))
+                emitSlot(UInt64(instruction.opcodeID))
             }
             if let immediate = instruction.rawImmediate {
                 var slots: [CodeSlot] = []

Utilities/Sources/VMGen.swift

@@ -30,21 +30,21 @@ enum VMGen {
 
     static func generateDispatcher(instructions: [Instruction]) -> String {
         let doExecuteParams: [Instruction.Parameter] =
-            [("instruction", "UInt64", false)]
+            [("opcode", "OpcodeID", false)]
             + ExecutionParameter.allCases.map { ($0.label, $0.type, true) }
         var output = """
             extension Execution {
                 @inline(__always)
                 mutating func doExecute(_ \(doExecuteParams.map { "\($0.label): \($0.isInout ? "inout " : "")\($0.type)" }.joined(separator: ", "))) throws -> CodeSlot {
-                    switch instruction {
+                    switch opcode {
             """
 
-        for (index, inst) in instructions.enumerated() {
+        for (opcode, inst) in instructions.enumerated() {
             let tryPrefix = inst.mayThrow ? "try " : ""
             let args = ExecutionParameter.allCases.map { "\($0.label): &\($0.label)" }
             output += """
 
-                        case \(index): return \(tryPrefix)self.execute_\(inst.name)(\(args.joined(separator: ", ")))
+                        case \(opcode): return \(tryPrefix)self.execute_\(inst.name)(\(args.joined(separator: ", ")))
                 """
         }
         output += """
@@ -226,7 +226,8 @@ enum VMGen {
         output += "\n\n"
         output += """
         extension Instruction {
-            var rawIndex: Int {
+            /// The opcode ID of the instruction.
+            var opcodeID: OpcodeID {
                 switch self {
 
         """
@@ -247,8 +248,8 @@ enum VMGen {
             /// - Returns: The instruction read from the program counter.
             /// - Precondition: The instruction sequence must be compiled with token threading model.
             static func load(from pc: inout Pc) -> Instruction {
-                let rawIndex = pc.read(UInt64.self)
-                switch rawIndex {
+                let opcode = pc.read(UInt64.self)
+                switch opcode {
 
         """
         for (i, inst) in instructions.enumerated() {
@@ -260,7 +261,7 @@ enum VMGen {
             }
         }
         output += """
-                default: fatalError("Unknown instruction index: \\(rawIndex)")
+                default: fatalError("Unknown instruction opcode: \\(opcode)")
                 }
             }
         }
@@ -271,12 +272,12 @@ enum VMGen {
         #if EngineStats
         extension Instruction {
             /// The name of the instruction.
-            /// - Parameter rawIndex: The raw index of the instruction.
+            /// - Parameter opcode: The opcode ID of the instruction.
             /// - Returns: The name of the instruction.
             ///
             /// NOTE: This function is used for debugging purposes.
-            static func name(rawIndex: UInt64) -> String {
-                switch rawIndex {
+            static func name(opcode: OpcodeID) -> String {
+                switch opcode {
         """
         for (i, inst) in instructions.enumerated() {
             output += """
@@ -286,7 +287,7 @@ enum VMGen {
         }
         output += """
 
-                default: fatalError("Unknown instruction index: \\(rawIndex)")
+                default: fatalError("Unknown instruction index: \\(opcode)")
                 }
             }
         }
@@ -464,7 +465,7 @@ enum VMGen {
 
                     @inline(never)
                     var handler: UInt64 {
-                        return Self.handlers[rawIndex]
+                        return Self.handlers[Int(self.opcodeID)]
                     }
                 }