mirrors/ParkanPlayground
0
Fork 0
mirror of https://github.com/sampletext32/ParkanPlayground.git synced 2025-06-19 16:08:02 +03:00
Code Issues Releases Activity

fixups

Browse Source
This commit is contained in:
bird_egop
2025-04-13 03:56:39 +03:00
parent 611dce32e5
commit b215908d76
5 changed files with 57 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
X86Disassembler/X86/Handlers/Int3Handler.cs
View File

@ -1,12 +1,12 @@
namespace X86Disassembler.X86.Handlers;
/// <summary>
/// Handler for CALL rel32 instruction (0xE8)
/// Handler for INT3 instruction (0xCC)
/// </summary>
public class Int3Handler : InstructionHandler
{
/// <summary>
/// Initializes a new instance of the CallRel32Handler class
/// Initializes a new instance of the Int3Handler class
/// </summary>
/// <param name="codeBuffer">The buffer containing the code to decode</param>
/// <param name="decoder">The instruction decoder that owns this handler</param>
@ -27,7 +27,7 @@ public class Int3Handler : InstructionHandler
}
/// <summary>
/// Decodes a CALL rel32 instruction
/// Decodes an INT3 instruction
/// </summary>
/// <param name="opcode">The opcode of the instruction</param>
/// <param name="instruction">The instruction object to populate</param>

50
X86Disassembler/X86/Handlers/Mov/MovRegMemHandler.cs
View File

@ -34,36 +34,56 @@ public class MovRegMemHandler : InstructionHandler
/// <returns>True if the instruction was successfully decoded</returns>
public override bool Decode(byte opcode, Instruction instruction)
{
// Save the original position for raw bytes calculation
int startPosition = Decoder.GetPosition();
// Set the mnemonic
instruction.Mnemonic = "mov";
int position = Decoder.GetPosition();
if (position >= Length)
if (startPosition >= Length)
{
return false;
instruction.Operands = "??";
instruction.RawBytes = new byte[] { opcode };
return true;
}
// Determine operand size (0 = 8-bit, 1 = 32-bit)
bool operandSize32 = (opcode & 0x01) != 0;
int operandSize = operandSize32 ? 32 : 8;
// Read the ModR/M byte
var (mod, reg, rm, memOperand) = ModRMDecoder.ReadModRM();
// Use ModRMDecoder to decode the ModR/M byte
var (mod, reg, rm, rmOperand) = ModRMDecoder.ReadModRM(false); // false for 32-bit operand
// Get register name based on size
string regName = ModRMDecoder.GetRegisterName(reg, operandSize);
string regName;
if (operandSize == 8)
{
regName = GetRegister8(reg);
}
else
{
regName = GetRegister32(reg);
}
// For mod == 3, both operands are registers
if (mod == 3)
// Get the position after decoding the ModR/M byte
int newPosition = Decoder.GetPosition();
// Set the operands - register is the destination, r/m is the source (for 0x8B)
// This matches the correct x86 instruction format: MOV r32, r/m32
instruction.Operands = $"{regName}, {rmOperand}";
// Set the raw bytes
int totalBytes = newPosition - startPosition + 1; // +1 for opcode
byte[] rawBytes = new byte[totalBytes];
rawBytes[0] = opcode;
for (int i = 0; i < totalBytes - 1; i++)
{
string rmRegName = ModRMDecoder.GetRegisterName(rm, operandSize);
instruction.Operands = $"{rmRegName}, {regName}";
}
else // Memory operand
{
instruction.Operands = $"{memOperand}, {regName}";
if (startPosition + i < Length)
{
rawBytes[i + 1] = CodeBuffer[startPosition + i];
}
}
instruction.RawBytes = rawBytes;
return true;
}