mirrors/ParkanPlayground
0
Fork 0
mirror of https://github.com/sampletext32/ParkanPlayground.git synced 2025-05-18 19:31:17 +03:00
Code Issues Releases Activity

Standardize FPU instruction handler naming convention

Browse Source
This commit is contained in:
bird_egop 2025-04-18 13:19:28 +03:00
parent fea700596c
commit adb37fe84f
4 changed files with 90 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
X86Disassembler/X86/Handlers/FloatingPoint/Control/FclexHandler.cs
View File

@ -1,9 +1,7 @@
namespace X86Disassembler.X86.Handlers.FloatingPoint.Control;
using X86Disassembler.X86.Operands;
/// <summary>
/// Handler for FNCLEX instruction (0xDB 0xE2) - Clears floating-point exception flags without checking for pending unmasked exceptions
/// Handler for FCLEX instruction with WAIT prefix (0x9B 0xDB 0xE2) - Clears floating-point exception flags after checking for pending unmasked floating-point exceptions
/// </summary>
public class FclexHandler : InstructionHandler
{
@ -23,41 +21,51 @@ public class FclexHandler : InstructionHandler
/// <returns>True if this handler can decode the opcode</returns>
public override bool CanHandle(byte opcode)
{
// FCLEX is DB E2
if (opcode != 0xDB) return false;
// FCLEX with WAIT prefix starts with 0x9B
if (opcode != 0x9B) return false;
// Check if we can read the next two bytes
if (!Decoder.CanReadByte())
{
return false;
}
// Check if the next byte is E2
byte nextByte = Decoder.PeakByte();
return nextByte == 0xE2;
// Check if the next bytes are 0xDB 0xE2 (for FCLEX with WAIT)
var (nextByte, thirdByte) = Decoder.PeakTwoBytes();
// The sequence must be 9B DB E2 for FCLEX with WAIT
return nextByte == 0xDB && thirdByte == 0xE2;
}
/// <summary>
/// Decodes a FCLEX instruction
/// Decodes a FCLEX instruction with WAIT prefix
/// </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 of the opcode
// Read the second byte (0xDB)
byte secondByte = Decoder.ReadByte();
if (secondByte != 0xDB)
return false;
// Read the third byte (0xE2)
if (!Decoder.CanReadByte())
return false;
byte thirdByte = Decoder.ReadByte();
if (thirdByte != 0xE2)
return false;
// Set the instruction type
instruction.Type = InstructionType.Fnclex;
instruction.Type = InstructionType.Fclex;
// FCLEX has no operands
instruction.StructuredOperands = [];
return true;
}
}

71
X86Disassembler/X86/Handlers/FloatingPoint/Control/FclexWaitHandler.cs
View File

@ -1,71 +0,0 @@
namespace X86Disassembler.X86.Handlers.FloatingPoint.Control;
/// <summary>
/// Handler for FCLEX instruction with WAIT prefix (0x9B 0xDB 0xE2) - Clears floating-point exception flags after checking for pending unmasked floating-point exceptions
/// </summary>
public class FclexWaitHandler : InstructionHandler
{
/// <summary>
/// Initializes a new instance of the FclexWaitHandler class
/// </summary>
/// <param name="decoder">The instruction decoder that owns this handler</param>
public FclexWaitHandler(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)
{
// FCLEX with WAIT prefix starts with 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 0xDB 0xE2 (for FCLEX with WAIT)
var (nextByte, thirdByte) = Decoder.PeakTwoBytes();
// The sequence must be 9B DB E2 for FCLEX with WAIT
return nextByte == 0xDB && thirdByte == 0xE2;
}
/// <summary>
/// Decodes a FCLEX instruction with WAIT prefix
/// </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 (0xDB)
byte secondByte = Decoder.ReadByte();
if (secondByte != 0xDB)
return false;
// Read the third byte (0xE2)
if (!Decoder.CanReadByte())
return false;
byte thirdByte = Decoder.ReadByte();
if (thirdByte != 0xE2)
return false;
// Set the instruction type
instruction.Type = InstructionType.Fclex;
// FCLEX has no operands
instruction.StructuredOperands = [];
return true;
}
}

63
X86Disassembler/X86/Handlers/FloatingPoint/Control/FnclexHandler.cs Normal file
View File

@ -0,0 +1,63 @@
namespace X86Disassembler.X86.Handlers.FloatingPoint.Control;
using X86Disassembler.X86.Operands;
/// <summary>
/// Handler for FNCLEX instruction (0xDB 0xE2) - Clears floating-point exception flags without checking for pending unmasked exceptions
/// </summary>
public class FnclexHandler : InstructionHandler
{
/// <summary>
/// Initializes a new instance of the FnclexHandler class
/// </summary>
/// <param name="decoder">The instruction decoder that owns this handler</param>
public FnclexHandler(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)
{
// FNCLEX is DB E2
if (opcode != 0xDB) return false;
if (!Decoder.CanReadByte())
{
return false;
}
// Check if the next byte is E2
byte nextByte = Decoder.PeakByte();
return nextByte == 0xE2;
}
/// <summary>
/// Decodes a FNCLEX 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 second byte of the opcode
byte secondByte = Decoder.ReadByte();
// Set the instruction type
instruction.Type = InstructionType.Fnclex;
// FCLEX has no operands
instruction.StructuredOperands = [];
return true;
}
}

4
X86Disassembler/X86/Handlers/InstructionHandlerFactory.cs
View File

@ -435,8 +435,8 @@ public class InstructionHandlerFactory
_handlers.Add(new FloatingPoint.Conditional.FcmovnuHandler(_decoder)); // FCMOVNU (DB D8-DF)
// DB opcode handlers (control instructions)
_handlers.Add(new FloatingPoint.Control.FclexHandler(_decoder)); // FNCLEX (DB E2)
_handlers.Add(new FloatingPoint.Control.FclexWaitHandler(_decoder)); // FCLEX (9B DB E2)
_handlers.Add(new FloatingPoint.Control.FnclexHandler(_decoder)); // FNCLEX (DB E2)
_handlers.Add(new FloatingPoint.Control.FclexHandler(_decoder)); // FCLEX (9B DB E2)
_handlers.Add(new FloatingPoint.Control.FninitHandler(_decoder)); // FNINIT (DB E3)
_handlers.Add(new FloatingPoint.Control.FinitHandler(_decoder)); // FINIT (9B DB E3)