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

cleanup

Browse Source
This commit is contained in:
bird_egop 2025-04-12 23:40:48 +03:00
parent 3cc6d27e33
commit f658f4384c
9 changed files with 16 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
X86Disassembler/X86/Handlers/FloatingPoint/Int32OperationHandler.cs
View File

@ -7,7 +7,7 @@ public class Int32OperationHandler : FloatingPointBaseHandler
{
// DA opcode - operations on int32
private static readonly string[] Mnemonics =
{
[
"fiadd",
"fimul",
"ficom",
@ -15,8 +15,8 @@ public class Int32OperationHandler : FloatingPointBaseHandler
"fisub",
"fisubr",
"fidiv",
"fidivr",
};
"fidivr"
];
/// <summary>
/// Initializes a new instance of the Int32OperationHandler class

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

@ -18,7 +18,7 @@ namespace X86Disassembler.X86.Handlers;
/// </summary>
public class InstructionHandlerFactory
{
private readonly List<IInstructionHandler> _handlers = new();
private readonly List<IInstructionHandler> _handlers = [];
private readonly byte[] _codeBuffer;
private readonly InstructionDecoder _decoder;
private readonly int _length;

8
X86Disassembler/X86/Handlers/Jump/ConditionalJumpHandler.cs
View File

@ -6,11 +6,11 @@ namespace X86Disassembler.X86.Handlers.Jump;
public class ConditionalJumpHandler : InstructionHandler
{
// Mnemonics for conditional jumps
private static readonly string[] ConditionalJumpMnemonics = new string[]
{
private static readonly string[] Mnemonics =
[
"jo", "jno", "jb", "jnb", "jz", "jnz", "jbe", "jnbe",
"js", "jns", "jp", "jnp", "jl", "jnl", "jle", "jnle"
};
];
/// <summary>
/// Initializes a new instance of the ConditionalJumpHandler class
@ -44,7 +44,7 @@ public class ConditionalJumpHandler : InstructionHandler
{
// Get the mnemonic from the table
int index = opcode - 0x70;
instruction.Mnemonic = ConditionalJumpMnemonics[index];
instruction.Mnemonic = Mnemonics[index];
// Get the current position in the code buffer
int position = Decoder.GetPosition();

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

@ -6,11 +6,11 @@ namespace X86Disassembler.X86.Handlers.Jump;
public class TwoByteConditionalJumpHandler : InstructionHandler
{
// Mnemonics for conditional jumps
private static readonly string[] ConditionalJumpMnemonics = new string[]
{
private static readonly string[] ConditionalJumpMnemonics =
[
"jo", "jno", "jb", "jnb", "jz", "jnz", "jbe", "jnbe",
"js", "jns", "jp", "jnp", "jl", "jnl", "jle", "jnle"
};
];
/// <summary>
/// Initializes a new instance of the TwoByteConditionalJumpHandler class

2
X86Disassembler/X86/Instruction.cs
View File

@ -23,7 +23,7 @@ public class Instruction
/// <summary>
/// Gets or sets the raw bytes of the instruction
/// </summary>
public byte[] RawBytes { get; set; } = Array.Empty<byte>();
public byte[] RawBytes { get; set; } = [];
/// <summary>
/// Returns a string representation of the instruction

6
X86Disassembler/X86/InstructionDecoder.cs
View File

@ -1,6 +1,6 @@
namespace X86Disassembler.X86;
using X86Disassembler.X86.Handlers;
using Handlers;
/// <summary>
/// Decodes x86 instructions from a byte buffer
@ -25,7 +25,7 @@ public class InstructionDecoder
private bool _segmentOverridePrefix;
private bool _lockPrefix;
private bool _repPrefix;
private string _segmentOverride = string.Empty;
private string _segmentOverride;
/// <summary>
/// Initializes a new instance of the InstructionDecoder class
@ -37,7 +37,7 @@ public class InstructionDecoder
_codeBuffer = codeBuffer;
_length = length;
_position = 0;
_segmentOverride = string.Empty;
_segmentOverride = "";
// Create the instruction handler factory
_handlerFactory = new InstructionHandlerFactory(_codeBuffer, this, _length);

72
X86Disassembler/X86/InstructionType.cs
View File

@ -1,72 +0,0 @@
namespace X86Disassembler.X86;
/// <summary>
/// Represents the different types of x86 instructions
/// </summary>
public enum InstructionType
{
/// <summary>
/// Unknown or unrecognized instruction
/// </summary>
Unknown,
/// <summary>
/// Data transfer instructions (e.g., MOV, PUSH, POP, XCHG)
/// </summary>
DataTransfer,
/// <summary>
/// Arithmetic instructions (e.g., ADD, SUB, MUL, DIV)
/// </summary>
Arithmetic,
/// <summary>
/// Logical instructions (e.g., AND, OR, XOR, NOT)
/// </summary>
Logical,
/// <summary>
/// Shift and rotate instructions (e.g., SHL, SHR, ROL, ROR)
/// </summary>
ShiftRotate,
/// <summary>
/// Control flow instructions (e.g., JMP, CALL, RET)
/// </summary>
ControlFlow,
/// <summary>
/// Conditional jump instructions (e.g., JE, JNE, JG, JL)
/// </summary>
ConditionalJump,
/// <summary>
/// String instructions (e.g., MOVS, CMPS, SCAS)
/// </summary>
String,
/// <summary>
/// I/O instructions (e.g., IN, OUT)
/// </summary>
IO,
/// <summary>
/// Flag control instructions (e.g., STC, CLC, CMC)
/// </summary>
FlagControl,
/// <summary>
/// Processor control instructions (e.g., HLT, WAIT)
/// </summary>
ProcessorControl,
/// <summary>
/// Floating-point instructions (e.g., FADD, FSUB, FMUL)
/// </summary>
FloatingPoint,
/// <summary>
/// SIMD instructions (e.g., MMX, SSE, AVX)
/// </summary>
SIMD
}

30
X86Disassembler/X86/ModRMDecoder.cs
View File

@ -239,34 +239,4 @@ 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}?";
}
}

42
X86Disassembler/X86/OpcodeMap.cs
View File

@ -3,7 +3,7 @@ namespace X86Disassembler.X86;
/// <summary>
/// Provides mapping between opcodes and their mnemonics
/// </summary>
public class OpcodeMap
public static class OpcodeMap
{
// One-byte opcode map
private static readonly string[] OneByteOpcodes = new string[256];
@ -14,16 +14,6 @@ public class OpcodeMap
"s", "ns", "p", "np", "l", "ge", "le", "g"
};
// Group 1 operations (used with opcodes 0x80, 0x81, 0x83)
public static readonly string[] Group1Operations = {
"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()
{
@ -138,34 +128,4 @@ public class OpcodeMap
{
return OneByteOpcodes[opcode];
}
/// <summary>
/// Checks if the opcode is a Group 1 opcode
/// </summary>
/// <param name="opcode">The opcode to check</param>
/// <returns>True if the opcode is a Group 1 opcode</returns>
public static bool IsGroup1Opcode(byte opcode)
{
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>
/// <param name="opcode">The opcode to check</param>
/// <returns>True if the opcode is a floating-point instruction</returns>
public static bool IsFloatingPointOpcode(byte opcode)
{
return opcode >= 0xD8 && opcode <= 0xDF;
}
}