From abe4d38d4ba3f3e3879d834b1158504aad0c9957 Mon Sep 17 00:00:00 2001 From: bird_egop Date: Tue, 15 Apr 2025 02:42:47 +0300 Subject: [PATCH] more cleanup --- .../Decompiler/ControlFlowGraph.cs | 4 ++-- .../Decompiler/DataFlowAnalysis.cs | 2 +- X86Disassembler/Decompiler/Decompiler.cs | 4 ++-- .../X86/Handlers/Adc/AdcImmToRm32Handler.cs | 7 +++---- .../Adc/AdcImmToRm32SignExtendedHandler.cs | 7 +++---- .../X86/Handlers/Add/AddImmToRm32Handler.cs | 5 ++--- .../Add/AddImmToRm32SignExtendedHandler.cs | 5 ++--- .../X86/Handlers/Add/AddImmToRm8Handler.cs | 7 +++---- .../X86/Handlers/Add/AddR32Rm32Handler.cs | 2 +- .../X86/Handlers/Add/AddRm32R32Handler.cs | 2 +- .../X86/Handlers/And/AndImmToRm32Handler.cs | 7 +++---- .../And/AndImmToRm32SignExtendedHandler.cs | 5 ++--- .../X86/Handlers/And/AndImmToRm8Handler.cs | 5 ++--- .../X86/Handlers/And/AndImmWithRm32Handler.cs | 5 ++--- .../X86/Handlers/And/AndMemRegHandler.cs | 2 +- .../X86/Handlers/And/AndR32Rm32Handler.cs | 2 +- .../X86/Handlers/And/AndR8Rm8Handler.cs | 2 +- .../X86/Handlers/And/AndRm8R8Handler.cs | 2 +- .../ArithmeticUnary/DivRm32Handler.cs | 5 ++--- .../ArithmeticUnary/IdivRm32Handler.cs | 5 ++--- .../ArithmeticUnary/ImulRm32Handler.cs | 5 ++--- .../ArithmeticUnary/MulRm32Handler.cs | 5 ++--- .../ArithmeticUnary/NegRm32Handler.cs | 5 ++--- .../ArithmeticUnary/NotRm32Handler.cs | 5 ++--- .../X86/Handlers/Call/CallRel32Handler.cs | 2 +- .../X86/Handlers/Call/CallRm32Handler.cs | 7 ++----- .../X86/Handlers/Cmp/CmpAlImmHandler.cs | 2 +- .../X86/Handlers/Cmp/CmpImmWithRm32Handler.cs | 5 ++--- .../Cmp/CmpImmWithRm32SignExtendedHandler.cs | 7 +++---- .../X86/Handlers/Cmp/CmpImmWithRm8Handler.cs | 5 ++--- .../X86/Handlers/Cmp/CmpR32Rm32Handler.cs | 2 +- .../X86/Handlers/Cmp/CmpRm32R32Handler.cs | 2 +- .../X86/Handlers/Dec/DecRegHandler.cs | 2 +- .../Handlers/FloatingPoint/FnstswHandler.cs | 2 +- .../X86/Handlers/Inc/IncRegHandler.cs | 2 +- .../Handlers/Jump/ConditionalJumpHandler.cs | 2 +- .../X86/Handlers/Jump/JgeRel8Handler.cs | 2 +- .../X86/Handlers/Jump/JmpRel32Handler.cs | 2 +- .../X86/Handlers/Jump/JmpRel8Handler.cs | 2 +- .../Jump/TwoByteConditionalJumpHandler.cs | 5 ++--- .../X86/Handlers/Lea/LeaR32MHandler.cs | 2 +- .../X86/Handlers/Mov/MovMemRegHandler.cs | 2 +- .../X86/Handlers/Mov/MovRegMemHandler.cs | 2 +- .../X86/Handlers/Mov/MovRm32Imm32Handler.cs | 4 ++-- .../X86/Handlers/Mov/MovRm8Imm8Handler.cs | 2 +- .../X86/Handlers/Nop/MultiByteNopHandler.cs | 2 +- .../X86/Handlers/Or/OrAlImmHandler.cs | 2 +- .../X86/Handlers/Or/OrEaxImmHandler.cs | 2 +- .../X86/Handlers/Or/OrImmToRm32Handler.cs | 7 +++---- .../Or/OrImmToRm32SignExtendedHandler.cs | 7 +++---- .../X86/Handlers/Or/OrImmToRm8Handler.cs | 5 ++--- .../X86/Handlers/Or/OrR32Rm32Handler.cs | 2 +- .../X86/Handlers/Or/OrR8Rm8Handler.cs | 2 +- .../X86/Handlers/Or/OrRm8R8Handler.cs | 5 +---- .../X86/Handlers/Pop/PopRegHandler.cs | 2 +- .../X86/Handlers/Push/PushImm32Handler.cs | 2 +- .../X86/Handlers/Push/PushImm8Handler.cs | 2 +- .../X86/Handlers/Push/PushRegHandler.cs | 2 +- .../X86/Handlers/Push/PushRm32Handler.cs | 10 +++------- .../X86/Handlers/Ret/RetImmHandler.cs | 2 +- .../X86/Handlers/Sbb/SbbImmFromRm32Handler.cs | 7 +++---- .../Sbb/SbbImmFromRm32SignExtendedHandler.cs | 7 +++---- .../String/StringInstructionHandler.cs | 2 +- .../X86/Handlers/Sub/SubImmFromRm16Handler.cs | 5 ++--- .../Sub/SubImmFromRm16SignExtendedHandler.cs | 5 ++--- .../X86/Handlers/Sub/SubImmFromRm32Handler.cs | 5 ++--- .../Sub/SubImmFromRm32SignExtendedHandler.cs | 5 ++--- .../X86/Handlers/Sub/SubImmFromRm8Handler.cs | 5 ++--- .../X86/Handlers/Sub/SubR16Rm16Handler.cs | 2 +- .../X86/Handlers/Sub/SubR32Rm32Handler.cs | 2 +- .../X86/Handlers/Sub/SubR8Rm8Handler.cs | 2 +- .../X86/Handlers/Sub/SubRm16R16Handler.cs | 2 +- .../X86/Handlers/Sub/SubRm32R32Handler.cs | 2 +- .../X86/Handlers/Sub/SubRm8R8Handler.cs | 2 +- .../X86/Handlers/Test/TestAlImmHandler.cs | 2 +- .../X86/Handlers/Test/TestEaxImmHandler.cs | 2 +- .../Handlers/Test/TestImmWithRm32Handler.cs | 5 ++--- .../Handlers/Test/TestImmWithRm8Handler.cs | 5 ++--- .../X86/Handlers/Test/TestRegMem8Handler.cs | 2 +- .../X86/Handlers/Test/TestRegMemHandler.cs | 2 +- .../X86/Handlers/Xchg/XchgEaxRegHandler.cs | 2 +- .../X86/Handlers/Xor/XorAlImmHandler.cs | 2 +- .../X86/Handlers/Xor/XorAxImm16Handler.cs | 2 +- .../X86/Handlers/Xor/XorEaxImmHandler.cs | 2 +- .../X86/Handlers/Xor/XorImmWithRm16Handler.cs | 5 ++--- .../Xor/XorImmWithRm16SignExtendedHandler.cs | 5 ++--- .../X86/Handlers/Xor/XorImmWithRm32Handler.cs | 7 +++---- .../Xor/XorImmWithRm32SignExtendedHandler.cs | 7 +++---- .../X86/Handlers/Xor/XorImmWithRm8Handler.cs | 7 +++---- .../X86/Handlers/Xor/XorMemRegHandler.cs | 4 ++-- .../X86/Handlers/Xor/XorR16Rm16Handler.cs | 2 +- .../X86/Handlers/Xor/XorR8Rm8Handler.cs | 2 +- .../X86/Handlers/Xor/XorRegMemHandler.cs | 4 ++-- .../X86/Handlers/Xor/XorRm16R16Handler.cs | 4 ++-- .../X86/Handlers/Xor/XorRm8R8Handler.cs | 2 +- X86Disassembler/X86/InstructionDecoder.cs | 19 ++++--------------- X86Disassembler/X86/ModRMDecoder.cs | 10 ++++------ 97 files changed, 160 insertions(+), 219 deletions(-) diff --git a/X86Disassembler/Decompiler/ControlFlowGraph.cs b/X86Disassembler/Decompiler/ControlFlowGraph.cs index e1c71af..f95fedb 100644 --- a/X86Disassembler/Decompiler/ControlFlowGraph.cs +++ b/X86Disassembler/Decompiler/ControlFlowGraph.cs @@ -1,8 +1,8 @@ namespace X86Disassembler.Decompiler; using System.Collections.Generic; -using X86Disassembler.X86; -using X86Disassembler.X86.Operands; +using X86; +using X86.Operands; /// /// Represents a control flow graph for decompilation diff --git a/X86Disassembler/Decompiler/DataFlowAnalysis.cs b/X86Disassembler/Decompiler/DataFlowAnalysis.cs index 7f5a97d..c1537e0 100644 --- a/X86Disassembler/Decompiler/DataFlowAnalysis.cs +++ b/X86Disassembler/Decompiler/DataFlowAnalysis.cs @@ -1,7 +1,7 @@ namespace X86Disassembler.Decompiler; using System.Collections.Generic; -using X86Disassembler.X86; +using X86; /// /// Performs data flow analysis on x86 instructions diff --git a/X86Disassembler/Decompiler/Decompiler.cs b/X86Disassembler/Decompiler/Decompiler.cs index 7cab669..c5b73eb 100644 --- a/X86Disassembler/Decompiler/Decompiler.cs +++ b/X86Disassembler/Decompiler/Decompiler.cs @@ -4,8 +4,8 @@ using System; using System.Collections.Generic; using System.Linq; using System.Text; -using X86Disassembler.X86; -using X86Disassembler.X86.Operands; +using X86; +using X86.Operands; /// /// Main decompiler class that translates assembly code into higher-level code diff --git a/X86Disassembler/X86/Handlers/Adc/AdcImmToRm32Handler.cs b/X86Disassembler/X86/Handlers/Adc/AdcImmToRm32Handler.cs index 2b69e04..206c8a0 100644 --- a/X86Disassembler/X86/Handlers/Adc/AdcImmToRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Adc/AdcImmToRm32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Adc; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for ADC r/m32, imm32 instruction (0x81 /2) @@ -30,8 +30,7 @@ public class AdcImmToRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 2; // 2 = ADC } @@ -53,7 +52,7 @@ public class AdcImmToRm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); if (!Decoder.CanReadUInt()) { diff --git a/X86Disassembler/X86/Handlers/Adc/AdcImmToRm32SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Adc/AdcImmToRm32SignExtendedHandler.cs index eb26ac5..ed93bdc 100644 --- a/X86Disassembler/X86/Handlers/Adc/AdcImmToRm32SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Adc/AdcImmToRm32SignExtendedHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Adc; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for ADC r/m32, imm8 (sign-extended) instruction (0x83 /2) @@ -30,8 +30,7 @@ public class AdcImmToRm32SignExtendedHandler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 2; // 2 = ADC } @@ -53,7 +52,7 @@ public class AdcImmToRm32SignExtendedHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); if (!Decoder.CanReadByte()) { diff --git a/X86Disassembler/X86/Handlers/Add/AddImmToRm32Handler.cs b/X86Disassembler/X86/Handlers/Add/AddImmToRm32Handler.cs index 85c7260..1b3714c 100644 --- a/X86Disassembler/X86/Handlers/Add/AddImmToRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Add/AddImmToRm32Handler.cs @@ -30,8 +30,7 @@ public class AddImmToRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 0; // 0 = ADD } @@ -53,7 +52,7 @@ public class AddImmToRm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/Add/AddImmToRm32SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Add/AddImmToRm32SignExtendedHandler.cs index 54410ad..1dd9497 100644 --- a/X86Disassembler/X86/Handlers/Add/AddImmToRm32SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Add/AddImmToRm32SignExtendedHandler.cs @@ -30,8 +30,7 @@ public class AddImmToRm32SignExtendedHandler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 0; // 0 = ADD } @@ -52,7 +51,7 @@ public class AddImmToRm32SignExtendedHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Check if we have enough bytes for the immediate value if (!Decoder.CanReadByte()) diff --git a/X86Disassembler/X86/Handlers/Add/AddImmToRm8Handler.cs b/X86Disassembler/X86/Handlers/Add/AddImmToRm8Handler.cs index 35db264..8338846 100644 --- a/X86Disassembler/X86/Handlers/Add/AddImmToRm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Add/AddImmToRm8Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Add; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for ADD r/m8, imm8 instruction (0x80 /0) @@ -29,8 +29,7 @@ public class AddImmToRm8Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 0; // 0 = ADD } @@ -52,7 +51,7 @@ public class AddImmToRm8Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size to 8-bit destOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Add/AddR32Rm32Handler.cs b/X86Disassembler/X86/Handlers/Add/AddR32Rm32Handler.cs index 4b2f4b7..eec5fc4 100644 --- a/X86Disassembler/X86/Handlers/Add/AddR32Rm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Add/AddR32Rm32Handler.cs @@ -47,7 +47,7 @@ public class AddR32Rm32Handler : InstructionHandler // - The reg field specifies the destination register // - The r/m field with mod specifies the source operand (register or memory) // The sourceOperand is already created by ModRMDecoder based on mod and rm fields - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // Create the destination register operand from the reg field var destinationOperand = OperandFactory.CreateRegisterOperand(reg, 32); diff --git a/X86Disassembler/X86/Handlers/Add/AddRm32R32Handler.cs b/X86Disassembler/X86/Handlers/Add/AddRm32R32Handler.cs index 8db7397..22fea1c 100644 --- a/X86Disassembler/X86/Handlers/Add/AddRm32R32Handler.cs +++ b/X86Disassembler/X86/Handlers/Add/AddRm32R32Handler.cs @@ -47,7 +47,7 @@ public class AddRm32R32Handler : InstructionHandler // - The r/m field with mod specifies the destination operand (register or memory) // - The reg field specifies the source register // The destinationOperand is already created by ModRMDecoder based on mod and rm fields - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Create the source register operand from the reg field var sourceOperand = OperandFactory.CreateRegisterOperand(reg, 32); diff --git a/X86Disassembler/X86/Handlers/And/AndImmToRm32Handler.cs b/X86Disassembler/X86/Handlers/And/AndImmToRm32Handler.cs index fcb8d92..18eafc7 100644 --- a/X86Disassembler/X86/Handlers/And/AndImmToRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/And/AndImmToRm32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.And; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for AND r/m32, imm32 instruction (0x81 /4) @@ -30,8 +30,7 @@ public class AndImmToRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 4; // 4 = AND } @@ -53,7 +52,7 @@ public class AndImmToRm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/And/AndImmToRm32SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/And/AndImmToRm32SignExtendedHandler.cs index 66a4cc1..29a7704 100644 --- a/X86Disassembler/X86/Handlers/And/AndImmToRm32SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/And/AndImmToRm32SignExtendedHandler.cs @@ -35,8 +35,7 @@ public class AndImmToRm32SignExtendedHandler : InstructionHandler } // Read the ModR/M byte to check the reg field (bits 5-3) - byte modRM = Decoder.PeakByte(); - int reg = (modRM >> 3) & 0x7; + var reg = ModRMDecoder.PeakModRMReg(); // reg = 4 means AND operation return reg == 4; @@ -57,7 +56,7 @@ public class AndImmToRm32SignExtendedHandler : InstructionHandler // For AND r/m32, imm8 (sign-extended) (0x83 /4): // - The r/m field with mod specifies the destination operand (register or memory) // - The immediate value is the source operand (sign-extended from 8 to 32 bits) - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); if (!Decoder.CanReadByte()) { diff --git a/X86Disassembler/X86/Handlers/And/AndImmToRm8Handler.cs b/X86Disassembler/X86/Handlers/And/AndImmToRm8Handler.cs index 5ecc5b2..4a6fc7f 100644 --- a/X86Disassembler/X86/Handlers/And/AndImmToRm8Handler.cs +++ b/X86Disassembler/X86/Handlers/And/AndImmToRm8Handler.cs @@ -35,8 +35,7 @@ public class AndImmToRm8Handler : InstructionHandler } // Read the ModR/M byte to check the reg field (bits 5-3) - byte modRM = Decoder.PeakByte(); - int reg = (modRM >> 3) & 0x7; + var reg = ModRMDecoder.PeakModRMReg(); // reg = 4 means AND operation return reg == 4; @@ -57,7 +56,7 @@ public class AndImmToRm8Handler : InstructionHandler // For AND r/m8, imm8 (0x80 /4): // - The r/m field with mod specifies the destination operand (register or memory) // - The immediate value is the source operand - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size to 8-bit destinationOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/And/AndImmWithRm32Handler.cs b/X86Disassembler/X86/Handlers/And/AndImmWithRm32Handler.cs index 9f1d8ed..64861f6 100644 --- a/X86Disassembler/X86/Handlers/And/AndImmWithRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/And/AndImmWithRm32Handler.cs @@ -30,8 +30,7 @@ public class AndImmWithRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 4; // 4 = AND } @@ -51,7 +50,7 @@ public class AndImmWithRm32Handler : InstructionHandler // For AND r/m32, imm32 (0x81 /4): // - The r/m field with mod specifies the destination operand (register or memory) // - The immediate value is the source operand - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Check if we have enough bytes for the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/And/AndMemRegHandler.cs b/X86Disassembler/X86/Handlers/And/AndMemRegHandler.cs index 02caa52..c721469 100644 --- a/X86Disassembler/X86/Handlers/And/AndMemRegHandler.cs +++ b/X86Disassembler/X86/Handlers/And/AndMemRegHandler.cs @@ -46,7 +46,7 @@ public class AndMemRegHandler : InstructionHandler // For AND r/m32, r32 (0x21): // - The r/m field with mod specifies the destination operand (register or memory) // - The reg field specifies the source register - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Create the source register operand var sourceOperand = OperandFactory.CreateRegisterOperand(reg, 32); diff --git a/X86Disassembler/X86/Handlers/And/AndR32Rm32Handler.cs b/X86Disassembler/X86/Handlers/And/AndR32Rm32Handler.cs index 1937af1..017fc21 100644 --- a/X86Disassembler/X86/Handlers/And/AndR32Rm32Handler.cs +++ b/X86Disassembler/X86/Handlers/And/AndR32Rm32Handler.cs @@ -46,7 +46,7 @@ public class AndR32Rm32Handler : InstructionHandler // For AND r32, r/m32 (0x23): // - The reg field specifies the destination register // - The r/m field with mod specifies the source operand (register or memory) - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // Create the destination register operand var destinationOperand = OperandFactory.CreateRegisterOperand(reg, 32); diff --git a/X86Disassembler/X86/Handlers/And/AndR8Rm8Handler.cs b/X86Disassembler/X86/Handlers/And/AndR8Rm8Handler.cs index c4d9560..61539cb 100644 --- a/X86Disassembler/X86/Handlers/And/AndR8Rm8Handler.cs +++ b/X86Disassembler/X86/Handlers/And/AndR8Rm8Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.And; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for AND r8, r/m8 instruction (0x22) diff --git a/X86Disassembler/X86/Handlers/And/AndRm8R8Handler.cs b/X86Disassembler/X86/Handlers/And/AndRm8R8Handler.cs index 57ce0f1..63b2a6c 100644 --- a/X86Disassembler/X86/Handlers/And/AndRm8R8Handler.cs +++ b/X86Disassembler/X86/Handlers/And/AndRm8R8Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.And; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for AND r/m8, r8 instruction (0x20) diff --git a/X86Disassembler/X86/Handlers/ArithmeticUnary/DivRm32Handler.cs b/X86Disassembler/X86/Handlers/ArithmeticUnary/DivRm32Handler.cs index e8edfec..06e91dc 100644 --- a/X86Disassembler/X86/Handlers/ArithmeticUnary/DivRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/ArithmeticUnary/DivRm32Handler.cs @@ -30,8 +30,7 @@ public class DivRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 6; // 6 = DIV } @@ -55,7 +54,7 @@ public class DivRm32Handler : InstructionHandler // Read the ModR/M byte // For DIV r/m32 (0xF7 /6): // - The r/m field with mod specifies the operand (register or memory) - var (mod, reg, rm, operand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, operand) = ModRMDecoder.ReadModRM(); // Verify this is a DIV instruction // The reg field should be 6 (DIV), which maps to RegisterIndex.Si in our enum diff --git a/X86Disassembler/X86/Handlers/ArithmeticUnary/IdivRm32Handler.cs b/X86Disassembler/X86/Handlers/ArithmeticUnary/IdivRm32Handler.cs index 78cc3b4..ec7b0a5 100644 --- a/X86Disassembler/X86/Handlers/ArithmeticUnary/IdivRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/ArithmeticUnary/IdivRm32Handler.cs @@ -30,8 +30,7 @@ public class IdivRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 7; // 7 = IDIV } @@ -55,7 +54,7 @@ public class IdivRm32Handler : InstructionHandler // Read the ModR/M byte // For IDIV r/m32 (0xF7 /7): // - The r/m field with mod specifies the operand (register or memory) - var (mod, reg, rm, operand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, operand) = ModRMDecoder.ReadModRM(); // Verify this is an IDIV instruction // The reg field should be 7 (IDIV) diff --git a/X86Disassembler/X86/Handlers/ArithmeticUnary/ImulRm32Handler.cs b/X86Disassembler/X86/Handlers/ArithmeticUnary/ImulRm32Handler.cs index d9af297..fae0383 100644 --- a/X86Disassembler/X86/Handlers/ArithmeticUnary/ImulRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/ArithmeticUnary/ImulRm32Handler.cs @@ -30,8 +30,7 @@ public class ImulRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 5; // 5 = IMUL } @@ -55,7 +54,7 @@ public class ImulRm32Handler : InstructionHandler // Read the ModR/M byte // For IMUL r/m32 (0xF7 /5): // - The r/m field with mod specifies the operand (register or memory) - var (mod, reg, rm, operand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, operand) = ModRMDecoder.ReadModRM(); // Verify this is an IMUL instruction // The reg field should be 5 (IMUL), which maps to RegisterIndex.Bp in our enum diff --git a/X86Disassembler/X86/Handlers/ArithmeticUnary/MulRm32Handler.cs b/X86Disassembler/X86/Handlers/ArithmeticUnary/MulRm32Handler.cs index 09ec608..4e147a4 100644 --- a/X86Disassembler/X86/Handlers/ArithmeticUnary/MulRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/ArithmeticUnary/MulRm32Handler.cs @@ -30,8 +30,7 @@ public class MulRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 4; // 4 = MUL } @@ -55,7 +54,7 @@ public class MulRm32Handler : InstructionHandler // Read the ModR/M byte // For MUL r/m32 (0xF7 /4): // - The r/m field with mod specifies the operand (register or memory) - var (mod, reg, rm, operand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, operand) = ModRMDecoder.ReadModRM(); // Verify this is a MUL instruction // The reg field should be 4 (MUL), which maps to RegisterIndex.Sp in our enum diff --git a/X86Disassembler/X86/Handlers/ArithmeticUnary/NegRm32Handler.cs b/X86Disassembler/X86/Handlers/ArithmeticUnary/NegRm32Handler.cs index e2df3c4..8bd3659 100644 --- a/X86Disassembler/X86/Handlers/ArithmeticUnary/NegRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/ArithmeticUnary/NegRm32Handler.cs @@ -30,8 +30,7 @@ public class NegRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 3; // 3 = NEG } @@ -55,7 +54,7 @@ public class NegRm32Handler : InstructionHandler // Read the ModR/M byte // For NEG r/m32 (0xF7 /3): // - The r/m field with mod specifies the operand (register or memory) - var (mod, reg, rm, operand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, operand) = ModRMDecoder.ReadModRM(); // Verify this is a NEG instruction // The reg field should be 3 (NEG), which maps to RegisterIndex.B in our enum diff --git a/X86Disassembler/X86/Handlers/ArithmeticUnary/NotRm32Handler.cs b/X86Disassembler/X86/Handlers/ArithmeticUnary/NotRm32Handler.cs index 3e470db..7311f54 100644 --- a/X86Disassembler/X86/Handlers/ArithmeticUnary/NotRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/ArithmeticUnary/NotRm32Handler.cs @@ -31,8 +31,7 @@ public class NotRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 2; // 2 = NOT } @@ -56,7 +55,7 @@ public class NotRm32Handler : InstructionHandler // Read the ModR/M byte // For NOT r/m32 (0xF7 /2): // - The r/m field with mod specifies the operand (register or memory) - var (mod, reg, rm, operand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, operand) = ModRMDecoder.ReadModRM(); // Verify this is a NOT instruction // The reg field should be 2 (NOT), which maps to RegisterIndex.D in our enum diff --git a/X86Disassembler/X86/Handlers/Call/CallRel32Handler.cs b/X86Disassembler/X86/Handlers/Call/CallRel32Handler.cs index a8101d3..da10659 100644 --- a/X86Disassembler/X86/Handlers/Call/CallRel32Handler.cs +++ b/X86Disassembler/X86/Handlers/Call/CallRel32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Call; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for CALL rel32 instruction (0xE8) diff --git a/X86Disassembler/X86/Handlers/Call/CallRm32Handler.cs b/X86Disassembler/X86/Handlers/Call/CallRm32Handler.cs index 3a9f882..95f04f3 100644 --- a/X86Disassembler/X86/Handlers/Call/CallRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Call/CallRm32Handler.cs @@ -35,11 +35,8 @@ public class CallRm32Handler : InstructionHandler return false; } - // Peek at the ModR/M byte without advancing the position - byte modRM = Decoder.PeakByte(); - // Extract the reg field (bits 3-5) - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); // CALL r/m32 is encoded as FF /2 (reg field = 2) return reg == 2; @@ -65,7 +62,7 @@ public class CallRm32Handler : InstructionHandler // Read the ModR/M byte // For CALL r/m32 (FF /2): // - The r/m field with mod specifies the operand (register or memory) - var (mod, reg, rm, operand) = ModRMDecoder.ReadModRM(); + var (_, _, _, operand) = ModRMDecoder.ReadModRM(); // Set the structured operands // CALL has only one operand diff --git a/X86Disassembler/X86/Handlers/Cmp/CmpAlImmHandler.cs b/X86Disassembler/X86/Handlers/Cmp/CmpAlImmHandler.cs index d583670..f7dcf8b 100644 --- a/X86Disassembler/X86/Handlers/Cmp/CmpAlImmHandler.cs +++ b/X86Disassembler/X86/Handlers/Cmp/CmpAlImmHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Cmp; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for CMP AL, imm8 instruction (0x3C) diff --git a/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm32Handler.cs b/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm32Handler.cs index c43f42a..e464bd0 100644 --- a/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm32Handler.cs @@ -30,8 +30,7 @@ public class CmpImmWithRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 7; // 7 = CMP } @@ -48,7 +47,7 @@ public class CmpImmWithRm32Handler : InstructionHandler instruction.Type = InstructionType.Cmp; // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm32SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm32SignExtendedHandler.cs index b03b2b2..a00de84 100644 --- a/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm32SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm32SignExtendedHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Cmp; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for CMP r/m32, imm8 (sign-extended) instruction (0x83 /7) @@ -30,8 +30,7 @@ public class CmpImmWithRm32SignExtendedHandler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 7; // 7 = CMP } @@ -53,7 +52,7 @@ public class CmpImmWithRm32SignExtendedHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value if (!Decoder.CanReadByte()) diff --git a/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm8Handler.cs b/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm8Handler.cs index 99a6b60..b46bb7e 100644 --- a/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Cmp/CmpImmWithRm8Handler.cs @@ -30,8 +30,7 @@ public class CmpImmWithRm8Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 7; // 7 = CMP } @@ -48,7 +47,7 @@ public class CmpImmWithRm8Handler : InstructionHandler instruction.Type = InstructionType.Cmp; // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Ensure the destination operand has the correct size (8-bit) destinationOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Cmp/CmpR32Rm32Handler.cs b/X86Disassembler/X86/Handlers/Cmp/CmpR32Rm32Handler.cs index f8462cf..cf1fa3d 100644 --- a/X86Disassembler/X86/Handlers/Cmp/CmpR32Rm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Cmp/CmpR32Rm32Handler.cs @@ -43,7 +43,7 @@ public class CmpR32Rm32Handler : InstructionHandler instruction.Type = InstructionType.Cmp; // Read the ModR/M byte - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // Create the destination register operand (32-bit) var destinationOperand = OperandFactory.CreateRegisterOperand((RegisterIndex)reg, 32); diff --git a/X86Disassembler/X86/Handlers/Cmp/CmpRm32R32Handler.cs b/X86Disassembler/X86/Handlers/Cmp/CmpRm32R32Handler.cs index 20b651d..99905c9 100644 --- a/X86Disassembler/X86/Handlers/Cmp/CmpRm32R32Handler.cs +++ b/X86Disassembler/X86/Handlers/Cmp/CmpRm32R32Handler.cs @@ -46,7 +46,7 @@ public class CmpRm32R32Handler : InstructionHandler // For CMP r/m32, r32 (0x39): // - The r/m field with mod specifies the destination operand (register or memory) // - The reg field specifies the source register - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Create the source register operand var sourceOperand = OperandFactory.CreateRegisterOperand(reg, 32); diff --git a/X86Disassembler/X86/Handlers/Dec/DecRegHandler.cs b/X86Disassembler/X86/Handlers/Dec/DecRegHandler.cs index 138a0ee..085db94 100644 --- a/X86Disassembler/X86/Handlers/Dec/DecRegHandler.cs +++ b/X86Disassembler/X86/Handlers/Dec/DecRegHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Dec; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for DEC r32 instructions (0x48-0x4F) diff --git a/X86Disassembler/X86/Handlers/FloatingPoint/FnstswHandler.cs b/X86Disassembler/X86/Handlers/FloatingPoint/FnstswHandler.cs index aa10c66..ed628cd 100644 --- a/X86Disassembler/X86/Handlers/FloatingPoint/FnstswHandler.cs +++ b/X86Disassembler/X86/Handlers/FloatingPoint/FnstswHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.FloatingPoint; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for FNSTSW AX instruction (0xDF 0xE0) diff --git a/X86Disassembler/X86/Handlers/Inc/IncRegHandler.cs b/X86Disassembler/X86/Handlers/Inc/IncRegHandler.cs index d5826e6..1bee3f2 100644 --- a/X86Disassembler/X86/Handlers/Inc/IncRegHandler.cs +++ b/X86Disassembler/X86/Handlers/Inc/IncRegHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Inc; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for INC r32 instructions (0x40-0x47) diff --git a/X86Disassembler/X86/Handlers/Jump/ConditionalJumpHandler.cs b/X86Disassembler/X86/Handlers/Jump/ConditionalJumpHandler.cs index bcf0e6d..a07eb64 100644 --- a/X86Disassembler/X86/Handlers/Jump/ConditionalJumpHandler.cs +++ b/X86Disassembler/X86/Handlers/Jump/ConditionalJumpHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Jump; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for conditional jump instructions (0x70-0x7F) diff --git a/X86Disassembler/X86/Handlers/Jump/JgeRel8Handler.cs b/X86Disassembler/X86/Handlers/Jump/JgeRel8Handler.cs index 77bd932..8adca77 100644 --- a/X86Disassembler/X86/Handlers/Jump/JgeRel8Handler.cs +++ b/X86Disassembler/X86/Handlers/Jump/JgeRel8Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Jump; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for JGE rel8 instruction (0x7D) diff --git a/X86Disassembler/X86/Handlers/Jump/JmpRel32Handler.cs b/X86Disassembler/X86/Handlers/Jump/JmpRel32Handler.cs index 1d6ffdb..37253bf 100644 --- a/X86Disassembler/X86/Handlers/Jump/JmpRel32Handler.cs +++ b/X86Disassembler/X86/Handlers/Jump/JmpRel32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Jump; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for JMP rel32 instruction (0xE9) diff --git a/X86Disassembler/X86/Handlers/Jump/JmpRel8Handler.cs b/X86Disassembler/X86/Handlers/Jump/JmpRel8Handler.cs index de5b107..9f680f3 100644 --- a/X86Disassembler/X86/Handlers/Jump/JmpRel8Handler.cs +++ b/X86Disassembler/X86/Handlers/Jump/JmpRel8Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Jump; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for JMP rel8 instruction (0xEB) diff --git a/X86Disassembler/X86/Handlers/Jump/TwoByteConditionalJumpHandler.cs b/X86Disassembler/X86/Handlers/Jump/TwoByteConditionalJumpHandler.cs index 68bd422..9e85996 100644 --- a/X86Disassembler/X86/Handlers/Jump/TwoByteConditionalJumpHandler.cs +++ b/X86Disassembler/X86/Handlers/Jump/TwoByteConditionalJumpHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Jump; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for two-byte conditional jump instructions (0x0F 0x80-0x8F) @@ -44,8 +44,7 @@ public class TwoByteConditionalJumpHandler : InstructionHandler { return false; } - - int position = Decoder.GetPosition(); + if (!Decoder.CanReadByte()) { return false; diff --git a/X86Disassembler/X86/Handlers/Lea/LeaR32MHandler.cs b/X86Disassembler/X86/Handlers/Lea/LeaR32MHandler.cs index 6bb5c41..dda70df 100644 --- a/X86Disassembler/X86/Handlers/Lea/LeaR32MHandler.cs +++ b/X86Disassembler/X86/Handlers/Lea/LeaR32MHandler.cs @@ -41,7 +41,7 @@ public class LeaR32MHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (mod, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // LEA only works with memory operands, not registers if (mod == 3) diff --git a/X86Disassembler/X86/Handlers/Mov/MovMemRegHandler.cs b/X86Disassembler/X86/Handlers/Mov/MovMemRegHandler.cs index b5de559..9f01045 100644 --- a/X86Disassembler/X86/Handlers/Mov/MovMemRegHandler.cs +++ b/X86Disassembler/X86/Handlers/Mov/MovMemRegHandler.cs @@ -51,7 +51,7 @@ public class MovMemRegHandler : InstructionHandler // For MOV r/m32, r32 (0x89) or MOV r/m8, r8 (0x88): // - The r/m field with mod specifies the destination operand (register or memory) // - The reg field specifies the source register - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size based on the opcode destinationOperand.Size = operandSize; diff --git a/X86Disassembler/X86/Handlers/Mov/MovRegMemHandler.cs b/X86Disassembler/X86/Handlers/Mov/MovRegMemHandler.cs index 8a5b056..2521b2a 100644 --- a/X86Disassembler/X86/Handlers/Mov/MovRegMemHandler.cs +++ b/X86Disassembler/X86/Handlers/Mov/MovRegMemHandler.cs @@ -50,7 +50,7 @@ public class MovRegMemHandler : InstructionHandler // For MOV r32, r/m32 (0x8B) or MOV r8, r/m8 (0x8A): // - The reg field specifies the destination register // - The r/m field with mod specifies the source operand (register or memory) - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size based on the opcode sourceOperand.Size = operandSize; diff --git a/X86Disassembler/X86/Handlers/Mov/MovRm32Imm32Handler.cs b/X86Disassembler/X86/Handlers/Mov/MovRm32Imm32Handler.cs index 14e0dfe..15823d4 100644 --- a/X86Disassembler/X86/Handlers/Mov/MovRm32Imm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Mov/MovRm32Imm32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Mov; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for MOV r/m32, imm32 instruction (0xC7) @@ -38,7 +38,7 @@ public class MovRm32Imm32Handler : InstructionHandler instruction.Type = InstructionType.Mov; // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // MOV r/m32, imm32 only uses reg=0 if (reg != 0) diff --git a/X86Disassembler/X86/Handlers/Mov/MovRm8Imm8Handler.cs b/X86Disassembler/X86/Handlers/Mov/MovRm8Imm8Handler.cs index 4bd4a7a..17e6dc4 100644 --- a/X86Disassembler/X86/Handlers/Mov/MovRm8Imm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Mov/MovRm8Imm8Handler.cs @@ -47,7 +47,7 @@ public class MovRm8Imm8Handler : InstructionHandler // For MOV r/m8, imm8 (0xC6): // - The r/m field with mod specifies the destination operand (register or memory) // - The immediate value is the source operand - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // MOV r/m8, imm8 only uses reg=0 if (reg != 0) diff --git a/X86Disassembler/X86/Handlers/Nop/MultiByteNopHandler.cs b/X86Disassembler/X86/Handlers/Nop/MultiByteNopHandler.cs index 9e7c667..94152d2 100644 --- a/X86Disassembler/X86/Handlers/Nop/MultiByteNopHandler.cs +++ b/X86Disassembler/X86/Handlers/Nop/MultiByteNopHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Nop; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for multi-byte NOP instructions (0x0F 0x1F ...) diff --git a/X86Disassembler/X86/Handlers/Or/OrAlImmHandler.cs b/X86Disassembler/X86/Handlers/Or/OrAlImmHandler.cs index 30766c2..0591c66 100644 --- a/X86Disassembler/X86/Handlers/Or/OrAlImmHandler.cs +++ b/X86Disassembler/X86/Handlers/Or/OrAlImmHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Or; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for OR AL, imm8 instruction (0x0C) diff --git a/X86Disassembler/X86/Handlers/Or/OrEaxImmHandler.cs b/X86Disassembler/X86/Handlers/Or/OrEaxImmHandler.cs index 4486935..9b13239 100644 --- a/X86Disassembler/X86/Handlers/Or/OrEaxImmHandler.cs +++ b/X86Disassembler/X86/Handlers/Or/OrEaxImmHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Or; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for OR EAX, imm32 instruction (0x0D) diff --git a/X86Disassembler/X86/Handlers/Or/OrImmToRm32Handler.cs b/X86Disassembler/X86/Handlers/Or/OrImmToRm32Handler.cs index 9509638..5f28aa9 100644 --- a/X86Disassembler/X86/Handlers/Or/OrImmToRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Or/OrImmToRm32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Or; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for OR r/m32, imm32 instruction (0x81 /1) @@ -30,8 +30,7 @@ public class OrImmToRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 1; // 1 = OR } @@ -53,7 +52,7 @@ public class OrImmToRm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Check if we can read the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/Or/OrImmToRm32SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Or/OrImmToRm32SignExtendedHandler.cs index 273ac56..dcd2fe5 100644 --- a/X86Disassembler/X86/Handlers/Or/OrImmToRm32SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Or/OrImmToRm32SignExtendedHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Or; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for OR r/m32, imm8 (sign-extended) instruction (0x83 /1) @@ -30,8 +30,7 @@ public class OrImmToRm32SignExtendedHandler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 1; // 1 = OR } @@ -53,7 +52,7 @@ public class OrImmToRm32SignExtendedHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value (sign-extended from 8 to 32 bits) if (!Decoder.CanReadByte()) diff --git a/X86Disassembler/X86/Handlers/Or/OrImmToRm8Handler.cs b/X86Disassembler/X86/Handlers/Or/OrImmToRm8Handler.cs index af225f0..674797c 100644 --- a/X86Disassembler/X86/Handlers/Or/OrImmToRm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Or/OrImmToRm8Handler.cs @@ -30,8 +30,7 @@ public class OrImmToRm8Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 1; // 1 = OR } @@ -56,7 +55,7 @@ public class OrImmToRm8Handler : InstructionHandler // For OR r/m8, imm8 (0x80 /1): // - The r/m field with mod specifies the destination operand (register or memory) // - The immediate value is the source operand - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size to 8-bit destinationOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Or/OrR32Rm32Handler.cs b/X86Disassembler/X86/Handlers/Or/OrR32Rm32Handler.cs index 704e885..8e6fbd0 100644 --- a/X86Disassembler/X86/Handlers/Or/OrR32Rm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Or/OrR32Rm32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Or; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for OR r32, r/m32 instruction (0x0B) diff --git a/X86Disassembler/X86/Handlers/Or/OrR8Rm8Handler.cs b/X86Disassembler/X86/Handlers/Or/OrR8Rm8Handler.cs index f9dd52d..0067809 100644 --- a/X86Disassembler/X86/Handlers/Or/OrR8Rm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Or/OrR8Rm8Handler.cs @@ -46,7 +46,7 @@ public class OrR8Rm8Handler : InstructionHandler // For OR r8, r/m8 (0x0A): // - The reg field specifies the destination register // - The r/m field with mod specifies the source operand (register or memory) - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size to 8-bit sourceOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Or/OrRm8R8Handler.cs b/X86Disassembler/X86/Handlers/Or/OrRm8R8Handler.cs index 7773618..71fd2f9 100644 --- a/X86Disassembler/X86/Handlers/Or/OrRm8R8Handler.cs +++ b/X86Disassembler/X86/Handlers/Or/OrRm8R8Handler.cs @@ -29,9 +29,6 @@ public class OrRm8R8Handler : InstructionHandler // Check if we can read the ModR/M byte if (!Decoder.CanReadByte()) return false; - - // Peek at the ModR/M byte to verify this is the correct instruction - byte modRM = Decoder.PeakByte(); return true; } @@ -54,7 +51,7 @@ public class OrRm8R8Handler : InstructionHandler } // Read the ModR/M byte, specifying that we're dealing with 8-bit operands - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM8(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM8(); // Adjust the operand size to 8-bit destinationOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Pop/PopRegHandler.cs b/X86Disassembler/X86/Handlers/Pop/PopRegHandler.cs index 2ed443e..e3ab59d 100644 --- a/X86Disassembler/X86/Handlers/Pop/PopRegHandler.cs +++ b/X86Disassembler/X86/Handlers/Pop/PopRegHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Pop; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for POP r32 instruction (0x58-0x5F) diff --git a/X86Disassembler/X86/Handlers/Push/PushImm32Handler.cs b/X86Disassembler/X86/Handlers/Push/PushImm32Handler.cs index 0ecd76e..7b22434 100644 --- a/X86Disassembler/X86/Handlers/Push/PushImm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Push/PushImm32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Push; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for PUSH imm32 instruction (0x68) diff --git a/X86Disassembler/X86/Handlers/Push/PushImm8Handler.cs b/X86Disassembler/X86/Handlers/Push/PushImm8Handler.cs index 1ca810d..6173dbf 100644 --- a/X86Disassembler/X86/Handlers/Push/PushImm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Push/PushImm8Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Push; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for PUSH imm8 instruction (0x6A) diff --git a/X86Disassembler/X86/Handlers/Push/PushRegHandler.cs b/X86Disassembler/X86/Handlers/Push/PushRegHandler.cs index 6a0537a..da81edb 100644 --- a/X86Disassembler/X86/Handlers/Push/PushRegHandler.cs +++ b/X86Disassembler/X86/Handlers/Push/PushRegHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Push; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for PUSH r32 instruction (0x50-0x57) diff --git a/X86Disassembler/X86/Handlers/Push/PushRm32Handler.cs b/X86Disassembler/X86/Handlers/Push/PushRm32Handler.cs index 523ac45..8a9a5d0 100644 --- a/X86Disassembler/X86/Handlers/Push/PushRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Push/PushRm32Handler.cs @@ -34,12 +34,8 @@ public class PushRm32Handler : InstructionHandler { return false; } - - // Peek at the ModR/M byte without advancing the position - byte modRM = Decoder.PeakByte(); - - // Extract the reg field (bits 3-5) - byte reg = (byte)((modRM & 0x38) >> 3); + + var reg = ModRMDecoder.PeakModRMReg(); // PUSH r/m32 is encoded as FF /6 (reg field = 6) return reg == 6; @@ -65,7 +61,7 @@ public class PushRm32Handler : InstructionHandler // Read the ModR/M byte // For PUSH r/m32 (FF /6): // - The r/m field with mod specifies the operand (register or memory) - var (mod, reg, rm, operand) = ModRMDecoder.ReadModRM(); + var (_, _, _, operand) = ModRMDecoder.ReadModRM(); // Set the structured operands // PUSH has only one operand diff --git a/X86Disassembler/X86/Handlers/Ret/RetImmHandler.cs b/X86Disassembler/X86/Handlers/Ret/RetImmHandler.cs index 0b11930..1f5b9fa 100644 --- a/X86Disassembler/X86/Handlers/Ret/RetImmHandler.cs +++ b/X86Disassembler/X86/Handlers/Ret/RetImmHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Ret; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for RET instruction with immediate operand (0xC2) diff --git a/X86Disassembler/X86/Handlers/Sbb/SbbImmFromRm32Handler.cs b/X86Disassembler/X86/Handlers/Sbb/SbbImmFromRm32Handler.cs index 3c2d115..108e47f 100644 --- a/X86Disassembler/X86/Handlers/Sbb/SbbImmFromRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Sbb/SbbImmFromRm32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Sbb; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for SBB r/m32, imm32 instruction (0x81 /3) @@ -30,8 +30,7 @@ public class SbbImmFromRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 3; // 3 = SBB } @@ -53,7 +52,7 @@ public class SbbImmFromRm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/Sbb/SbbImmFromRm32SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Sbb/SbbImmFromRm32SignExtendedHandler.cs index f8afaf3..157550d 100644 --- a/X86Disassembler/X86/Handlers/Sbb/SbbImmFromRm32SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Sbb/SbbImmFromRm32SignExtendedHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Sbb; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for SBB r/m32, imm8 (sign-extended) instruction (0x83 /3) @@ -30,8 +30,7 @@ public class SbbImmFromRm32SignExtendedHandler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 3; // 3 = SBB } @@ -53,7 +52,7 @@ public class SbbImmFromRm32SignExtendedHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value (sign-extended from 8 to 32 bits) if (!Decoder.CanReadByte()) diff --git a/X86Disassembler/X86/Handlers/String/StringInstructionHandler.cs b/X86Disassembler/X86/Handlers/String/StringInstructionHandler.cs index 265f7fb..376d6db 100644 --- a/X86Disassembler/X86/Handlers/String/StringInstructionHandler.cs +++ b/X86Disassembler/X86/Handlers/String/StringInstructionHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.String; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for string instructions (MOVS, STOS, LODS, SCAS) with and without REP/REPNE prefixes diff --git a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm16Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm16Handler.cs index f5c867f..3a2b551 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm16Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm16Handler.cs @@ -36,8 +36,7 @@ public class SubImmFromRm16Handler : InstructionHandler } // Check if the reg field is 5 (SUB) - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 5; // 5 = SUB } @@ -63,7 +62,7 @@ public class SubImmFromRm16Handler : InstructionHandler // For SUB r/m16, imm16 (0x81 /5 with 0x66 prefix): // - The r/m field with mod specifies the destination operand (register or memory) // - The immediate value is the source operand - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size to 16-bit destinationOperand.Size = 16; diff --git a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm16SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm16SignExtendedHandler.cs index ac745da..4e7bdbe 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm16SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm16SignExtendedHandler.cs @@ -36,8 +36,7 @@ public class SubImmFromRm16SignExtendedHandler : InstructionHandler } // Check if the reg field is 5 (SUB) - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 5; // 5 = SUB } @@ -63,7 +62,7 @@ public class SubImmFromRm16SignExtendedHandler : InstructionHandler // For SUB r/m16, imm8 (0x83 /5 with 0x66 prefix and sign extension): // - The r/m field with mod specifies the destination operand (register or memory) // - The immediate value is the source operand (sign-extended from 8 to 16 bits) - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size to 16-bit destinationOperand.Size = 16; diff --git a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm32Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm32Handler.cs index 38f81b1..f592cd4 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm32Handler.cs @@ -30,8 +30,7 @@ public class SubImmFromRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 5; // 5 = SUB } @@ -53,7 +52,7 @@ public class SubImmFromRm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm32SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm32SignExtendedHandler.cs index b09e91c..83d6c32 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm32SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm32SignExtendedHandler.cs @@ -30,8 +30,7 @@ public class SubImmFromRm32SignExtendedHandler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 5; // 5 = SUB } @@ -54,7 +53,7 @@ public class SubImmFromRm32SignExtendedHandler : InstructionHandler } // Extract the fields from the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Check if we have enough bytes for the immediate value if (!Decoder.CanReadByte()) diff --git a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm8Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm8Handler.cs index a98da40..c81f2ea 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubImmFromRm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubImmFromRm8Handler.cs @@ -30,8 +30,7 @@ public class SubImmFromRm8Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte) ((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 5; // 5 = SUB } @@ -48,7 +47,7 @@ public class SubImmFromRm8Handler : InstructionHandler instruction.Type = InstructionType.Sub; // Read the ModR/M byte, specifying that we're dealing with 8-bit operands - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM8(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM8(); // Ensure the destination operand has the correct size (8-bit) destinationOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Sub/SubR16Rm16Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubR16Rm16Handler.cs index b4a3a15..29989af 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubR16Rm16Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubR16Rm16Handler.cs @@ -44,7 +44,7 @@ public class SubR16Rm16Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // Ensure the source operand has the correct size (16-bit) sourceOperand.Size = 16; diff --git a/X86Disassembler/X86/Handlers/Sub/SubR32Rm32Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubR32Rm32Handler.cs index a7257e6..c1ec14e 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubR32Rm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubR32Rm32Handler.cs @@ -40,7 +40,7 @@ public class SubR32Rm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // Set the instruction type instruction.Type = InstructionType.Sub; diff --git a/X86Disassembler/X86/Handlers/Sub/SubR8Rm8Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubR8Rm8Handler.cs index d555f42..f794a27 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubR8Rm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubR8Rm8Handler.cs @@ -43,7 +43,7 @@ public class SubR8Rm8Handler : InstructionHandler } // Read the ModR/M byte, specifying that we're dealing with 8-bit operands - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM8(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM8(); // Ensure the source operand has the correct size (8-bit) sourceOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Sub/SubRm16R16Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubRm16R16Handler.cs index 410536b..2714337 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubRm16R16Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubRm16R16Handler.cs @@ -44,7 +44,7 @@ public class SubRm16R16Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Ensure the destination operand has the correct size (16-bit) destinationOperand.Size = 16; diff --git a/X86Disassembler/X86/Handlers/Sub/SubRm32R32Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubRm32R32Handler.cs index 6aac6f0..58ff242 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubRm32R32Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubRm32R32Handler.cs @@ -43,7 +43,7 @@ public class SubRm32R32Handler : InstructionHandler instruction.Type = InstructionType.Sub; // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Create the source register operand (32-bit) var sourceOperand = OperandFactory.CreateRegisterOperand((RegisterIndex)reg, 32); diff --git a/X86Disassembler/X86/Handlers/Sub/SubRm8R8Handler.cs b/X86Disassembler/X86/Handlers/Sub/SubRm8R8Handler.cs index aae3392..c8a47fc 100644 --- a/X86Disassembler/X86/Handlers/Sub/SubRm8R8Handler.cs +++ b/X86Disassembler/X86/Handlers/Sub/SubRm8R8Handler.cs @@ -38,7 +38,7 @@ public class SubRm8R8Handler : InstructionHandler instruction.Type = InstructionType.Sub; // Read the ModR/M byte, specifying that we're dealing with 8-bit operands - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM8(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM8(); // Ensure the destination operand has the correct size (8-bit) destinationOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Test/TestAlImmHandler.cs b/X86Disassembler/X86/Handlers/Test/TestAlImmHandler.cs index b081060..01e2bba 100644 --- a/X86Disassembler/X86/Handlers/Test/TestAlImmHandler.cs +++ b/X86Disassembler/X86/Handlers/Test/TestAlImmHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Test; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for TEST AL, imm8 instruction (0xA8) diff --git a/X86Disassembler/X86/Handlers/Test/TestEaxImmHandler.cs b/X86Disassembler/X86/Handlers/Test/TestEaxImmHandler.cs index 4de6fec..0d9ea75 100644 --- a/X86Disassembler/X86/Handlers/Test/TestEaxImmHandler.cs +++ b/X86Disassembler/X86/Handlers/Test/TestEaxImmHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Test; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for TEST EAX, imm32 instruction (0xA9) diff --git a/X86Disassembler/X86/Handlers/Test/TestImmWithRm32Handler.cs b/X86Disassembler/X86/Handlers/Test/TestImmWithRm32Handler.cs index 20a7cdf..31ae5e6 100644 --- a/X86Disassembler/X86/Handlers/Test/TestImmWithRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Test/TestImmWithRm32Handler.cs @@ -36,8 +36,7 @@ public class TestImmWithRm32Handler : InstructionHandler } // Check if the reg field is 0 (TEST operation) - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 0; // 0 = TEST } @@ -59,7 +58,7 @@ public class TestImmWithRm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/Test/TestImmWithRm8Handler.cs b/X86Disassembler/X86/Handlers/Test/TestImmWithRm8Handler.cs index 0aa7c7e..905ad34 100644 --- a/X86Disassembler/X86/Handlers/Test/TestImmWithRm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Test/TestImmWithRm8Handler.cs @@ -36,8 +36,7 @@ public class TestImmWithRm8Handler : InstructionHandler } // Check if the reg field is 0 (TEST operation) - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 0; // 0 = TEST } @@ -54,7 +53,7 @@ public class TestImmWithRm8Handler : InstructionHandler instruction.Type = InstructionType.Test; // Read the ModR/M byte, specifying that we're dealing with 8-bit operands - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM8(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM8(); // Check if we have enough bytes for the immediate value if (!Decoder.CanReadByte()) diff --git a/X86Disassembler/X86/Handlers/Test/TestRegMem8Handler.cs b/X86Disassembler/X86/Handlers/Test/TestRegMem8Handler.cs index 231695e..546bc6e 100644 --- a/X86Disassembler/X86/Handlers/Test/TestRegMem8Handler.cs +++ b/X86Disassembler/X86/Handlers/Test/TestRegMem8Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Test; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for TEST r/m8, r8 instruction (0x84) diff --git a/X86Disassembler/X86/Handlers/Test/TestRegMemHandler.cs b/X86Disassembler/X86/Handlers/Test/TestRegMemHandler.cs index e3412f6..73998e1 100644 --- a/X86Disassembler/X86/Handlers/Test/TestRegMemHandler.cs +++ b/X86Disassembler/X86/Handlers/Test/TestRegMemHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Test; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for TEST r/m32, r32 instruction (0x85) diff --git a/X86Disassembler/X86/Handlers/Xchg/XchgEaxRegHandler.cs b/X86Disassembler/X86/Handlers/Xchg/XchgEaxRegHandler.cs index 809368b..32ea7ea 100644 --- a/X86Disassembler/X86/Handlers/Xchg/XchgEaxRegHandler.cs +++ b/X86Disassembler/X86/Handlers/Xchg/XchgEaxRegHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xchg; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XCHG EAX, r32 instruction (0x90-0x97) diff --git a/X86Disassembler/X86/Handlers/Xor/XorAlImmHandler.cs b/X86Disassembler/X86/Handlers/Xor/XorAlImmHandler.cs index 66cad21..ed26ecb 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorAlImmHandler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorAlImmHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xor; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XOR AL, imm8 instruction (0x34) diff --git a/X86Disassembler/X86/Handlers/Xor/XorAxImm16Handler.cs b/X86Disassembler/X86/Handlers/Xor/XorAxImm16Handler.cs index b0fc9d8..7b2f3d3 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorAxImm16Handler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorAxImm16Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xor; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XOR AX, imm16 instruction (0x35 with 0x66 prefix) diff --git a/X86Disassembler/X86/Handlers/Xor/XorEaxImmHandler.cs b/X86Disassembler/X86/Handlers/Xor/XorEaxImmHandler.cs index b953f01..4452d7e 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorEaxImmHandler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorEaxImmHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xor; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XOR EAX, imm32 instruction (0x35) diff --git a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm16Handler.cs b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm16Handler.cs index 9a59389..5e488dc 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm16Handler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm16Handler.cs @@ -30,8 +30,7 @@ public class XorImmWithRm16Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 6; // 6 = XOR } @@ -54,7 +53,7 @@ public class XorImmWithRm16Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Ensure the destination operand has the correct size (16-bit) destinationOperand.Size = 16; diff --git a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm16SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm16SignExtendedHandler.cs index f186a2b..d2fa62d 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm16SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm16SignExtendedHandler.cs @@ -30,8 +30,7 @@ public class XorImmWithRm16SignExtendedHandler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 6; // 6 = XOR } @@ -56,7 +55,7 @@ public class XorImmWithRm16SignExtendedHandler : InstructionHandler // For XOR r/m16, imm8 (sign-extended) (0x83 /6 with 0x66 prefix): // - The r/m field with mod specifies the destination operand (register or memory) // - The immediate value is the source operand (sign-extended from 8 to 16 bits) - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size to 16-bit destinationOperand.Size = 16; diff --git a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm32Handler.cs b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm32Handler.cs index 7999d01..c755323 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm32Handler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm32Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xor; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XOR r/m32, imm32 instruction (0x81 /6) @@ -30,8 +30,7 @@ public class XorImmWithRm32Handler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 6; // 6 = XOR } @@ -53,7 +52,7 @@ public class XorImmWithRm32Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value if (!Decoder.CanReadUInt()) diff --git a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm32SignExtendedHandler.cs b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm32SignExtendedHandler.cs index d43a9f5..55db6a0 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm32SignExtendedHandler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm32SignExtendedHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xor; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XOR r/m32, imm8 (sign-extended) instruction (0x83 /6) @@ -30,8 +30,7 @@ public class XorImmWithRm32SignExtendedHandler : InstructionHandler if (!Decoder.CanReadByte()) return false; - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + var reg = ModRMDecoder.PeakModRMReg(); return reg == 6; // 6 = XOR } @@ -53,7 +52,7 @@ public class XorImmWithRm32SignExtendedHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, _, _, destOperand) = ModRMDecoder.ReadModRM(); // Read the immediate value (sign-extended from 8 to 32 bits) if (!Decoder.CanReadByte()) diff --git a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm8Handler.cs b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm8Handler.cs index 80571d7..28367cd 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorImmWithRm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorImmWithRm8Handler.cs @@ -29,9 +29,8 @@ public class XorImmWithRm8Handler : InstructionHandler // Check if the reg field of the ModR/M byte is 6 (XOR) if (!Decoder.CanReadByte()) return false; - - byte modRM = Decoder.PeakByte(); - byte reg = (byte)((modRM & 0x38) >> 3); + + var reg = ModRMDecoder.PeakModRMReg(); return reg == 6; // 6 = XOR } @@ -48,7 +47,7 @@ public class XorImmWithRm8Handler : InstructionHandler instruction.Type = InstructionType.Xor; // Read the ModR/M byte, specifying that we're dealing with 8-bit operands - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM8(); + var (_, _, _, destinationOperand) = ModRMDecoder.ReadModRM8(); // Ensure the destination operand has the correct size (8-bit) destinationOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Xor/XorMemRegHandler.cs b/X86Disassembler/X86/Handlers/Xor/XorMemRegHandler.cs index 98df33c..f19c75f 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorMemRegHandler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorMemRegHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xor; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XOR r/m32, r32 instruction (0x31) @@ -43,7 +43,7 @@ public class XorMemRegHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destOperand) = ModRMDecoder.ReadModRM(); // Create the source register operand var srcOperand = OperandFactory.CreateRegisterOperand(reg, 32); diff --git a/X86Disassembler/X86/Handlers/Xor/XorR16Rm16Handler.cs b/X86Disassembler/X86/Handlers/Xor/XorR16Rm16Handler.cs index 1e40d7b..b8a64a6 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorR16Rm16Handler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorR16Rm16Handler.cs @@ -47,7 +47,7 @@ public class XorR16Rm16Handler : InstructionHandler // For XOR r16, r/m16 (0x33 with 0x66 prefix): // - The reg field specifies the destination register // - The r/m field with mod specifies the source operand (register or memory) - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM(); // Adjust the operand size to 16-bit sourceOperand.Size = 16; diff --git a/X86Disassembler/X86/Handlers/Xor/XorR8Rm8Handler.cs b/X86Disassembler/X86/Handlers/Xor/XorR8Rm8Handler.cs index 24fb200..6c42bf8 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorR8Rm8Handler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorR8Rm8Handler.cs @@ -38,7 +38,7 @@ public class XorR8Rm8Handler : InstructionHandler instruction.Type = InstructionType.Xor; // Read the ModR/M byte, specifying that we're dealing with 8-bit operands - var (mod, reg, rm, sourceOperand) = ModRMDecoder.ReadModRM8(); + var (_, reg, _, sourceOperand) = ModRMDecoder.ReadModRM8(); // Ensure the source operand has the correct size (8-bit) sourceOperand.Size = 8; diff --git a/X86Disassembler/X86/Handlers/Xor/XorRegMemHandler.cs b/X86Disassembler/X86/Handlers/Xor/XorRegMemHandler.cs index b34a904..4a7958a 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorRegMemHandler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorRegMemHandler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xor; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XOR r32, r/m32 instruction (0x33) @@ -45,7 +45,7 @@ public class XorRegMemHandler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, srcOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, srcOperand) = ModRMDecoder.ReadModRM(); // Create the destination register operand var destOperand = OperandFactory.CreateRegisterOperand(reg, 32); diff --git a/X86Disassembler/X86/Handlers/Xor/XorRm16R16Handler.cs b/X86Disassembler/X86/Handlers/Xor/XorRm16R16Handler.cs index bf2e1dc..e3f7aec 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorRm16R16Handler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorRm16R16Handler.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86.Handlers.Xor; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handler for XOR r/m16, r16 instruction (0x31 with 0x66 prefix) @@ -44,7 +44,7 @@ public class XorRm16R16Handler : InstructionHandler } // Read the ModR/M byte - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM(); // Create the source register operand (16-bit) var sourceOperand = OperandFactory.CreateRegisterOperand(reg, 16); diff --git a/X86Disassembler/X86/Handlers/Xor/XorRm8R8Handler.cs b/X86Disassembler/X86/Handlers/Xor/XorRm8R8Handler.cs index 2137147..e8d107b 100644 --- a/X86Disassembler/X86/Handlers/Xor/XorRm8R8Handler.cs +++ b/X86Disassembler/X86/Handlers/Xor/XorRm8R8Handler.cs @@ -38,7 +38,7 @@ public class XorRm8R8Handler : InstructionHandler instruction.Type = InstructionType.Xor; // Read the ModR/M byte, specifying that we're dealing with 8-bit operands - var (mod, reg, rm, destinationOperand) = ModRMDecoder.ReadModRM8(); + var (_, reg, _, destinationOperand) = ModRMDecoder.ReadModRM8(); // Ensure the destination operand has the correct size (8-bit) destinationOperand.Size = 8; diff --git a/X86Disassembler/X86/InstructionDecoder.cs b/X86Disassembler/X86/InstructionDecoder.cs index 9b3f349..b1465f0 100644 --- a/X86Disassembler/X86/InstructionDecoder.cs +++ b/X86Disassembler/X86/InstructionDecoder.cs @@ -4,7 +4,7 @@ using System.Diagnostics.Contracts; namespace X86Disassembler.X86; using Handlers; -using X86Disassembler.X86.Operands; +using Operands; /// /// Decodes x86 instructions from a byte buffer @@ -25,7 +25,6 @@ public class InstructionDecoder // Specialized decoders private readonly PrefixDecoder _prefixDecoder; - private readonly ModRMDecoder _modRMDecoder; /// /// Initializes a new instance of the InstructionDecoder class @@ -40,7 +39,7 @@ public class InstructionDecoder // Create specialized decoders _prefixDecoder = new PrefixDecoder(); - _modRMDecoder = new ModRMDecoder(this); + new ModRMDecoder(this); // Create the instruction handler factory _handlerFactory = new InstructionHandlerFactory(_codeBuffer, this, _length); @@ -133,8 +132,7 @@ public class InstructionDecoder string segmentOverride = _prefixDecoder.GetSegmentOverride(); // Save the position before decoding - int beforeDecodePosition = _position; - + // Decode the instruction handlerSuccess = handler.Decode(opcode, instruction); @@ -144,7 +142,7 @@ public class InstructionDecoder // Apply segment override to memory operands foreach (var operand in instruction.StructuredOperands) { - if (operand is Operands.MemoryOperand memoryOperand) + if (operand is MemoryOperand memoryOperand) { memoryOperand.SegmentOverride = segmentOverride; } @@ -287,15 +285,6 @@ public class InstructionDecoder return _prefixDecoder.HasOperandSizePrefix(); } - /// - /// Gets the prefix decoder - /// - /// The prefix decoder - public PrefixDecoder GetPrefixDecoder() - { - return _prefixDecoder; - } - /// /// Checks if a single byte can be read from the current position /// diff --git a/X86Disassembler/X86/ModRMDecoder.cs b/X86Disassembler/X86/ModRMDecoder.cs index 1894832..7fbdf02 100644 --- a/X86Disassembler/X86/ModRMDecoder.cs +++ b/X86Disassembler/X86/ModRMDecoder.cs @@ -1,6 +1,6 @@ namespace X86Disassembler.X86; -using X86Disassembler.X86.Operands; +using Operands; /// /// Handles decoding of ModR/M bytes in x86 instructions @@ -213,21 +213,19 @@ public class ModRMDecoder /// Peaks a ModR/M byte and returns the raw field values, without advancing position /// /// A tuple containing the raw mod, reg, and rm fields from the ModR/M byte - public (byte mod, byte reg, byte rm) PeakModRMRaw() + public byte PeakModRMReg() { if (!_decoder.CanReadByte()) { - return (0, 0, 0); + return 0; } byte modRM = _decoder.PeakByte(); // Extract fields from ModR/M byte - byte mod = (byte)((modRM & MOD_MASK) >> 6); // Top 2 bits (bits 6-7) byte regIndex = (byte)((modRM & REG_MASK) >> 3); // Middle 3 bits (bits 3-5) - byte rmIndex = (byte)(modRM & RM_MASK); // Bottom 3 bits (bits 0-2) - return (mod, regIndex, rmIndex); + return regIndex; } ///