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

Simplified TwoByteConditionalJumpHandler and MovRegMemHandler by improving boundary checking and target address calculation

Browse Source
This commit is contained in:
bird_egop 2025-04-14 00:17:31 +03:00
parent 996be18172
commit 2d0f701dd1
2 changed files with 25 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
X86Disassembler/X86/Handlers/Jump/TwoByteConditionalJumpHandler.cs
View File

@ -31,18 +31,20 @@ public class TwoByteConditionalJumpHandler : InstructionHandler
public override bool CanHandle(byte opcode) public override bool CanHandle(byte opcode)
{ {
// Two-byte conditional jumps start with 0x0F // Two-byte conditional jumps start with 0x0F
if (opcode == 0x0F) if (opcode != 0x0F)
{ {
int position = Decoder.GetPosition(); return false;
if (position < Length)
{
byte secondByte = CodeBuffer[position];
// Second byte must be in the range 0x80-0x8F
return secondByte >= 0x80 && secondByte <= 0x8F;
}
} }
return false; int position = Decoder.GetPosition();
if (!Decoder.CanReadByte())
{
return false;
}
byte secondByte = CodeBuffer[position];
// Second byte must be in the range 0x80-0x8F
return secondByte >= 0x80 && secondByte <= 0x8F;
} }
/// <summary> /// <summary>
@ -55,20 +57,21 @@ public class TwoByteConditionalJumpHandler : InstructionHandler
{ {
int position = Decoder.GetPosition(); int position = Decoder.GetPosition();
if (position >= Length) // Check if we have enough bytes for the second byte
{ if (!Decoder.CanReadByte())
{
return false; return false;
} }
// Read the second byte of the opcode // Read the second byte of the opcode
byte secondByte = CodeBuffer[position++]; byte secondByte = Decoder.ReadByte();
Decoder.SetPosition(position);
// Get the mnemonic from the table // Get the mnemonic from the table
int index = secondByte - 0x80; int index = secondByte - 0x80;
instruction.Mnemonic = ConditionalJumpMnemonics[index]; instruction.Mnemonic = ConditionalJumpMnemonics[index];
if (position + 4 > Length) // Check if we have enough bytes for the offset
if (!Decoder.CanReadUInt())
{ {
return false; return false;
} }
@ -77,9 +80,10 @@ public class TwoByteConditionalJumpHandler : InstructionHandler
uint offset = Decoder.ReadUInt32(); uint offset = Decoder.ReadUInt32();
// Calculate the target address // Calculate the target address
uint targetAddress = (uint)(position + offset + 4); // For two-byte conditional jumps, the instruction is 6 bytes: first opcode (1) + second opcode (1) + offset (4)
uint targetAddress = (uint)(instruction.Address + 6 + offset);
// Set the operands // Format the target address
instruction.Operands = $"0x{targetAddress:X8}"; instruction.Operands = $"0x{targetAddress:X8}";
return true; return true;

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

@ -34,52 +34,28 @@ public class MovRegMemHandler : InstructionHandler
/// <returns>True if the instruction was successfully decoded</returns> /// <returns>True if the instruction was successfully decoded</returns>
public override bool Decode(byte opcode, Instruction instruction) public override bool Decode(byte opcode, Instruction instruction)
{ {
// Save the original position for raw bytes calculation
int startPosition = Decoder.GetPosition();
// Set the mnemonic // Set the mnemonic
instruction.Mnemonic = "mov"; instruction.Mnemonic = "mov";
if (startPosition >= Length) // Check if we have enough bytes for the ModR/M byte
if (!Decoder.CanReadByte())
{ {
instruction.Operands = "??"; return false;
instruction.RawBytes = new byte[] {opcode};
return true;
} }
// Determine operand size (0 = 8-bit, 1 = 32-bit) // Determine operand size (0 = 8-bit, 1 = 32-bit)
bool operandSize32 = (opcode & 0x01) != 0; int operandSize = (opcode & 0x01) != 0 ? 32 : 8;
int operandSize = operandSize32
? 32
: 8;
// Use ModRMDecoder to decode the ModR/M byte // Use ModRMDecoder to decode the ModR/M byte
var (mod, reg, rm, rmOperand) = ModRMDecoder.ReadModRM(); // false for 32-bit operand var (mod, reg, rm, rmOperand) = ModRMDecoder.ReadModRM();
// Get register name based on size // Get register name based on size
string regName = ModRMDecoder.GetRegisterName(reg, operandSize); string regName = ModRMDecoder.GetRegisterName(reg, operandSize);
// 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) // 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 // This matches the correct x86 instruction format: MOV r32, r/m32
instruction.Operands = $"{regName}, {rmOperand}"; 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++)
{
if (startPosition + i < Length)
{
rawBytes[i + 1] = CodeBuffer[startPosition + i];
}
}
instruction.RawBytes = rawBytes;
return true; return true;
} }
} }