Refactored floating point p-handlers with consistent naming convention

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FaddpStiStHandler.cs

@@ -3,15 +3,15 @@ namespace X86Disassembler.X86.Handlers.FloatingPoint.Arithmetic;
 using X86Disassembler.X86.Operands;
 
 /// <summary>
-/// Handler for FADD ST(i), ST(0) instruction (DC C0-C7)
+/// Handler for FADDP ST(i), ST instruction (DE C0-C7)
 /// </summary>
-public class FaddRegisterHandler : InstructionHandler
+public class FaddpStiStHandler : InstructionHandler
 {
     /// <summary>
-    /// Initializes a new instance of the FaddRegisterHandler class
+    /// Initializes a new instance of the FaddpStiStHandler class
     /// </summary>
     /// <param name="decoder">The instruction decoder that owns this handler</param>
-    public FaddRegisterHandler(InstructionDecoder decoder)
+    public FaddpStiStHandler(InstructionDecoder decoder)
         : base(decoder)
     {
     }
@@ -23,25 +23,23 @@ public class FaddRegisterHandler : InstructionHandler
     /// <returns>True if this handler can decode the opcode</returns>
     public override bool CanHandle(byte opcode)
     {
-        // FADD ST(i), ST(0) is DC C0-C7
-        if (opcode != 0xDC) return false;
+        // FADDP ST(i), ST is DE C0-C7
+        if (opcode != 0xDE) return false;
 
         if (!Decoder.CanReadByte())
         {
             return false;
         }
 
-        // Check if the ModR/M byte has reg field = 0 and mod = 3
-        byte modRm = Decoder.PeakByte();
-        byte reg = (byte)((modRm >> 3) & 0x7);
-        byte mod = (byte)((modRm >> 6) & 0x3);
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
         
-        // Only handle register operands (mod = 3) with reg = 0
-        return reg == 0 && mod == 3;
+        // Only handle C0-C7
+        return secondOpcode is >= 0xC0 and <= 0xC7;
     }
     
     /// <summary>
-    /// Decodes a FADD ST(i), ST(0) instruction
+    /// Decodes a FADDP ST(i), ST instruction
     /// </summary>
     /// <param name="opcode">The opcode of the instruction</param>
     /// <param name="instruction">The instruction object to populate</param>
@@ -53,25 +51,11 @@ public class FaddRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Read the ModR/M byte
-        var (mod, reg, rm, _) = ModRMDecoder.ReadModRM();
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xC0);
         
         // Set the instruction type
-        instruction.Type = InstructionType.Fadd;
-
-        // Map rm field to FPU register index
-        FpuRegisterIndex stIndex = rm switch
-        {
-            RegisterIndex.A => FpuRegisterIndex.ST0,
-            RegisterIndex.C => FpuRegisterIndex.ST1,
-            RegisterIndex.D => FpuRegisterIndex.ST2,
-            RegisterIndex.B => FpuRegisterIndex.ST3,
-            RegisterIndex.Sp => FpuRegisterIndex.ST4,
-            RegisterIndex.Bp => FpuRegisterIndex.ST5,
-            RegisterIndex.Si => FpuRegisterIndex.ST6,
-            RegisterIndex.Di => FpuRegisterIndex.ST7,
-            _ => FpuRegisterIndex.ST0 // Default case, should not happen
-        };
+        instruction.Type = InstructionType.Faddp;
         
         // Create the FPU register operands
         var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FdivRegisterHandler.cs

@@ -31,13 +31,11 @@ public class FdivRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Check if the ModR/M byte has reg field = 6 and mod = 3
-        byte modRm = Decoder.PeakByte();
-        byte reg = (byte)((modRm >> 3) & 0x7);
-        byte mod = (byte)((modRm >> 6) & 0x3);
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
         
-        // Only handle register operands (mod = 3) with reg = 6
-        return reg == 6 && mod == 3;
+        // Only handle F0-F7
+        return secondOpcode is >= 0xF0 and <= 0xF7;
     }
     
     /// <summary>
@@ -53,25 +51,11 @@ public class FdivRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Read the ModR/M byte
-        var (mod, reg, rm, _) = ModRMDecoder.ReadModRM();
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xF0);
         
         // Set the instruction type
         instruction.Type = InstructionType.Fdiv;
-
-        // Map rm field to FPU register index
-        FpuRegisterIndex stIndex = rm switch
-        {
-            RegisterIndex.A => FpuRegisterIndex.ST0,
-            RegisterIndex.C => FpuRegisterIndex.ST1,
-            RegisterIndex.D => FpuRegisterIndex.ST2,
-            RegisterIndex.B => FpuRegisterIndex.ST3,
-            RegisterIndex.Sp => FpuRegisterIndex.ST4,
-            RegisterIndex.Bp => FpuRegisterIndex.ST5,
-            RegisterIndex.Si => FpuRegisterIndex.ST6,
-            RegisterIndex.Di => FpuRegisterIndex.ST7,
-            _ => FpuRegisterIndex.ST0 // Default case, should not happen
-        };
         
         // Create the FPU register operands
         var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FdivpStiStHandler.cs

@@ -0,0 +1,73 @@
+namespace X86Disassembler.X86.Handlers.FloatingPoint.Arithmetic;
+
+using X86Disassembler.X86.Operands;
+
+/// <summary>
+/// Handler for FDIVP ST(i), ST instruction (DE F0-F7)
+/// </summary>
+public class FdivpStiStHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the FdivpStiStHandler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public FdivpStiStHandler(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)
+    {
+        // FDIVP ST(i), ST is DE F0-F7
+        if (opcode != 0xDE) return false;
+
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
+        
+        // Only handle F0-F7
+        return secondOpcode is >= 0xF0 and <= 0xF7;
+    }
+    
+    /// <summary>
+    /// Decodes a FDIVP ST(i), ST 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)
+    {
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xF0);
+        
+        // Set the instruction type
+        instruction.Type = InstructionType.Fdivp;
+        
+        // Create the FPU register operands
+        var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);
+        var st0Operand = OperandFactory.CreateFPURegisterOperand(FpuRegisterIndex.ST0);
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            stiOperand,
+            st0Operand
+        ];
+
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FdivrRegisterHandler.cs

@@ -31,13 +31,11 @@ public class FdivrRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Check if the ModR/M byte has reg field = 7 and mod = 3
-        byte modRm = Decoder.PeakByte();
-        byte reg = (byte)((modRm >> 3) & 0x7);
-        byte mod = (byte)((modRm >> 6) & 0x3);
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
         
-        // Only handle register operands (mod = 3) with reg = 7
-        return reg == 7 && mod == 3;
+        // Only handle F8-FF
+        return secondOpcode is >= 0xF8 and <= 0xFF;
     }
     
     /// <summary>
@@ -53,25 +51,11 @@ public class FdivrRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Read the ModR/M byte
-        var (mod, reg, rm, _) = ModRMDecoder.ReadModRM();
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xF8);
         
         // Set the instruction type
         instruction.Type = InstructionType.Fdivr;
-
-        // Map rm field to FPU register index
-        FpuRegisterIndex stIndex = rm switch
-        {
-            RegisterIndex.A => FpuRegisterIndex.ST0,
-            RegisterIndex.C => FpuRegisterIndex.ST1,
-            RegisterIndex.D => FpuRegisterIndex.ST2,
-            RegisterIndex.B => FpuRegisterIndex.ST3,
-            RegisterIndex.Sp => FpuRegisterIndex.ST4,
-            RegisterIndex.Bp => FpuRegisterIndex.ST5,
-            RegisterIndex.Si => FpuRegisterIndex.ST6,
-            RegisterIndex.Di => FpuRegisterIndex.ST7,
-            _ => FpuRegisterIndex.ST0 // Default case, should not happen
-        };
         
         // Create the FPU register operands
         var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FdivrpStiStHandler.cs

@@ -0,0 +1,73 @@
+namespace X86Disassembler.X86.Handlers.FloatingPoint.Arithmetic;
+
+using X86Disassembler.X86.Operands;
+
+/// <summary>
+/// Handler for FDIVRP ST(i), ST instruction (DE F8-FF)
+/// </summary>
+public class FdivrpStiStHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the FdivrpStiStHandler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public FdivrpStiStHandler(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)
+    {
+        // FDIVRP ST(i), ST is DE F8-FF
+        if (opcode != 0xDE) return false;
+
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
+        
+        // Only handle F8-FF
+        return secondOpcode is >= 0xF8 and <= 0xFF;
+    }
+    
+    /// <summary>
+    /// Decodes a FDIVRP ST(i), ST 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)
+    {
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xF8);
+        
+        // Set the instruction type
+        instruction.Type = InstructionType.Fdivrp;
+        
+        // Create the FPU register operands
+        var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);
+        var st0Operand = OperandFactory.CreateFPURegisterOperand(FpuRegisterIndex.ST0);
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            stiOperand,
+            st0Operand
+        ];
+
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FmulRegisterHandler.cs

@@ -31,13 +31,11 @@ public class FmulRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Check if the ModR/M byte has reg field = 1 and mod = 3
-        byte modRm = Decoder.PeakByte();
-        byte reg = (byte)((modRm >> 3) & 0x7);
-        byte mod = (byte)((modRm >> 6) & 0x3);
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
         
-        // Only handle register operands (mod = 3) with reg = 1
-        return reg == 1 && mod == 3;
+        // Only handle C8-CF
+        return secondOpcode is >= 0xC8 and <= 0xCF;
     }
     
     /// <summary>
@@ -53,25 +51,11 @@ public class FmulRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Read the ModR/M byte
-        var (mod, reg, rm, _) = ModRMDecoder.ReadModRM();
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xC8);
         
         // Set the instruction type
         instruction.Type = InstructionType.Fmul;
-
-        // Map rm field to FPU register index
-        FpuRegisterIndex stIndex = rm switch
-        {
-            RegisterIndex.A => FpuRegisterIndex.ST0,
-            RegisterIndex.C => FpuRegisterIndex.ST1,
-            RegisterIndex.D => FpuRegisterIndex.ST2,
-            RegisterIndex.B => FpuRegisterIndex.ST3,
-            RegisterIndex.Sp => FpuRegisterIndex.ST4,
-            RegisterIndex.Bp => FpuRegisterIndex.ST5,
-            RegisterIndex.Si => FpuRegisterIndex.ST6,
-            RegisterIndex.Di => FpuRegisterIndex.ST7,
-            _ => FpuRegisterIndex.ST0 // Default case, should not happen
-        };
         
         // Create the FPU register operands
         var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FmulpStiStHandler.cs

@@ -0,0 +1,73 @@
+namespace X86Disassembler.X86.Handlers.FloatingPoint.Arithmetic;
+
+using X86Disassembler.X86.Operands;
+
+/// <summary>
+/// Handler for FMULP ST(i), ST instruction (DE C8-CF)
+/// </summary>
+public class FmulpStiStHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the FmulpStiStHandler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public FmulpStiStHandler(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)
+    {
+        // FMULP ST(i), ST is DE C8-CF
+        if (opcode != 0xDE) return false;
+
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
+        
+        // Only handle C8-CF
+        return secondOpcode is >= 0xC8 and <= 0xCF;
+    }
+    
+    /// <summary>
+    /// Decodes a FMULP ST(i), ST 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)
+    {
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xC8);
+        
+        // Set the instruction type
+        instruction.Type = InstructionType.Fmulp;
+        
+        // Create the FPU register operands
+        var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);
+        var st0Operand = OperandFactory.CreateFPURegisterOperand(FpuRegisterIndex.ST0);
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            stiOperand,
+            st0Operand
+        ];
+
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FsubRegisterHandler.cs

@@ -31,13 +31,11 @@ public class FsubRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Check if the ModR/M byte has reg field = 4 and mod = 3
-        byte modRm = Decoder.PeakByte();
-        byte reg = (byte)((modRm >> 3) & 0x7);
-        byte mod = (byte)((modRm >> 6) & 0x3);
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
         
-        // Only handle register operands (mod = 3) with reg = 4
-        return reg == 4 && mod == 3;
+        // Only handle E0-E7
+        return secondOpcode is >= 0xE0 and <= 0xE7;
     }
     
     /// <summary>
@@ -53,25 +51,11 @@ public class FsubRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Read the ModR/M byte
-        var (mod, reg, rm, _) = ModRMDecoder.ReadModRM();
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xE0);
         
         // Set the instruction type
         instruction.Type = InstructionType.Fsub;
-
-        // Map rm field to FPU register index
-        FpuRegisterIndex stIndex = rm switch
-        {
-            RegisterIndex.A => FpuRegisterIndex.ST0,
-            RegisterIndex.C => FpuRegisterIndex.ST1,
-            RegisterIndex.D => FpuRegisterIndex.ST2,
-            RegisterIndex.B => FpuRegisterIndex.ST3,
-            RegisterIndex.Sp => FpuRegisterIndex.ST4,
-            RegisterIndex.Bp => FpuRegisterIndex.ST5,
-            RegisterIndex.Si => FpuRegisterIndex.ST6,
-            RegisterIndex.Di => FpuRegisterIndex.ST7,
-            _ => FpuRegisterIndex.ST0 // Default case, should not happen
-        };
         
         // Create the FPU register operands
         var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FsubpStiStHandler.cs

@@ -0,0 +1,73 @@
+namespace X86Disassembler.X86.Handlers.FloatingPoint.Arithmetic;
+
+using X86Disassembler.X86.Operands;
+
+/// <summary>
+/// Handler for FSUBP ST(i), ST instruction (DE E0-E7)
+/// </summary>
+public class FsubpStiStHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the FsubpStiStHandler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public FsubpStiStHandler(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)
+    {
+        // FSUBP ST(i), ST is DE E0-E7
+        if (opcode != 0xDE) return false;
+
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
+        
+        // Only handle E0-E7
+        return secondOpcode is >= 0xE0 and <= 0xE7;
+    }
+    
+    /// <summary>
+    /// Decodes a FSUBP ST(i), ST 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)
+    {
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xE0);
+        
+        // Set the instruction type
+        instruction.Type = InstructionType.Fsubp;
+        
+        // Create the FPU register operands
+        var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);
+        var st0Operand = OperandFactory.CreateFPURegisterOperand(FpuRegisterIndex.ST0);
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            stiOperand,
+            st0Operand
+        ];
+
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FsubrRegisterHandler.cs

@@ -31,13 +31,11 @@ public class FsubrRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Check if the ModR/M byte has reg field = 5 and mod = 3
-        byte modRm = Decoder.PeakByte();
-        byte reg = (byte)((modRm >> 3) & 0x7);
-        byte mod = (byte)((modRm >> 6) & 0x3);
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
         
-        // Only handle register operands (mod = 3) with reg = 5
-        return reg == 5 && mod == 3;
+        // Only handle E8-EF
+        return secondOpcode is >= 0xE8 and <= 0xEF;
     }
     
     /// <summary>
@@ -53,25 +51,11 @@ public class FsubrRegisterHandler : InstructionHandler
             return false;
         }
 
-        // Read the ModR/M byte
-        var (mod, reg, rm, _) = ModRMDecoder.ReadModRM();
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xE8);
         
         // Set the instruction type
         instruction.Type = InstructionType.Fsubr;
-
-        // Map rm field to FPU register index
-        FpuRegisterIndex stIndex = rm switch
-        {
-            RegisterIndex.A => FpuRegisterIndex.ST0,
-            RegisterIndex.C => FpuRegisterIndex.ST1,
-            RegisterIndex.D => FpuRegisterIndex.ST2,
-            RegisterIndex.B => FpuRegisterIndex.ST3,
-            RegisterIndex.Sp => FpuRegisterIndex.ST4,
-            RegisterIndex.Bp => FpuRegisterIndex.ST5,
-            RegisterIndex.Si => FpuRegisterIndex.ST6,
-            RegisterIndex.Di => FpuRegisterIndex.ST7,
-            _ => FpuRegisterIndex.ST0 // Default case, should not happen
-        };
         
         // Create the FPU register operands
         var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);

X86Disassembler/X86/Handlers/FloatingPoint/Arithmetic/FsubrpStiStHandler.cs

@@ -0,0 +1,73 @@
+namespace X86Disassembler.X86.Handlers.FloatingPoint.Arithmetic;
+
+using X86Disassembler.X86.Operands;
+
+/// <summary>
+/// Handler for FSUBRP ST(i), ST instruction (DE E8-EF)
+/// </summary>
+public class FsubrpStiStHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the FsubrpStiStHandler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public FsubrpStiStHandler(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)
+    {
+        // FSUBRP ST(i), ST is DE E8-EF
+        if (opcode != 0xDE) return false;
+
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Check second opcode byte
+        byte secondOpcode = Decoder.PeakByte();
+        
+        // Only handle E8-EF
+        return secondOpcode is >= 0xE8 and <= 0xEF;
+    }
+    
+    /// <summary>
+    /// Decodes a FSUBRP ST(i), ST 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)
+    {
+        if (!Decoder.CanReadByte())
+        {
+            return false;
+        }
+
+        // Read the ModR/M byte and calculate ST(i) index
+        var stIndex = (FpuRegisterIndex)(Decoder.ReadByte() - 0xE8);
+        
+        // Set the instruction type
+        instruction.Type = InstructionType.Fsubrp;
+        
+        // Create the FPU register operands
+        var stiOperand = OperandFactory.CreateFPURegisterOperand(stIndex);
+        var st0Operand = OperandFactory.CreateFPURegisterOperand(FpuRegisterIndex.ST0);
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            stiOperand,
+            st0Operand
+        ];
+
+        return true;
+    }
+}