mirror of
https://github.com/sampletext32/ParkanPlayground.git
synced 2025-06-20 08:18:36 +03:00
split float handlers
This commit is contained in:
bird_egop
@ -0,0 +1,83 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for floating-point operations on float32 (D8 opcode)
|
||||
/// </summary>
|
||||
public class Float32OperationHandler : FloatingPointBaseHandler
|
||||
{
|
||||
// D8 opcode - operations on float32
|
||||
private static readonly string[] Mnemonics =
|
||||
[
|
||||
"fadd",
|
||||
"fmul",
|
||||
"fcom",
|
||||
"fcomp",
|
||||
"fsub",
|
||||
"fsubr",
|
||||
"fdiv",
|
||||
"fdivr"
|
||||
];
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the Float32OperationHandler 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 Float32OperationHandler(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)
|
||||
{
|
||||
return opcode == 0xD8;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a floating-point instruction for float32 operations
|
||||
/// </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)
|
||||
{
|
||||
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);
|
||||
byte rm = (byte) (modRM & 0x07);
|
||||
|
||||
// Set the mnemonic based on the opcode and reg field
|
||||
instruction.Mnemonic = Mnemonics[reg];
|
||||
|
||||
// For memory operands, set the operand
|
||||
if (mod != 3) // Memory operand
|
||||
{
|
||||
string operand = ModRMDecoder.DecodeModRM(mod, rm, false);
|
||||
instruction.Operands = $"dword ptr {operand}";
|
||||
}
|
||||
else // Register operand (ST(i))
|
||||
{
|
||||
// For register operands, we need to handle the stack registers
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,83 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for floating-point operations on float64 (DC opcode)
|
||||
/// </summary>
|
||||
public class Float64OperationHandler : FloatingPointBaseHandler
|
||||
{
|
||||
// DC opcode - operations on float64
|
||||
private static readonly string[] Mnemonics =
|
||||
[
|
||||
"fadd",
|
||||
"fmul",
|
||||
"fcom",
|
||||
"fcomp",
|
||||
"fsub",
|
||||
"fsubr",
|
||||
"fdiv",
|
||||
"fdivr"
|
||||
];
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the Float64OperationHandler 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 Float64OperationHandler(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)
|
||||
{
|
||||
return opcode == 0xDC;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a floating-point instruction for float64 operations
|
||||
/// </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)
|
||||
{
|
||||
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);
|
||||
byte rm = (byte)(modRM & 0x07);
|
||||
|
||||
// Set the mnemonic based on the opcode and reg field
|
||||
instruction.Mnemonic = Mnemonics[reg];
|
||||
|
||||
// For memory operands, set the operand
|
||||
if (mod != 3) // Memory operand
|
||||
{
|
||||
string operand = ModRMDecoder.DecodeModRM(mod, rm, false);
|
||||
instruction.Operands = $"qword ptr {operand}";
|
||||
}
|
||||
else // Register operand (ST(i))
|
||||
{
|
||||
// For DC C0-DC FF, the operands are reversed: ST(i), ST(0)
|
||||
instruction.Operands = $"st({rm}), st(0)";
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Base class for floating-point instruction handlers
|
||||
/// </summary>
|
||||
public abstract class FloatingPointBaseHandler : InstructionHandler
|
||||
{
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the FloatingPointBaseHandler 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 FloatingPointBaseHandler(byte[] codeBuffer, InstructionDecoder decoder, int length)
|
||||
: base(codeBuffer, decoder, length)
|
||||
{
|
||||
}
|
||||
}
|
||||
63
X86Disassembler/X86/Handlers/FloatingPoint/FnstswHandler.cs
Normal file
63
X86Disassembler/X86/Handlers/FloatingPoint/FnstswHandler.cs
Normal file
@ -0,0 +1,63 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for FNSTSW instruction (0xDFE0)
|
||||
/// </summary>
|
||||
public class FnstswHandler : InstructionHandler
|
||||
{
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the FnstswHandler 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 FnstswHandler(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)
|
||||
{
|
||||
// FNSTSW is a two-byte opcode (0xDF 0xE0)
|
||||
if (opcode == 0xDF)
|
||||
{
|
||||
int position = Decoder.GetPosition();
|
||||
if (position < Length && CodeBuffer[position] == 0xE0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes an FNSTSW 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)
|
||||
{
|
||||
int position = Decoder.GetPosition();
|
||||
|
||||
if (position >= Length || CodeBuffer[position] != 0xE0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Skip the second byte of the opcode
|
||||
Decoder.SetPosition(position + 1);
|
||||
|
||||
// Set the mnemonic and operands
|
||||
instruction.Mnemonic = "fnstsw";
|
||||
instruction.Operands = "ax";
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,128 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for floating-point operations on int16 (DE opcode)
|
||||
/// </summary>
|
||||
public class Int16OperationHandler : FloatingPointBaseHandler
|
||||
{
|
||||
// DE opcode - operations on int16
|
||||
private static readonly string[] Mnemonics =
|
||||
[
|
||||
"fiadd",
|
||||
"fimul",
|
||||
"ficom",
|
||||
"ficomp",
|
||||
"fisub",
|
||||
"fisubr",
|
||||
"fidiv",
|
||||
"fidivr"
|
||||
];
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the Int16OperationHandler 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 Int16OperationHandler(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)
|
||||
{
|
||||
return opcode == 0xDE;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a floating-point instruction for int16 operations
|
||||
/// </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)
|
||||
{
|
||||
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);
|
||||
byte rm = (byte) (modRM & 0x07);
|
||||
|
||||
// Set the mnemonic based on the opcode and reg field
|
||||
instruction.Mnemonic = Mnemonics[reg];
|
||||
|
||||
// For memory operands, set the operand
|
||||
if (mod != 3) // Memory operand
|
||||
{
|
||||
string operand = ModRMDecoder.DecodeModRM(mod, rm, false);
|
||||
instruction.Operands = $"word ptr {operand}";
|
||||
}
|
||||
else // Register operand (ST(i))
|
||||
{
|
||||
// Special handling for register-register operations
|
||||
if (reg == 0) // FADDP
|
||||
{
|
||||
instruction.Mnemonic = "faddp";
|
||||
instruction.Operands = $"st({rm}), st(0)";
|
||||
}
|
||||
else if (reg == 1) // FMULP
|
||||
{
|
||||
instruction.Mnemonic = "fmulp";
|
||||
instruction.Operands = $"st({rm}), st(0)";
|
||||
}
|
||||
else if (reg == 2 && rm == 1) // FCOMP
|
||||
{
|
||||
instruction.Mnemonic = "fcomp";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
else if (reg == 3 && rm == 1) // FCOMPP
|
||||
{
|
||||
instruction.Mnemonic = "fcompp";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
else if (reg == 4) // FSUBP
|
||||
{
|
||||
instruction.Mnemonic = "fsubp";
|
||||
instruction.Operands = $"st({rm}), st(0)";
|
||||
}
|
||||
else if (reg == 5) // FSUBRP
|
||||
{
|
||||
instruction.Mnemonic = "fsubrp";
|
||||
instruction.Operands = $"st({rm}), st(0)";
|
||||
}
|
||||
else if (reg == 6) // FDIVP
|
||||
{
|
||||
instruction.Mnemonic = "fdivp";
|
||||
instruction.Operands = $"st({rm}), st(0)";
|
||||
}
|
||||
else if (reg == 7) // FDIVRP
|
||||
{
|
||||
instruction.Mnemonic = "fdivrp";
|
||||
instruction.Operands = $"st({rm}), st(0)";
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unknown instruction
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,113 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for floating-point operations on int32 (DA opcode)
|
||||
/// </summary>
|
||||
public class Int32OperationHandler : FloatingPointBaseHandler
|
||||
{
|
||||
// DA opcode - operations on int32
|
||||
private static readonly string[] Mnemonics =
|
||||
{
|
||||
"fiadd",
|
||||
"fimul",
|
||||
"ficom",
|
||||
"ficomp",
|
||||
"fisub",
|
||||
"fisubr",
|
||||
"fidiv",
|
||||
"fidivr",
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the Int32OperationHandler 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 Int32OperationHandler(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)
|
||||
{
|
||||
return opcode == 0xDA;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a floating-point instruction for int32 operations
|
||||
/// </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)
|
||||
{
|
||||
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);
|
||||
byte rm = (byte) (modRM & 0x07);
|
||||
|
||||
// Set the mnemonic based on the opcode and reg field
|
||||
instruction.Mnemonic = Mnemonics[reg];
|
||||
|
||||
// For memory operands, set the operand
|
||||
if (mod != 3) // Memory operand
|
||||
{
|
||||
string operand = ModRMDecoder.DecodeModRM(mod, rm, false);
|
||||
instruction.Operands = $"dword ptr {operand}";
|
||||
}
|
||||
else // Register operand (ST(i))
|
||||
{
|
||||
// Special handling for register-register operations
|
||||
if (reg == 0) // FCMOVB
|
||||
{
|
||||
instruction.Mnemonic = "fcmovb";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 1) // FCMOVE
|
||||
{
|
||||
instruction.Mnemonic = "fcmove";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 2) // FCMOVBE
|
||||
{
|
||||
instruction.Mnemonic = "fcmovbe";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 3) // FCMOVU
|
||||
{
|
||||
instruction.Mnemonic = "fcmovu";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 5 && rm == 1) // FUCOMPP
|
||||
{
|
||||
instruction.Mnemonic = "fucompp";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unknown instruction
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,213 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for floating-point load, store, and control operations (D9 opcode)
|
||||
/// </summary>
|
||||
public class LoadStoreControlHandler : FloatingPointBaseHandler
|
||||
{
|
||||
// D9 opcode - load, store, and control operations
|
||||
private static readonly string[] Mnemonics =
|
||||
[
|
||||
"fld",
|
||||
"??",
|
||||
"fst",
|
||||
"fstp",
|
||||
"fldenv",
|
||||
"fldcw",
|
||||
"fnstenv",
|
||||
"fnstcw"
|
||||
];
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the LoadStoreControlHandler 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 LoadStoreControlHandler(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)
|
||||
{
|
||||
return opcode == 0xD9;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a floating-point instruction for load, store, and control operations
|
||||
/// </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)
|
||||
{
|
||||
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);
|
||||
byte rm = (byte)(modRM & 0x07);
|
||||
|
||||
// Set the mnemonic based on the opcode and reg field
|
||||
instruction.Mnemonic = Mnemonics[reg];
|
||||
|
||||
// For memory operands, set the operand
|
||||
if (mod != 3) // Memory operand
|
||||
{
|
||||
string operand = ModRMDecoder.DecodeModRM(mod, rm, false);
|
||||
|
||||
// Different operand types based on the instruction
|
||||
if (reg == 0 || reg == 2 || reg == 3) // fld, fst, fstp
|
||||
{
|
||||
instruction.Operands = $"dword ptr {operand}";
|
||||
}
|
||||
else // fldenv, fldcw, fnstenv, fnstcw
|
||||
{
|
||||
instruction.Operands = operand;
|
||||
}
|
||||
}
|
||||
else // Register operand (ST(i))
|
||||
{
|
||||
// Special handling for D9C0-D9FF (register-register operations)
|
||||
if (reg == 0) // FLD ST(i)
|
||||
{
|
||||
instruction.Operands = $"st({rm})";
|
||||
}
|
||||
else if (reg == 1) // FXCH ST(i)
|
||||
{
|
||||
instruction.Mnemonic = "fxch";
|
||||
instruction.Operands = $"st({rm})";
|
||||
}
|
||||
else if (reg == 4)
|
||||
{
|
||||
// D9E0-D9EF special instructions
|
||||
switch (rm)
|
||||
{
|
||||
case 0:
|
||||
instruction.Mnemonic = "fchs";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 1:
|
||||
instruction.Mnemonic = "fabs";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 4:
|
||||
instruction.Mnemonic = "ftst";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 5:
|
||||
instruction.Mnemonic = "fxam";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
default:
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (reg == 5)
|
||||
{
|
||||
// D9F0-D9FF special instructions
|
||||
switch (rm)
|
||||
{
|
||||
case 0:
|
||||
instruction.Mnemonic = "f2xm1";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 1:
|
||||
instruction.Mnemonic = "fyl2x";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 2:
|
||||
instruction.Mnemonic = "fptan";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 3:
|
||||
instruction.Mnemonic = "fpatan";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 4:
|
||||
instruction.Mnemonic = "fxtract";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 5:
|
||||
instruction.Mnemonic = "fprem1";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 6:
|
||||
instruction.Mnemonic = "fdecstp";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 7:
|
||||
instruction.Mnemonic = "fincstp";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
default:
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (reg == 6)
|
||||
{
|
||||
// D9F0-D9FF more special instructions
|
||||
switch (rm)
|
||||
{
|
||||
case 0:
|
||||
instruction.Mnemonic = "fprem";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 1:
|
||||
instruction.Mnemonic = "fyl2xp1";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 2:
|
||||
instruction.Mnemonic = "fsqrt";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 3:
|
||||
instruction.Mnemonic = "fsincos";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 4:
|
||||
instruction.Mnemonic = "frndint";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 5:
|
||||
instruction.Mnemonic = "fscale";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 6:
|
||||
instruction.Mnemonic = "fsin";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
case 7:
|
||||
instruction.Mnemonic = "fcos";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
default:
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,120 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for floating-point load/store float64 operations (DD opcode)
|
||||
/// </summary>
|
||||
public class LoadStoreFloat64Handler : FloatingPointBaseHandler
|
||||
{
|
||||
// DD opcode - load/store float64
|
||||
private static readonly string[] Mnemonics =
|
||||
[
|
||||
"fld",
|
||||
"??",
|
||||
"fst",
|
||||
"fstp",
|
||||
"frstor",
|
||||
"fnsave",
|
||||
"fnstsw"
|
||||
];
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the LoadStoreFloat64Handler 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 LoadStoreFloat64Handler(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)
|
||||
{
|
||||
return opcode == 0xDD;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a floating-point instruction for load/store float64 operations
|
||||
/// </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)
|
||||
{
|
||||
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);
|
||||
byte rm = (byte) (modRM & 0x07);
|
||||
|
||||
// Set the mnemonic based on the opcode and reg field
|
||||
instruction.Mnemonic = Mnemonics[reg];
|
||||
|
||||
// For memory operands, set the operand
|
||||
if (mod != 3) // Memory operand
|
||||
{
|
||||
string operand = ModRMDecoder.DecodeModRM(mod, rm, false);
|
||||
|
||||
if (reg == 0 || reg == 2 || reg == 3) // fld, fst, fstp
|
||||
{
|
||||
instruction.Operands = $"qword ptr {operand}";
|
||||
}
|
||||
else // frstor, fnsave, fnstsw
|
||||
{
|
||||
instruction.Operands = operand;
|
||||
}
|
||||
}
|
||||
else // Register operand (ST(i))
|
||||
{
|
||||
// Special handling for register-register operations
|
||||
if (reg == 0) // FFREE
|
||||
{
|
||||
instruction.Mnemonic = "ffree";
|
||||
instruction.Operands = $"st({rm})";
|
||||
}
|
||||
else if (reg == 2) // FST
|
||||
{
|
||||
instruction.Mnemonic = "fst";
|
||||
instruction.Operands = $"st({rm})";
|
||||
}
|
||||
else if (reg == 3) // FSTP
|
||||
{
|
||||
instruction.Mnemonic = "fstp";
|
||||
instruction.Operands = $"st({rm})";
|
||||
}
|
||||
else if (reg == 4) // FUCOM
|
||||
{
|
||||
instruction.Mnemonic = "fucom";
|
||||
instruction.Operands = $"st({rm})";
|
||||
}
|
||||
else if (reg == 5) // FUCOMP
|
||||
{
|
||||
instruction.Mnemonic = "fucomp";
|
||||
instruction.Operands = $"st({rm})";
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unknown instruction
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,150 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for floating-point load/store int16 and miscellaneous operations (DF opcode)
|
||||
/// </summary>
|
||||
public class LoadStoreInt16Handler : FloatingPointBaseHandler
|
||||
{
|
||||
// DF opcode - load/store int16, misc
|
||||
private static readonly string[] Mnemonics =
|
||||
[
|
||||
"fild",
|
||||
"??",
|
||||
"fist",
|
||||
"fistp",
|
||||
"fbld",
|
||||
"fild",
|
||||
"fbstp",
|
||||
"fistp"
|
||||
];
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the LoadStoreInt16Handler 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 LoadStoreInt16Handler(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)
|
||||
{
|
||||
return opcode == 0xDF;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a floating-point instruction for load/store int16 and miscellaneous operations
|
||||
/// </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)
|
||||
{
|
||||
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);
|
||||
byte rm = (byte) (modRM & 0x07);
|
||||
|
||||
// Check for FNSTSW AX (DF E0)
|
||||
if (mod == 3 && reg == 7 && rm == 0)
|
||||
{
|
||||
// This is handled by the FnstswHandler, so we should not handle it here
|
||||
return false;
|
||||
}
|
||||
|
||||
// Set the mnemonic based on the opcode and reg field
|
||||
instruction.Mnemonic = Mnemonics[reg];
|
||||
|
||||
// For memory operands, set the operand
|
||||
if (mod != 3) // Memory operand
|
||||
{
|
||||
string operand = ModRMDecoder.DecodeModRM(mod, rm, false);
|
||||
|
||||
if (reg == 0 || reg == 2 || reg == 3 || reg == 5 || reg == 7) // fild, fist, fistp, fild, fistp
|
||||
{
|
||||
if (reg == 5 || reg == 7) // 64-bit integer
|
||||
{
|
||||
instruction.Operands = $"qword ptr {operand}";
|
||||
}
|
||||
else // 16-bit integer
|
||||
{
|
||||
instruction.Operands = $"word ptr {operand}";
|
||||
}
|
||||
}
|
||||
else if (reg == 4 || reg == 6) // fbld, fbstp
|
||||
{
|
||||
instruction.Operands = $"tbyte ptr {operand}";
|
||||
}
|
||||
else
|
||||
{
|
||||
instruction.Operands = operand;
|
||||
}
|
||||
}
|
||||
else // Register operand (ST(i))
|
||||
{
|
||||
// Special handling for register-register operations
|
||||
if (reg == 0) // FFREEP
|
||||
{
|
||||
instruction.Mnemonic = "ffreep";
|
||||
instruction.Operands = $"st({rm})";
|
||||
}
|
||||
else if (reg == 1 && rm == 0) // FXCH
|
||||
{
|
||||
instruction.Mnemonic = "fxch";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
else if (reg == 2 && rm == 0) // FSTP
|
||||
{
|
||||
instruction.Mnemonic = "fstp";
|
||||
instruction.Operands = "st(1)";
|
||||
}
|
||||
else if (reg == 3 && rm == 0) // FSTP
|
||||
{
|
||||
instruction.Mnemonic = "fstp";
|
||||
instruction.Operands = "st(1)";
|
||||
}
|
||||
else if (reg == 4) // FNSTSW
|
||||
{
|
||||
// This should not happen as FNSTSW AX is handled by FnstswHandler
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
else if (reg == 5) // FUCOMIP
|
||||
{
|
||||
instruction.Mnemonic = "fucomip";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 6) // FCOMIP
|
||||
{
|
||||
instruction.Mnemonic = "fcomip";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unknown instruction
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,148 @@
|
||||
namespace X86Disassembler.X86.Handlers.FloatingPoint;
|
||||
|
||||
/// <summary>
|
||||
/// Handler for floating-point load/store int32 and miscellaneous operations (DB opcode)
|
||||
/// </summary>
|
||||
public class LoadStoreInt32Handler : FloatingPointBaseHandler
|
||||
{
|
||||
// DB opcode - load/store int32, misc
|
||||
private static readonly string[] Mnemonics =
|
||||
[
|
||||
"fild",
|
||||
"??",
|
||||
"fist",
|
||||
"fistp",
|
||||
"??",
|
||||
"fld",
|
||||
"??",
|
||||
"fstp",
|
||||
];
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the LoadStoreInt32Handler 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 LoadStoreInt32Handler(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)
|
||||
{
|
||||
return opcode == 0xDB;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decodes a floating-point instruction for load/store int32 and miscellaneous operations
|
||||
/// </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)
|
||||
{
|
||||
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);
|
||||
byte rm = (byte) (modRM & 0x07);
|
||||
|
||||
// Set the mnemonic based on the opcode and reg field
|
||||
instruction.Mnemonic = Mnemonics[reg];
|
||||
|
||||
// For memory operands, set the operand
|
||||
if (mod != 3) // Memory operand
|
||||
{
|
||||
string operand = ModRMDecoder.DecodeModRM(mod, rm, false);
|
||||
|
||||
if (reg == 0 || reg == 2 || reg == 3) // fild, fist, fistp
|
||||
{
|
||||
instruction.Operands = $"dword ptr {operand}";
|
||||
}
|
||||
else if (reg == 5 || reg == 7) // fld, fstp (extended precision)
|
||||
{
|
||||
instruction.Operands = $"tword ptr {operand}";
|
||||
}
|
||||
else
|
||||
{
|
||||
instruction.Operands = operand;
|
||||
}
|
||||
}
|
||||
else // Register operand (ST(i))
|
||||
{
|
||||
// Special handling for register-register operations
|
||||
if (reg == 0) // FCMOVNB
|
||||
{
|
||||
instruction.Mnemonic = "fcmovnb";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 1) // FCMOVNE
|
||||
{
|
||||
instruction.Mnemonic = "fcmovne";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 2) // FCMOVNBE
|
||||
{
|
||||
instruction.Mnemonic = "fcmovnbe";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 3) // FCMOVNU
|
||||
{
|
||||
instruction.Mnemonic = "fcmovnu";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 4)
|
||||
{
|
||||
if (rm == 2) // FCLEX
|
||||
{
|
||||
instruction.Mnemonic = "fclex";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
else if (rm == 3) // FINIT
|
||||
{
|
||||
instruction.Mnemonic = "finit";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
else
|
||||
{
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
}
|
||||
else if (reg == 5) // FUCOMI
|
||||
{
|
||||
instruction.Mnemonic = "fucomi";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else if (reg == 6) // FCOMI
|
||||
{
|
||||
instruction.Mnemonic = "fcomi";
|
||||
instruction.Operands = $"st(0), st({rm})";
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unknown instruction
|
||||
instruction.Mnemonic = "??";
|
||||
instruction.Operands = "";
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user