Fixed several instruction handling issues: 1) Added proper handling for zero displacements in memory operands, 2) Fixed large unsigned displacement values display, 3) Added CmpEaxImmHandler for CMP EAX, imm32 instruction, 4) Fixed JP and JNP conditional jump instruction types

X86Disassembler/X86/Handlers/Cmp/CmpAlImmHandler.cs

@@ -46,7 +46,7 @@ public class CmpAlImmHandler : InstructionHandler
         byte imm8 = Decoder.ReadByte();
 
         // Create the register operand for AL
-        var alOperand = OperandFactory.CreateRegisterOperand(RegisterIndex.A, 8);
+        var alOperand = OperandFactory.CreateRegisterOperand8(RegisterIndex8.AL);
         
         // Create the immediate operand
         var immOperand = OperandFactory.CreateImmediateOperand(imm8, 8);

X86Disassembler/X86/Handlers/Cmp/CmpEaxImmHandler.cs

@@ -0,0 +1,60 @@
+using X86Disassembler.X86.Operands;
+
+namespace X86Disassembler.X86.Handlers.Cmp;
+
+/// <summary>
+/// Handler for CMP EAX, imm32 instruction (opcode 3D)
+/// </summary>
+public class CmpEaxImmHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the CmpEaxImmHandler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public CmpEaxImmHandler(InstructionDecoder decoder)
+        : base(decoder)
+    {
+    }
+
+    /// <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)
+    {
+        // CMP EAX, imm32 is encoded as 3D
+        return opcode == 0x3D;
+    }
+
+    /// <summary>
+    /// Decodes a CMP EAX, 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 instruction type
+        instruction.Type = InstructionType.Cmp;
+
+        // Check if we have enough bytes for the immediate value
+        if (!Decoder.CanReadUInt())
+        {
+            return false;
+        }
+
+        // Read the immediate value
+        uint imm32 = Decoder.ReadUInt32();
+
+        // Set the structured operands
+        // CMP EAX, imm32 has two operands: EAX and the immediate value
+        instruction.StructuredOperands = 
+        [
+            OperandFactory.CreateRegisterOperand(RegisterIndex.A),
+            OperandFactory.CreateImmediateOperand(imm32)
+        ];
+
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/Cmp/CmpR8Rm8Handler.cs

@@ -0,0 +1,70 @@
+using X86Disassembler.X86.Operands;
+
+namespace X86Disassembler.X86.Handlers.Cmp;
+
+/// <summary>
+/// Handler for CMP r8, r/m8 instruction (0x3A)
+/// </summary>
+public class CmpR8Rm8Handler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the CmpR8Rm8Handler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public CmpR8Rm8Handler(InstructionDecoder decoder) 
+        : base(decoder)
+    {
+    }
+    
+    /// <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 != 0x3A)
+            return false;
+            
+        // Check if we can read the ModR/M byte
+        if (!Decoder.CanReadByte())
+            return false;
+        
+        return true;
+    }
+    
+    /// <summary>
+    /// Decodes a CMP r8, r/m8 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 instruction type
+        instruction.Type = InstructionType.Cmp;
+        
+        // Check if we have enough bytes for the ModR/M byte
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Read the ModR/M byte, specifying that we're dealing with 8-bit operands
+        var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM8();
+        
+        // Note: The operand size is already set to 8-bit by the ReadModRM8 method
+        
+        // Create the destination register operand using the 8-bit register type
+        var destinationOperand = OperandFactory.CreateRegisterOperand8(reg);
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            destinationOperand,
+            sourceOperand
+        ];
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/Cmp/CmpRm8R8Handler.cs

@@ -0,0 +1,70 @@
+using X86Disassembler.X86.Operands;
+
+namespace X86Disassembler.X86.Handlers.Cmp;
+
+/// <summary>
+/// Handler for CMP r/m8, r8 instruction (0x38)
+/// </summary>
+public class CmpRm8R8Handler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the CmpRm8R8Handler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public CmpRm8R8Handler(InstructionDecoder decoder) 
+        : base(decoder)
+    {
+    }
+    
+    /// <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 != 0x38)
+            return false;
+            
+        // Check if we can read the ModR/M byte
+        if (!Decoder.CanReadByte())
+            return false;
+        
+        return true;
+    }
+    
+    /// <summary>
+    /// Decodes a CMP r/m8, r8 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 instruction type
+        instruction.Type = InstructionType.Cmp;
+        
+        // Check if we have enough bytes for the ModR/M byte
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Read the ModR/M byte, specifying that we're dealing with 8-bit operands
+        var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM8();
+        
+        // Note: The operand size is already set to 8-bit by the ReadModRM8 method
+        
+        // Create the source register operand using the 8-bit register type
+        var sourceOperand = OperandFactory.CreateRegisterOperand8(reg);
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            destinationOperand,
+            sourceOperand
+        ];
+        
+        return true;
+    }
+}