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

Removed duplicate OR instruction handlers and files to fix handler organization

Browse Source
This commit is contained in:
bird_egop 2025-04-13 01:11:20 +03:00
parent 03aa51d13c
commit 8123ced2d6
4 changed files with 0 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -203,8 +203,6 @@ public class InstructionHandlerFactory
_handlers.Add(new OrR32Rm32Handler(_codeBuffer, _decoder, _length));
_handlers.Add(new OrAlImmHandler(_codeBuffer, _decoder, _length));
_handlers.Add(new OrEaxImmHandler(_codeBuffer, _decoder, _length));
_handlers.Add(new OrImmWithRm32Handler(_codeBuffer, _decoder, _length));
_handlers.Add(new OrImmWithRm32SignExtendedHandler(_codeBuffer, _decoder, _length));
}
/// <summary>

115
X86Disassembler/X86/Handlers/Or/OrImmWithRm32Handler.cs
View File

@ -1,115 +0,0 @@
namespace X86Disassembler.X86.Handlers.Or;
/// <summary>
/// Handler for OR r/m32, imm32 instruction (0x81 /1)
/// </summary>
public class OrImmWithRm32Handler : InstructionHandler
{
/// <summary>
/// Initializes a new instance of the OrImmWithRm32Handler 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 OrImmWithRm32Handler(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 == 0x81;
}
/// <summary>
/// Decodes an OR r/m32, imm32 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
byte modRM = CodeBuffer[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 if this is an OR instruction (reg field = 1)
if (reg != 1)
{
return false;
}
// Process SIB and displacement bytes if needed
if (mod != 3 && rm == 4) // SIB byte present
{
if (position >= Length)
{
return false;
}
position++; // Skip SIB byte
}
// Handle displacement
if ((mod == 1 && position >= Length) || (mod == 2 && position + 3 >= Length))
{
return false;
}
if (mod == 1) // 8-bit displacement
{
position++;
}
else if (mod == 2) // 32-bit displacement
{
position += 4;
}
// Read the immediate dword
if (position + 3 >= Length)
{
return false;
}
byte b0 = CodeBuffer[position++];
byte b1 = CodeBuffer[position++];
byte b2 = CodeBuffer[position++];
byte b3 = CodeBuffer[position++];
uint imm32 = (uint)(b0 | (b1 << 8) | (b2 << 16) | (b3 << 24));
Decoder.SetPosition(position);
// Set the mnemonic
instruction.Mnemonic = "or";
// Get the operand string
string operand;
if (mod != 3) // Memory operand
{
operand = ModRMDecoder.DecodeModRM(mod, rm, false);
}
else // Register operand
{
operand = GetRegister32(rm);
}
// Set the operands
instruction.Operands = $"{operand}, 0x{imm32:X8}";
return true;
}
}

111
X86Disassembler/X86/Handlers/Or/OrImmWithRm32SignExtendedHandler.cs
View File

@ -1,111 +0,0 @@
namespace X86Disassembler.X86.Handlers.Or;
/// <summary>
/// Handler for OR r/m32, imm8 sign-extended instruction (0x83 /1)
/// </summary>
public class OrImmWithRm32SignExtendedHandler : InstructionHandler
{
/// <summary>
/// Initializes a new instance of the OrImmWithRm32SignExtendedHandler 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 OrImmWithRm32SignExtendedHandler(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 == 0x83;
}
/// <summary>
/// Decodes an OR r/m32, imm8 sign-extended 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
byte modRM = CodeBuffer[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 if this is an OR instruction (reg field = 1)
if (reg != 1)
{
return false;
}
// Process SIB and displacement bytes if needed
if (mod != 3 && rm == 4) // SIB byte present
{
if (position >= Length)
{
return false;
}
position++; // Skip SIB byte
}
// Handle displacement
if ((mod == 1 && position >= Length) || (mod == 2 && position + 3 >= Length))
{
return false;
}
if (mod == 1) // 8-bit displacement
{
position++;
}
else if (mod == 2) // 32-bit displacement
{
position += 4;
}
// Read the immediate byte
if (position >= Length)
{
return false;
}
byte imm8 = CodeBuffer[position++];
Decoder.SetPosition(position);
// Set the mnemonic
instruction.Mnemonic = "or";
// Get the operand string
string operand;
if (mod != 3) // Memory operand
{
operand = ModRMDecoder.DecodeModRM(mod, rm, false);
}
else // Register operand
{
operand = GetRegister32(rm);
}
// Set the operands
instruction.Operands = $"{operand}, {imm8}";
return true;
}
}

136
X86Disassembler/X86/Handlers/Or/OrImmWithRm8Handler.cs
View File

@ -1,136 +0,0 @@
namespace X86Disassembler.X86.Handlers.Group1;
/// <summary>
/// Handler for OR r/m8, imm8 instruction (0x80 /1)
/// </summary>
public class OrImmWithRm8Handler : InstructionHandler
{
/// <summary>
/// Initializes a new instance of the OrImmWithRm8Handler 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 OrImmWithRm8Handler(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)
{
if (opcode != 0x80)
return false;
// Check if the reg field of the ModR/M byte is 1 (OR)
int position = Decoder.GetPosition();
if (position >= Length)
return false;
byte modRM = CodeBuffer[position];
byte reg = (byte)((modRM & 0x38) >> 3);
return reg == 1; // 1 = OR
}
/// <summary>
/// Decodes an OR r/m8, imm8 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
byte modRM = CodeBuffer[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);
// OR r/m8, imm8 is encoded as 80 /1
if (reg != 1)
{
return false;
}
// Process SIB and displacement bytes if needed
if (mod != 3 && rm == 4) // SIB byte present
{
if (position >= Length)
{
return false;
}
position++; // Skip SIB byte
}
// Handle displacement
if ((mod == 1 && position >= Length) || (mod == 2 && position + 3 >= Length))
{
return false;
}
if (mod == 1) // 8-bit displacement
{
position++;
}
else if (mod == 2) // 32-bit displacement
{
position += 4;
}
// Read the immediate byte
if (position >= Length)
{
return false;
}
byte imm8 = CodeBuffer[position++];
Decoder.SetPosition(position);
// Set the mnemonic
instruction.Mnemonic = "or";
// Get the operand string
string operand;
if (mod != 3) // Memory operand
{
string memOperand = ModRMDecoder.DecodeModRM(mod, rm, true);
// Replace the size prefix with "byte ptr"
if (memOperand.StartsWith("qword ptr "))
{
operand = memOperand.Replace("qword ptr ", "byte ptr ");
}
else if (memOperand.StartsWith("dword ptr "))
{
operand = memOperand.Replace("dword ptr ", "byte ptr ");
}
else
{
operand = $"byte ptr {memOperand}";
}
}
else // Register operand
{
operand = GetRegister8(rm);
}
// Set the operands
instruction.Operands = $"{operand}, 0x{imm8:X2}";
return true;
}
}