Merge pull request #7 from Kreijstal/fix-wide-instruction-parser

Fix(parser): Correctly parse wide instructions

Author: Kreijstal

dissasembleClass.js

@@ -303,6 +303,15 @@ function disassemble(ast, constantPool) {
         line += ` ${operands.index}`;
       } else if ("value" in operands) {
         line += ` ${operands.value}`;
+      } else if ("byte" in operands) { // bipush immediate byte
+        line += ` ${operands.byte}`;
+      }
+
+      // For widened iinc (iinc_w) include constant
+      if (opcodeName === 'iinc_w' && 'const' in operands) {
+        line += ` ${operands.const}`;
+      } else if (opcodeName === 'iinc' && 'const' in operands) {
+        line += ` ${operands.index} ${operands.const}`; // existing narrow iinc already has index and const but index printed earlier
       }
 
       output.push(line);
@@ -467,15 +476,36 @@ function parseClassFile(jsonObject, opcodeNames) {
       for (const inst of codeInfo.code.instructions) {
         const opcode = inst.instruction.opcode;
         const opcodeInfo = inst.instruction.info || {};
-        const opcodeLength = opcodeInfo.length || 1;
-
-        const instruction = {
-          pc,
-          opcode,
-          opcodeName: opcodeNames[opcode], // To be resolved later
-          operands: opcodeInfo,
-          comment: null
-        };
+        const opcodeLength = opcodeInfo.length || 1; // includes wide combined length from parser
+
+        // Handle wide specially: we want a synthetic widened opcode name like istore_w
+        let instruction;
+        if (opcode === 0xc4) { // wide
+          const modified = opcodeInfo.modifiedOpcode;
+          const widenedNameBase = opcodeNames[modified];
+            // Map base mnemonic to widened form suffix, javap uses <mnemonic>_w (except iinc which becomes iinc_w)
+          const widenedName = widenedNameBase + "_w";
+          // Build operand structure
+          const wideOperands = { index: opcodeInfo.index };
+          if (modified === 0x84) { // iinc
+            wideOperands.const = opcodeInfo.info.const; // 16-bit const already parsed
+          }
+          instruction = {
+            pc,
+            opcode: modified,
+            opcodeName: widenedName,
+            operands: wideOperands,
+            comment: null
+          };
+        } else {
+          instruction = {
+            pc,
+            opcode,
+            opcodeName: opcodeNames[opcode], // To be resolved later
+            operands: opcodeInfo,
+            comment: null
+          };
+        }
 
         // Resolve operands for specific opcodes
         if ("index" in opcodeInfo) {
@@ -533,8 +563,8 @@ function parseClassFile(jsonObject, opcodeNames) {
           }
         }
 
-        instructions.push(instruction);
-        pc += opcodeLength; // Simplification; in reality, instruction lengths vary
+  instructions.push(instruction);
+  pc += opcodeLength; // length already accounts for wide expanded length
       }
 
       methodInfo.code = {

generate_java.js

@@ -0,0 +1,21 @@
+const fs = require('fs');
+
+// Create sources directory if it doesn't exist
+if (!fs.existsSync('sources')) {
+    fs.mkdirSync('sources');
+}
+
+let javaCode = `
+public class RealWide {
+    public static void main(String[] args) {
+`;
+
+for (let i = 0; i <= 256; i++) {
+    javaCode += `        int var${i} = ${i};\n`;
+}
+
+javaCode += `        System.out.println(var256);\n`;
+javaCode += `    }\n`;
+javaCode += `}\n`;
+
+fs.writeFileSync('sources/RealWide.java', javaCode);

parsers.js

@@ -411,7 +411,6 @@ const AttributeInfo = Parser.start()
   });
 
 const WideInstructionParser = Parser.start()
-  .uint8("opcode", { assert: 0xc4 }) // wide opcode
   .uint8("modifiedOpcode")
   .uint16be("index")
   .choice("info", {
@@ -435,7 +434,9 @@ const WideInstructionParser = Parser.start()
   .buffer("length", {
     length: () => 0,
     formatter: function () {
-      return 1 + 1 + 1 + 2 + (this.modifiedOpcode == 0x84 ? 2 : 0);
+  // Total length INCLUDING the wide opcode itself:
+  // 1 (wide) + 1 (modifiedOpcode) + 2 (index) + optional 2 (const for iinc)
+  return 1 + 1 + 2 + (this.modifiedOpcode === 0x84 ? 2 : 0);
     },
   });
 
@@ -1155,7 +1156,7 @@ const InstructionParser = Parser.start()
       0xc3: Parser.start()
         .namely("monitorexit")
         .buffer("length", { length: () => 0, formatter: () => 1 }), // monitorexit
-      0xc4: "wide", // wide
+      0xc4: WideInstructionParser, // wide
       0xc5: Parser.start()
         .uint16be("index")
         .uint8("dimensions")
@@ -1181,34 +1182,13 @@ const InstructionParser = Parser.start()
   });
 
 const BytecodeParser = Parser.start()
-  .useContextVars()
   .array("instructions", {
-    type: Parser.start().choice("instruction", {
-      tag: function () {
-        switch (
-          this.opcode // Access the "opcode" property of the current item
-        ) {
-          case 0xc4:
-            return 0; // WideInstructionParser
-          case 0xaa:
-            return 1; // TableswitchParser
-          case 0xab:
-            return 2; // LookupswitchParser
-          default:
-            return 3; // InstructionParser (default)
-        }
-      },
-      choices: [
-        // Use an array of choices (indexed numerically)
-        WideInstructionParser,
-        TableswitchParser,
-        LookupswitchParser,
-        InstructionParser,
-      ],
-    }),
-    lengthInBytes: function (item) {
-      return this.$parent.code_length;
-    },
+      type: Parser.start().nest("instruction", {
+          type: InstructionParser
+      }),
+      lengthInBytes: function() {
+        return this.$parent.code_length;
+      }
   });
 
 CodeAttribute = CodeAttribute.useContextVars()
@@ -1301,7 +1281,7 @@ const ClassFile = Parser.start()
     type: AttributeInfo,
     length: "attributes_count",
   });
-  module.exports= {
+module.exports= {
     CodeAttribute,
     ConstantClassInfo,
     ConstantFieldrefInfo,