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

Add support for TEST instruction

Browse Source
This commit is contained in:
bird_egop 2025-04-12 19:26:00 +03:00
parent ae1c4730d0
commit cedd7a931e
5 changed files with 258 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
X86Disassembler/X86/Handlers/Group3Handler.cs Normal file
View File

@ -0,0 +1,99 @@
namespace X86Disassembler.X86.Handlers;
/// <summary>
/// Handler for Group 3 instructions (TEST, NOT, NEG, MUL, IMUL, DIV, IDIV)
/// </summary>
public class Group3Handler : InstructionHandler
{
/// <summary>
/// Initializes a new instance of the Group3Handler 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 Group3Handler(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 OpcodeMap.IsGroup3Opcode(opcode);
}
/// <summary>
/// Decodes a Group 3 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)
{
return false;
}
// Read the ModR/M byte
var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM();
// Determine the operation based on reg field
instruction.Mnemonic = OpcodeMap.Group3Operations[reg];
// For TEST instruction (reg = 0), we need to read an immediate value
if (reg == 0) // TEST
{
position = Decoder.GetPosition();
string immOperand;
switch (opcode)
{
case 0xF6: // 8-bit TEST
if (position < Length)
{
byte imm8 = CodeBuffer[position];
Decoder.SetPosition(position + 1);
immOperand = $"0x{imm8:X2}";
}
else
{
immOperand = "???";
}
break;
case 0xF7: // 32-bit TEST
if (position + 3 < Length)
{
uint imm32 = BitConverter.ToUInt32(CodeBuffer, position);
Decoder.SetPosition(position + 4);
immOperand = $"0x{imm32:X8}";
}
else
{
immOperand = "???";
}
break;
default:
return false;
}
// Set the operands
instruction.Operands = $"{destOperand}, {immOperand}";
}
else
{
// For other Group 3 instructions (NOT, NEG, MUL, etc.), there's only one operand
instruction.Operands = destOperand;
}
return true;
}
}

101
X86Disassembler/X86/Handlers/TestHandler.cs Normal file
View File

@ -0,0 +1,101 @@
namespace X86Disassembler.X86.Handlers;
/// <summary>
/// Handler for TEST instructions
/// </summary>
public class TestHandler : InstructionHandler
{
/// <summary>
/// Initializes a new instance of the TestHandler 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 TestHandler(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 == 0x84 || opcode == 0x85 || opcode == 0xA8 || opcode == 0xA9;
}
/// <summary>
/// Decodes a TEST 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)
{
return false;
}
// Set the mnemonic
instruction.Mnemonic = "test";
switch (opcode)
{
case 0x84: // TEST r/m8, r8
case 0x85: // TEST r/m32, r32
// Read the ModR/M byte
var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM();
// Determine the source register
string sourceReg;
if (opcode == 0x84) // 8-bit registers
{
sourceReg = ModRMDecoder.GetRegister8(reg);
}
else // 32-bit registers
{
sourceReg = ModRMDecoder.GetRegister32(reg);
}
// Set the operands
instruction.Operands = $"{destOperand}, {sourceReg}";
break;
case 0xA8: // TEST AL, imm8
if (position < Length)
{
byte imm8 = CodeBuffer[position];
Decoder.SetPosition(position + 1);
instruction.Operands = $"al, 0x{imm8:X2}";
}
else
{
instruction.Operands = "al, ???";
}
break;
case 0xA9: // TEST EAX, imm32
if (position + 3 < Length)
{
uint imm32 = BitConverter.ToUInt32(CodeBuffer, position);
Decoder.SetPosition(position + 4);
instruction.Operands = $"eax, 0x{imm32:X8}";
}
else
{
instruction.Operands = "eax, ???";
}
break;
default:
return false;
}
return true;
}
}

4
X86Disassembler/X86/InstructionDecoder.cs
View File

@ -48,7 +48,9 @@ public class InstructionDecoder
new Group1Handler(_codeBuffer, this, _length),
new FloatingPointHandler(_codeBuffer, this, _length),
new DataTransferHandler(_codeBuffer, this, _length),
new ControlFlowHandler(_codeBuffer, this, _length)
new ControlFlowHandler(_codeBuffer, this, _length),
new Group3Handler(_codeBuffer, this, _length),
new TestHandler(_codeBuffer, this, _length)
};
}

30
X86Disassembler/X86/ModRMDecoder.cs
View File

@ -239,4 +239,34 @@ public class ModRMDecoder
_ => RegisterNames32[index]
};
}
/// <summary>
/// Gets the 8-bit register name based on the register number
/// </summary>
/// <param name="reg">The register number (0-7)</param>
/// <returns>The register name</returns>
public static string GetRegister8(int reg)
{
if (reg >= 0 && reg < RegisterNames8.Length)
{
return RegisterNames8[reg];
}
return $"r{reg}?";
}
/// <summary>
/// Gets the 32-bit register name based on the register number
/// </summary>
/// <param name="reg">The register number (0-7)</param>
/// <returns>The register name</returns>
public static string GetRegister32(int reg)
{
if (reg >= 0 && reg < RegisterNames32.Length)
{
return RegisterNames32[reg];
}
return $"r{reg}?";
}
}

25
X86Disassembler/X86/OpcodeMap.cs
View File

@ -19,6 +19,11 @@ public class OpcodeMap
"add", "or", "adc", "sbb", "and", "sub", "xor", "cmp"
};
// Group 3 operations (used with opcodes 0xF6, 0xF7)
public static readonly string[] Group3Operations = {
"test", "???", "not", "neg", "mul", "imul", "div", "idiv"
};
// Static constructor to initialize the opcode maps
static OpcodeMap()
{
@ -51,6 +56,16 @@ public class OpcodeMap
OneByteOpcodes[0x81] = "group1d";
OneByteOpcodes[0x83] = "group1s"; // Sign-extended immediate
// Group 3 instructions (TEST, NOT, NEG, MUL, IMUL, DIV, IDIV)
OneByteOpcodes[0xF6] = "group3b"; // 8-bit operations
OneByteOpcodes[0xF7] = "group3d"; // 32-bit operations
// TEST instructions
OneByteOpcodes[0x84] = "test"; // TEST r/m8, r8
OneByteOpcodes[0x85] = "test"; // TEST r/m32, r32
OneByteOpcodes[0xA8] = "test"; // TEST AL, imm8
OneByteOpcodes[0xA9] = "test"; // TEST EAX, imm32
// Data transfer instructions
for (int i = 0x88; i <= 0x8B; i++)
{
@ -125,6 +140,16 @@ public class OpcodeMap
return opcode == 0x80 || opcode == 0x81 || opcode == 0x83;
}
/// <summary>
/// Checks if the opcode is a Group 3 opcode
/// </summary>
/// <param name="opcode">The opcode to check</param>
/// <returns>True if the opcode is a Group 3 opcode</returns>
public static bool IsGroup3Opcode(byte opcode)
{
return opcode == 0xF6 || opcode == 0xF7;
}
/// <summary>
/// Checks if the opcode is a floating-point instruction
/// </summary>