Implemented individual handlers for Group1 and Group3 instructions

X86Disassembler/X86/Handlers/Group3/DivRm32Handler.cs

@@ -0,0 +1,75 @@
+namespace X86Disassembler.X86.Handlers.Group3;
+
+/// <summary>
+/// Handler for DIV r/m32 instruction (0xF7 /6)
+/// </summary>
+public class DivRm32Handler : Group3BaseHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the DivRm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public DivRm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0xF7)
+            return false;
+            
+        // Check if the reg field of the ModR/M byte is 6 (DIV)
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+            return false;
+            
+        byte modRM = CodeBuffer[position];
+        byte reg = (byte)((modRM & 0x38) >> 3);
+        
+        return reg == 6; // 6 = DIV
+    }
+    
+    /// <summary>
+    /// Decodes a DIV r/m32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "div";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        byte modRM = CodeBuffer[position++];
+        Decoder.SetPosition(position);
+        
+        // Extract the fields from the ModR/M byte
+        byte mod = (byte)((modRM & 0xC0) >> 6);
+        byte reg = (byte)((modRM & 0x38) >> 3); // Should be 6 for DIV
+        byte rm = (byte)(modRM & 0x07);
+        
+        // Decode the operand
+        string operand = _modRMDecoder.DecodeModRM(mod, rm, false);
+        
+        // Set the operands
+        instruction.Operands = operand;
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/Group3/Group3BaseHandler.cs

@@ -0,0 +1,44 @@
+namespace X86Disassembler.X86.Handlers.Group3;
+
+/// <summary>
+/// Base class for Group 3 instruction handlers (TEST, NOT, NEG, MUL, IMUL, DIV, IDIV)
+/// </summary>
+public abstract class Group3BaseHandler : InstructionHandler
+{
+    // ModR/M decoder
+    protected readonly ModRMDecoder _modRMDecoder;
+    
+    /// <summary>
+    /// Initializes a new instance of the Group3BaseHandler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    protected Group3BaseHandler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+        _modRMDecoder = new ModRMDecoder(codeBuffer, decoder, length);
+    }
+    
+    /// <summary>
+    /// Gets the 32-bit register name for the given register index
+    /// </summary>
+    /// <param name="reg">The register index</param>
+    /// <returns>The register name</returns>
+    protected static string GetRegister32(byte reg)
+    {
+        string[] registerNames = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi" };
+        return registerNames[reg & 0x07];
+    }
+    
+    /// <summary>
+    /// Gets the 8-bit register name for the given register index
+    /// </summary>
+    /// <param name="reg">The register index</param>
+    /// <returns>The register name</returns>
+    protected static string GetRegister8(byte reg)
+    {
+        string[] registerNames = { "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh" };
+        return registerNames[reg & 0x07];
+    }
+}

X86Disassembler/X86/Handlers/Group3/IdivRm32Handler.cs

@@ -0,0 +1,75 @@
+namespace X86Disassembler.X86.Handlers.Group3;
+
+/// <summary>
+/// Handler for IDIV r/m32 instruction (0xF7 /7)
+/// </summary>
+public class IdivRm32Handler : Group3BaseHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the IdivRm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public IdivRm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0xF7)
+            return false;
+            
+        // Check if the reg field of the ModR/M byte is 7 (IDIV)
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+            return false;
+            
+        byte modRM = CodeBuffer[position];
+        byte reg = (byte)((modRM & 0x38) >> 3);
+        
+        return reg == 7; // 7 = IDIV
+    }
+    
+    /// <summary>
+    /// Decodes an IDIV r/m32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "idiv";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        byte modRM = CodeBuffer[position++];
+        Decoder.SetPosition(position);
+        
+        // Extract the fields from the ModR/M byte
+        byte mod = (byte)((modRM & 0xC0) >> 6);
+        byte reg = (byte)((modRM & 0x38) >> 3); // Should be 7 for IDIV
+        byte rm = (byte)(modRM & 0x07);
+        
+        // Decode the operand
+        string operand = _modRMDecoder.DecodeModRM(mod, rm, false);
+        
+        // Set the operands
+        instruction.Operands = operand;
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/Group3/ImulRm32Handler.cs

@@ -0,0 +1,75 @@
+namespace X86Disassembler.X86.Handlers.Group3;
+
+/// <summary>
+/// Handler for IMUL r/m32 instruction (0xF7 /5)
+/// </summary>
+public class ImulRm32Handler : Group3BaseHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the ImulRm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public ImulRm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0xF7)
+            return false;
+            
+        // Check if the reg field of the ModR/M byte is 5 (IMUL)
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+            return false;
+            
+        byte modRM = CodeBuffer[position];
+        byte reg = (byte)((modRM & 0x38) >> 3);
+        
+        return reg == 5; // 5 = IMUL
+    }
+    
+    /// <summary>
+    /// Decodes an IMUL r/m32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "imul";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        byte modRM = CodeBuffer[position++];
+        Decoder.SetPosition(position);
+        
+        // Extract the fields from the ModR/M byte
+        byte mod = (byte)((modRM & 0xC0) >> 6);
+        byte reg = (byte)((modRM & 0x38) >> 3); // Should be 5 for IMUL
+        byte rm = (byte)(modRM & 0x07);
+        
+        // Decode the operand
+        string operand = _modRMDecoder.DecodeModRM(mod, rm, false);
+        
+        // Set the operands
+        instruction.Operands = operand;
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/Group3/MulRm32Handler.cs

@@ -0,0 +1,75 @@
+namespace X86Disassembler.X86.Handlers.Group3;
+
+/// <summary>
+/// Handler for MUL r/m32 instruction (0xF7 /4)
+/// </summary>
+public class MulRm32Handler : Group3BaseHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the MulRm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public MulRm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0xF7)
+            return false;
+            
+        // Check if the reg field of the ModR/M byte is 4 (MUL)
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+            return false;
+            
+        byte modRM = CodeBuffer[position];
+        byte reg = (byte)((modRM & 0x38) >> 3);
+        
+        return reg == 4; // 4 = MUL
+    }
+    
+    /// <summary>
+    /// Decodes a MUL r/m32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "mul";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        byte modRM = CodeBuffer[position++];
+        Decoder.SetPosition(position);
+        
+        // Extract the fields from the ModR/M byte
+        byte mod = (byte)((modRM & 0xC0) >> 6);
+        byte reg = (byte)((modRM & 0x38) >> 3); // Should be 4 for MUL
+        byte rm = (byte)(modRM & 0x07);
+        
+        // Decode the operand
+        string operand = _modRMDecoder.DecodeModRM(mod, rm, false);
+        
+        // Set the operands
+        instruction.Operands = operand;
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/Group3/NegRm32Handler.cs

@@ -0,0 +1,75 @@
+namespace X86Disassembler.X86.Handlers.Group3;
+
+/// <summary>
+/// Handler for NEG r/m32 instruction (0xF7 /3)
+/// </summary>
+public class NegRm32Handler : Group3BaseHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the NegRm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public NegRm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0xF7)
+            return false;
+            
+        // Check if the reg field of the ModR/M byte is 3 (NEG)
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+            return false;
+            
+        byte modRM = CodeBuffer[position];
+        byte reg = (byte)((modRM & 0x38) >> 3);
+        
+        return reg == 3; // 3 = NEG
+    }
+    
+    /// <summary>
+    /// Decodes a NEG r/m32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "neg";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        byte modRM = CodeBuffer[position++];
+        Decoder.SetPosition(position);
+        
+        // Extract the fields from the ModR/M byte
+        byte mod = (byte)((modRM & 0xC0) >> 6);
+        byte reg = (byte)((modRM & 0x38) >> 3); // Should be 3 for NEG
+        byte rm = (byte)(modRM & 0x07);
+        
+        // Decode the operand
+        string operand = _modRMDecoder.DecodeModRM(mod, rm, false);
+        
+        // Set the operands
+        instruction.Operands = operand;
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/Group3/NotRm32Handler.cs

@@ -0,0 +1,75 @@
+namespace X86Disassembler.X86.Handlers.Group3;
+
+/// <summary>
+/// Handler for NOT r/m32 instruction (0xF7 /2)
+/// </summary>
+public class NotRm32Handler : Group3BaseHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the NotRm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public NotRm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0xF7)
+            return false;
+            
+        // Check if the reg field of the ModR/M byte is 2 (NOT)
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+            return false;
+            
+        byte modRM = CodeBuffer[position];
+        byte reg = (byte)((modRM & 0x38) >> 3);
+        
+        return reg == 2; // 2 = NOT
+    }
+    
+    /// <summary>
+    /// Decodes a NOT r/m32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "not";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        byte modRM = CodeBuffer[position++];
+        Decoder.SetPosition(position);
+        
+        // Extract the fields from the ModR/M byte
+        byte mod = (byte)((modRM & 0xC0) >> 6);
+        byte reg = (byte)((modRM & 0x38) >> 3); // Should be 2 for NOT
+        byte rm = (byte)(modRM & 0x07);
+        
+        // Decode the operand
+        string operand = _modRMDecoder.DecodeModRM(mod, rm, false);
+        
+        // Set the operands
+        instruction.Operands = operand;
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/Group3/TestImmWithRm32Handler.cs

@@ -0,0 +1,84 @@
+namespace X86Disassembler.X86.Handlers.Group3;
+
+/// <summary>
+/// Handler for TEST r/m32, imm32 instruction (0xF7 /0)
+/// </summary>
+public class TestImmWithRm32Handler : Group3BaseHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the TestImmWithRm32Handler class
+    /// </summary>
+    /// <param name="codeBuffer">The buffer containing the code to decode</param>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    /// <param name="length">The length of the buffer</param>
+    public TestImmWithRm32Handler(byte[] codeBuffer, InstructionDecoder decoder, int length) 
+        : base(codeBuffer, decoder, length)
+    {
+    }
+    
+    /// <summary>
+    /// Checks if this handler can decode the given opcode
+    /// </summary>
+    /// <param name="opcode">The opcode to check</param>
+    /// <returns>True if this handler can decode the opcode</returns>
+    public override bool CanHandle(byte opcode)
+    {
+        if (opcode != 0xF7)
+            return false;
+            
+        // Check if the reg field of the ModR/M byte is 0 (TEST)
+        int position = Decoder.GetPosition();
+        if (position >= Length)
+            return false;
+            
+        byte modRM = CodeBuffer[position];
+        byte reg = (byte)((modRM & 0x38) >> 3);
+        
+        return reg == 0; // 0 = TEST
+    }
+    
+    /// <summary>
+    /// Decodes a TEST r/m32, imm32 instruction
+    /// </summary>
+    /// <param name="opcode">The opcode of the instruction</param>
+    /// <param name="instruction">The instruction object to populate</param>
+    /// <returns>True if the instruction was successfully decoded</returns>
+    public override bool Decode(byte opcode, Instruction instruction)
+    {
+        // Set the mnemonic
+        instruction.Mnemonic = "test";
+        
+        int position = Decoder.GetPosition();
+        
+        if (position >= Length)
+        {
+            return false;
+        }
+        
+        // Read the ModR/M byte
+        byte modRM = CodeBuffer[position++];
+        Decoder.SetPosition(position);
+        
+        // Extract the fields from the ModR/M byte
+        byte mod = (byte)((modRM & 0xC0) >> 6);
+        byte reg = (byte)((modRM & 0x38) >> 3); // Should be 0 for TEST
+        byte rm = (byte)(modRM & 0x07);
+        
+        // Decode the destination operand
+        string destOperand = _modRMDecoder.DecodeModRM(mod, rm, false);
+        
+        // Read the immediate value
+        if (position + 3 >= Length)
+        {
+            return false;
+        }
+        
+        uint imm32 = BitConverter.ToUInt32(CodeBuffer, position);
+        Decoder.SetPosition(position + 4);
+        
+        // Set the operands
+        instruction.Operands = $"{destOperand}, 0x{imm32:X8}";
+        
+        return true;
+    }
+}