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

Moved AND instruction handlers from ArithmeticImmediate to dedicated And namespace for better organization

Browse Source
This commit is contained in:
bird_egop
2025-04-13 04:11:06 +03:00
parent af94b88868
commit e8a16e7ecd
4 changed files with 0 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
X86DisassemblerTests/SequenceDebuggingTests.cs
View File

@ -1,90 +0,0 @@
namespace X86DisassemblerTests;
using System;
using Xunit;
using X86Disassembler.X86;
using X86Disassembler.X86.Handlers;
using X86Disassembler.X86.Handlers.ArithmeticImmediate;
using X86Disassembler.X86.Handlers.Inc;
/// <summary>
/// Tests for debugging the specific problematic sequence
/// </summary>
public class SequenceDebuggingTests
{
/// <summary>
/// Tests each byte in the problematic sequence individually
/// </summary>
[Fact]
public void Debug_ProblematicSequence_ByteByByte()
{
// The problematic sequence
byte[] fullSequence = new byte[] { 0x08, 0x83, 0xC1, 0x04, 0x50, 0xE8, 0x42, 0x01, 0x00, 0x00 };
// Test each byte individually
for (int i = 0; i < fullSequence.Length; i++)
{
byte opcode = fullSequence[i];
string expectedMnemonic = GetExpectedMnemonic(opcode);
// Create a buffer with just this byte
byte[] buffer = new byte[] { opcode };
var decoder = new InstructionDecoder(buffer, buffer.Length);
var factory = new InstructionHandlerFactory(buffer, decoder, buffer.Length);
// Get the handler for this opcode
var handler = factory.GetHandler(opcode);
// Output debug information
Console.WriteLine($"Byte 0x{opcode:X2} at position {i}: Handler = {(handler != null ? handler.GetType().Name : "null")}");
// If we have a handler, decode the instruction
if (handler != null)
{
var instruction = new Instruction();
bool success = handler.Decode(opcode, instruction);
Console.WriteLine($" Decoded as: {instruction.Mnemonic} {instruction.Operands}");
}
}
// Now test the specific sequence 0x83 0xC1 0x04 (ADD ecx, 0x04)
byte[] addSequence = new byte[] { 0x83, 0xC1, 0x04 };
var addDecoder = new InstructionDecoder(addSequence, addSequence.Length);
var addInstruction = addDecoder.DecodeInstruction();
Console.WriteLine($"\nDecoding 0x83 0xC1 0x04 directly: {addInstruction?.Mnemonic} {addInstruction?.Operands}");
// Now test the sequence 0x08 0x83 0xC1 0x04
byte[] orAddSequence = new byte[] { 0x08, 0x83, 0xC1, 0x04 };
var orAddDecoder = new InstructionDecoder(orAddSequence, orAddSequence.Length);
// Decode the first instruction (0x08)
var orInstruction = orAddDecoder.DecodeInstruction();
Console.WriteLine($"\nDecoding 0x08 in sequence 0x08 0x83 0xC1 0x04: {orInstruction?.Mnemonic} {orInstruction?.Operands}");
// Decode the second instruction (0x83 0xC1 0x04)
var secondInstruction = orAddDecoder.DecodeInstruction();
Console.WriteLine($"Decoding 0x83 0xC1 0x04 after 0x08: {secondInstruction?.Mnemonic} {secondInstruction?.Operands}");
// Assert that we get the expected mnemonic for the second instruction
Assert.Equal("add", secondInstruction?.Mnemonic);
}
/// <summary>
/// Gets the expected mnemonic for a given opcode
/// </summary>
private string GetExpectedMnemonic(byte opcode)
{
return opcode switch
{
0x08 => "or",
0x83 => "add", // Assuming reg field is 0 (ADD)
0x50 => "push",
0xE8 => "call",
0x40 => "inc",
0x41 => "inc",
0x42 => "inc",
_ => "??"
};
}
}