Implement separate FSTSW handlers and fix test encodings

X86Disassembler/X86/Handlers/FloatingPoint/Control/FstswHandler.cs

@@ -3,10 +3,7 @@ using X86Disassembler.X86.Operands;
 namespace X86Disassembler.X86.Handlers.FloatingPoint.Control;
 
 /// <summary>
-/// Handler for FSTSW instruction (with WAIT prefix 0x9B)
-/// Handles both:
-/// - FSTSW AX (0x9B 0xDF 0xE0)
-/// - FSTSW m2byte (0x9B 0xDD /7)
+/// Handler for FSTSW AX instruction (0x9B 0xDF 0xE0) - Store FPU status word with wait prefix to AX register
 /// </summary>
 public class FstswHandler : InstructionHandler
 {
@@ -26,38 +23,22 @@ public class FstswHandler : InstructionHandler
     /// <returns>True if this handler can decode the opcode</returns>
     public override bool CanHandle(byte opcode)
     {
-        // FSTSW starts with the WAIT prefix (0x9B)
+        // FSTSW AX starts with the WAIT prefix (0x9B)
         if (opcode != 0x9B) return false;
 
-        // Check if we can read the next byte
+        // Check if we can read the next two bytes
         if (!Decoder.CanReadByte())
             return false;
 
-        // Check if the next byte is 0xDF (for FSTSW AX) or 0xDD (for FSTSW m2byte)
+        // Check if the next bytes are 0xDF 0xE0 (for FSTSW AX)
+        var (nextByte, thirdByte) = Decoder.PeakTwoBytes();
 
-        var (nextByte, modRM) = Decoder.PeakTwoBytes();
-
-        if (nextByte != 0xDF && nextByte != 0xDD)
-            return false;
-
-        if (nextByte == 0xDF)
-        {
-            // For FSTSW AX, check if we can peek at the third byte and it's 0xE0
-
-            return modRM == 0xE0;
-        }
-        else // nextByte == 0xDD
-        {
-            // For FSTSW m2byte, check if we can peek at ModR/M byte and reg field = 7
-            byte regField = ModRMDecoder.GetRegFromModRM(modRM);
-            
-            // The reg field must be 7 for FSTSW m2byte
-            return regField == 7;
-        }
+        // The sequence must be 9B DF E0 for FSTSW AX
+        return nextByte == 0xDF && thirdByte == 0xE0;
     }
     
     /// <summary>
-    /// Decodes an FSTSW instruction
+    /// Decodes an FSTSW AX instruction
     /// </summary>
     /// <param name="opcode">The opcode of the instruction</param>
     /// <param name="instruction">The instruction object to populate</param>
@@ -68,48 +49,30 @@ public class FstswHandler : InstructionHandler
         if (!Decoder.CanReadByte())
             return false;
 
-        // Read the second byte (0xDF for AX variant, 0xDD for memory variant)
+        // Read the second byte (0xDF)
         byte secondByte = Decoder.ReadByte();
+        if (secondByte != 0xDF)
+            return false;
+            
+        // Read the third byte (0xE0)
+        if (!Decoder.CanReadByte())
+            return false;
+
+        byte thirdByte = Decoder.ReadByte();
+        if (thirdByte != 0xE0)
+            return false;
         
         // Set the instruction type
         instruction.Type = InstructionType.Fstsw;
-
-        if (secondByte == 0xDF)
-        {
-            // FSTSW AX variant
-            // Read the 0xE0 byte
-            if (!Decoder.CanReadByte())
-                return false;
-
-            byte e0Byte = Decoder.ReadByte();
-            if (e0Byte != 0xE0)
-                return false;
-            
-            // Create the AX register operand
-            var axOperand = OperandFactory.CreateRegisterOperand(RegisterIndex.A, 16);
-            
-            // Set the structured operands
-            instruction.StructuredOperands = 
-            [
-                axOperand
-            ];
-        }
-        else if (secondByte == 0xDD)
-        {
-            // FSTSW m2byte variant
-            // Use ModRMDecoder to read and decode the ModR/M byte for 16-bit memory operand
-            var (mod, reg, rm, memoryOperand) = ModRMDecoder.ReadModRM16();
-                
-            // Set the structured operands
-            instruction.StructuredOperands = 
-            [
-                memoryOperand
-            ];
-        }
-        else
-        {
-            return false;
-        }
+        
+        // Create the AX register operand
+        var axOperand = OperandFactory.CreateRegisterOperand(RegisterIndex.A, 16);
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            axOperand
+        ];
         
         return true;
     }

X86Disassembler/X86/Handlers/FloatingPoint/Control/FstswMemHandler.cs

@@ -0,0 +1,78 @@
+using X86Disassembler.X86.Operands;
+
+namespace X86Disassembler.X86.Handlers.FloatingPoint.Control;
+
+/// <summary>
+/// Handler for FSTSW m2byte instruction (0x9B 0xDD /7) - Store FPU status word with wait prefix to memory
+/// </summary>
+public class FstswMemHandler : InstructionHandler
+{
+    /// <summary>
+    /// Initializes a new instance of the FstswMemHandler class
+    /// </summary>
+    /// <param name="decoder">The instruction decoder that owns this handler</param>
+    public FstswMemHandler(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)
+    {
+        // FSTSW m2byte starts with the WAIT prefix (0x9B)
+        if (opcode != 0x9B) return false;
+
+        // Check if we can read the next two bytes
+        if (!Decoder.CanReadByte())
+            return false;
+
+        // Check if the next bytes are 0xDD followed by ModR/M with reg field = 7
+        var (nextByte, modRM) = Decoder.PeakTwoBytes();
+
+        // The first byte must be 0xDD for FSTSW m2byte
+        if (nextByte != 0xDD)
+            return false;
+            
+        // Check if ModR/M byte has reg field = 7
+        byte regField = ModRMDecoder.GetRegFromModRM(modRM);
+        
+        // The reg field must be 7 for FSTSW m2byte
+        return regField == 7;
+    }
+    
+    /// <summary>
+    /// Decodes an FSTSW m2byte 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)
+    {
+        // Skip the WAIT prefix (0x9B) - we already read it in CanHandle
+        if (!Decoder.CanReadByte())
+            return false;
+
+        // Read the second byte (0xDD)
+        byte secondByte = Decoder.ReadByte();
+        if (secondByte != 0xDD)
+            return false;
+            
+        // Set the instruction type
+        instruction.Type = InstructionType.Fstsw;
+        
+        // Use ModRMDecoder to read and decode the ModR/M byte for 16-bit memory operand
+        var (mod, reg, rm, memoryOperand) = ModRMDecoder.ReadModRM16();
+        
+        // Set the structured operands
+        instruction.StructuredOperands = 
+        [
+            memoryOperand
+        ];
+        
+        return true;
+    }
+}

X86Disassembler/X86/Handlers/InstructionHandlerFactory.cs

@@ -419,6 +419,7 @@ public class InstructionHandlerFactory
         // Other floating point handlers
         _handlers.Add(new FloatingPoint.Control.FnstswHandler(_decoder));         // FNSTSW AX (DF E0)
         _handlers.Add(new FloatingPoint.Control.FstswHandler(_decoder));           // FSTSW AX (9B DF E0)
+        _handlers.Add(new FloatingPoint.Control.FstswMemHandler(_decoder));        // FSTSW m2byte (9B DD /7)
         
         // DB opcode handlers (int32 operations and extended precision)
         _handlers.Add(new FloatingPoint.LoadStore.FildInt32Handler(_decoder));     // FILD int32 (DB /0)