Simplified instruction handlers for better maintainability and consistency. Fixed operand size handling in XOR handlers with 16-bit registers. Added support for 6-byte NOP variant. Fixed formatting of immediate values to maintain consistent output.

X86Disassembler/X86/Handlers/Add/AddEaxImmHandler.cs

@@ -34,56 +34,25 @@ public class AddEaxImmHandler : InstructionHandler
     /// <returns>True if the instruction was successfully decoded</returns>
     public override bool Decode(byte opcode, Instruction instruction)
     {
-        // Save the original position for raw bytes calculation
-        int startPosition = Decoder.GetPosition();
-        
         // Set the mnemonic
         instruction.Mnemonic = "add";
         
-        // Check if we have enough bytes for the immediate value
+        int position = Decoder.GetPosition();
-        if (startPosition + 4 > Length)
-        {
-            // Not enough bytes for the immediate value
-            instruction.Operands = "eax, ??";
-            
-            // Set the raw bytes to just the opcode
-            instruction.RawBytes = new byte[] { opcode };
-            
-            return true; // Still return true as we've set a valid mnemonic and operands
-        }
         
-        // Check for special cases where the immediate value might be part of another instruction
+        // Check if we have enough bytes for the immediate value
-        // For example, if the next byte is 0x83 (Group 1 sign-extended immediate)
+        if (position + 3 >= Length)
-        // or 0xEB (JMP rel8), it's likely the start of a new instruction
-        byte nextByte = CodeBuffer[startPosition];
-        if (nextByte == 0x83 || nextByte == 0xEB)
         {
-            // This is likely the start of a new instruction, not part of our immediate value
+            return false; // Not enough bytes for the immediate value
-            instruction.Operands = "eax, ??";
-            
-            // Set the raw bytes to just the opcode
-            instruction.RawBytes = new byte[] { opcode };
-            
-            return true;
         }
         
         // Read the 32-bit immediate value
         uint imm32 = Decoder.ReadUInt32();
         
-        // Set the operands
+        // Format the immediate value
-        instruction.Operands = $"eax, 0x{imm32:X8}";
+        string immStr = $"0x{imm32:X}";
         
-        // Set the raw bytes
+        // Set the operands
-        byte[] rawBytes = new byte[5]; // opcode + 4 bytes for immediate
+        instruction.Operands = $"eax, {immStr}";
-        rawBytes[0] = opcode;
-        for (int i = 0; i < 4; i++)
-        {
-            if (startPosition + i < Length)
-            {
-                rawBytes[i + 1] = CodeBuffer[startPosition + i];
-            }
-        }
-        instruction.RawBytes = rawBytes;
         
         return true;
     }

X86Disassembler/X86/Handlers/Add/AddImmToRm32SignExtendedHandler.cs

@@ -45,95 +45,32 @@ public class AddImmToRm32SignExtendedHandler : InstructionHandler
     /// <returns>True if the instruction was successfully decoded</returns>
     public override bool Decode(byte opcode, Instruction instruction)
     {
-        // Save the original position for raw bytes calculation
-        int startPosition = Decoder.GetPosition();
-        
         // Set the mnemonic
         instruction.Mnemonic = "add";
         
-        if (startPosition >= Length)
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
         {
-            instruction.Operands = "??";
+            return false;
-            instruction.RawBytes = new byte[] { opcode };
-            return true;
         }
         
         // Read the ModR/M byte
         var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM();
         
-        // Track the bytes needed for this instruction
-        int bytesNeeded = 1; // ModR/M byte
-        
-        // Process SIB byte if needed
-        byte sib = 0;
-        if (mod != 3 && rm == RegisterIndex.Si) // SIB byte present
-        {
-            if (startPosition + bytesNeeded >= Length)
-            {
-                instruction.Operands = "??";
-                instruction.RawBytes = new byte[] { opcode, CodeBuffer[startPosition] };
-                return true;
-            }
-            sib = CodeBuffer[startPosition + bytesNeeded];
-            bytesNeeded++; // SIB byte
-        }
-        
-        // Handle displacement
-        int dispSize = 0;
-        if (mod == 0 && rm == RegisterIndex.Di) // 32-bit displacement
-        {
-            dispSize = 4;
-        }
-        else if (mod == 1) // 8-bit displacement
-        {
-            dispSize = 1;
-        }
-        else if (mod == 2) // 32-bit displacement
-        {
-            dispSize = 4;
-        }
-        
-        // Check if we have enough bytes for the displacement
-        if (startPosition + bytesNeeded + dispSize >= Length)
-        {
-            instruction.Operands = "??";
-            instruction.RawBytes = new byte[] { opcode, CodeBuffer[startPosition] };
-            return true;
-        }
-        
-        bytesNeeded += dispSize; // Add displacement bytes
-        
-        // Set the decoder position to after the ModR/M byte
-        Decoder.SetPosition(startPosition + 1);
-
         // Get the position after decoding the ModR/M byte
-        int newPosition = Decoder.GetPosition();
+        position = Decoder.GetPosition();
         
-        // Read the immediate value
+        // Check if we have enough bytes for the immediate value
-        if (newPosition >= Length)
+        if (position >= Length)
         {
-            instruction.Operands = $"{destOperand}, ??";
+            return false;
-            
-            // Set raw bytes without the immediate
-            int partialBytes = newPosition - startPosition + 1; // +1 for opcode
-            byte[] partialRawBytes = new byte[partialBytes];
-            partialRawBytes[0] = opcode;
-            for (int i = 0; i < partialBytes - 1; i++)
-            {
-                if (startPosition + i < Length)
-                {
-                    partialRawBytes[i + 1] = CodeBuffer[startPosition + i];
-                }
-            }
-            instruction.RawBytes = partialRawBytes;
-            
-            return true;
         }
         
         // Read the immediate value as a signed byte and automatically sign-extend it to int
         int signExtendedImm = (sbyte)Decoder.ReadByte();
         
-        // Format the immediate value as a 32-bit hex value
+        // Format the immediate value
         string immStr;
         if (signExtendedImm < 0)
         {
@@ -142,26 +79,13 @@ public class AddImmToRm32SignExtendedHandler : InstructionHandler
         }
         else
         {
-            // For positive values, use the regular format
+            // For positive values, use the regular format with leading zeros
             immStr = $"0x{signExtendedImm:X8}";
         }
         
         // Set the operands
         instruction.Operands = $"{destOperand}, {immStr}";
         
-        // Set the raw bytes
-        int totalBytes = newPosition - startPosition + 1; // +1 for opcode
-        byte[] rawBytes = new byte[totalBytes];
-        rawBytes[0] = opcode;
-        for (int i = 0; i < totalBytes - 1; i++)
-        {
-            if (startPosition + i < Length)
-            {
-                rawBytes[i + 1] = CodeBuffer[startPosition + i];
-            }
-        }
-        instruction.RawBytes = rawBytes;
-        
         return true;
     }
 }