paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-08-14 20:39:09 +02:00
Code Issues Packages Projects Releases Wiki Activity

Renamed TDbgDisassembler class and all related classes to avoid name clashes with FpDebugDebugger classes.

Browse Source 
Patch/Contributed by ccrause

git-svn-id: trunk@62757 -
This commit is contained in:
martin 2020-03-12 14:21:17 +00:00
parent 147cf21fef
commit 62facbb44d
9 changed files with 99 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
components/fpdebug/fpdbgavrclasses.pas
View File

@ -950,5 +950,5 @@ initialization
RegisterDbgOsClasses(TOSDbgClasses.Create( RegisterDbgOsClasses(TOSDbgClasses.Create(
TDbgAvrProcess, TDbgAvrProcess,
TDbgAvrThread, TDbgAvrThread,
TAvrDisassembler)); TAvrAsmDecoder));
end. end.

40
components/fpdebug/fpdbgclasses.pp
View File

@ -397,9 +397,9 @@ type
TStartInstanceFlag = (siRediretOutput, siForceNewConsole); TStartInstanceFlag = (siRediretOutput, siForceNewConsole);
TStartInstanceFlags = set of TStartInstanceFlag; TStartInstanceFlags = set of TStartInstanceFlag;
{ TDbgDisassemblerInstruction } { TDbgAsmInstruction }
TDbgDisassemblerInstruction = class(TRefCountedObject) TDbgAsmInstruction = class(TRefCountedObject)
public public
// returns byte len of call instruction at AAddress // 0 if not a call intruction // returns byte len of call instruction at AAddress // 0 if not a call intruction
function IsCallInstruction: boolean; virtual; function IsCallInstruction: boolean; virtual;
@ -408,9 +408,9 @@ type
function InstructionLength: Integer; virtual; function InstructionLength: Integer; virtual;
end; end;
{ TDbgDisassembler } { TDbgAsmDecoder }
TDbgDisassembler = class TDbgAsmDecoder = class
protected protected
function GetLastErrorWasMemReadErr: Boolean; virtual; function GetLastErrorWasMemReadErr: Boolean; virtual;
function GetMaxInstrSize: integer; virtual; abstract; function GetMaxInstrSize: integer; virtual; abstract;
@ -422,7 +422,7 @@ type
procedure Disassemble(var AAddress: Pointer; out ACodeBytes: String; out ACode: String); virtual; abstract; procedure Disassemble(var AAddress: Pointer; out ACodeBytes: String; out ACode: String); virtual; abstract;
procedure ReverseDisassemble(var AAddress: Pointer; out ACodeBytes: String; out ACode: String); virtual; procedure ReverseDisassemble(var AAddress: Pointer; out ACodeBytes: String; out ACode: String); virtual;
function GetInstructionInfo(AnAddress: TDBGPtr): TDbgDisassemblerInstruction; virtual; abstract; function GetInstructionInfo(AnAddress: TDBGPtr): TDbgAsmInstruction; virtual; abstract;
function GetFunctionFrameInfo(AnAddress: TDBGPtr; out AnIsOutsideFrame: Boolean): Boolean; virtual; function GetFunctionFrameInfo(AnAddress: TDBGPtr; out AnIsOutsideFrame: Boolean): Boolean; virtual;
property LastErrorWasMemReadErr: Boolean read GetLastErrorWasMemReadErr; property LastErrorWasMemReadErr: Boolean read GetLastErrorWasMemReadErr;
@ -430,7 +430,7 @@ type
property MinInstructionSize: integer read GetMinInstrSize; // abstract property MinInstructionSize: integer read GetMinInstrSize; // abstract
property CanReverseDisassemble: boolean read GetCanReverseDisassemble; property CanReverseDisassemble: boolean read GetCanReverseDisassemble;
end; end;
TDbgDisassemblerClass = class of TDbgDisassembler; TDbgDisassemblerClass = class of TDbgAsmDecoder;
{ TDbgProcess } { TDbgProcess }
@ -438,7 +438,7 @@ type
protected const protected const
Int3: Byte = $CC; Int3: Byte = $CC;
private private
FDisassembler: TDbgDisassembler; FDisassembler: TDbgAsmDecoder;
FExceptionClass: string; FExceptionClass: string;
FExceptionMessage: string; FExceptionMessage: string;
FExitCode: DWord; FExitCode: DWord;
@ -449,7 +449,7 @@ type
FThreadID: Integer; FThreadID: Integer;
FWatchPointData: TFpWatchPointData; FWatchPointData: TFpWatchPointData;
function GetDisassembler: TDbgDisassembler; function GetDisassembler: TDbgAsmDecoder;
function GetLastLibraryLoaded: TDbgLibrary; function GetLastLibraryLoaded: TDbgLibrary;
function GetPauseRequested: boolean; function GetPauseRequested: boolean;
procedure SetPauseRequested(AValue: boolean); procedure SetPauseRequested(AValue: boolean);
@ -580,7 +580,7 @@ public
property LastEventProcessIdentifier: THandle read GetLastEventProcessIdentifier; property LastEventProcessIdentifier: THandle read GetLastEventProcessIdentifier;
property MainThread: TDbgThread read FMainThread; property MainThread: TDbgThread read FMainThread;
property GotExitProcess: Boolean read FGotExitProcess write FGotExitProcess; property GotExitProcess: Boolean read FGotExitProcess write FGotExitProcess;
property Disassembler: TDbgDisassembler read GetDisassembler; property Disassembler: TDbgAsmDecoder read GetDisassembler;
end; end;
TDbgProcessClass = class of TDbgProcess; TDbgProcessClass = class of TDbgProcess;
@ -1277,36 +1277,36 @@ begin
SetValue(ANumValue, trim(FlagS),4,Cardinal(-1)); SetValue(ANumValue, trim(FlagS),4,Cardinal(-1));
end; end;
{ TDbgDisassemblerInstruction } { TDbgAsmInstruction }
function TDbgDisassemblerInstruction.IsCallInstruction: boolean; function TDbgAsmInstruction.IsCallInstruction: boolean;
begin begin
Result := False; Result := False;
end; end;
function TDbgDisassemblerInstruction.IsReturnInstruction: boolean; function TDbgAsmInstruction.IsReturnInstruction: boolean;
begin begin
Result := False; Result := False;
end; end;
function TDbgDisassemblerInstruction.IsLeaveStackFrame: boolean; function TDbgAsmInstruction.IsLeaveStackFrame: boolean;
begin begin
Result := False; Result := False;
end; end;
function TDbgDisassemblerInstruction.InstructionLength: Integer; function TDbgAsmInstruction.InstructionLength: Integer;
begin begin
Result := 0; Result := 0;
end; end;
{ TDbgDisassembler } { TDbgAsmDecoder }
function TDbgDisassembler.GetLastErrorWasMemReadErr: Boolean; function TDbgAsmDecoder.GetLastErrorWasMemReadErr: Boolean;
begin begin
Result := False; Result := False;
end; end;
function TDbgDisassembler.GetCanReverseDisassemble: boolean; function TDbgAsmDecoder.GetCanReverseDisassemble: boolean;
begin begin
Result := false; Result := false;
end; end;
@ -1316,7 +1316,7 @@ end;
// If not decrease instruction size and try again. // If not decrease instruction size and try again.
// Many pitfalls with X86 instruction encoding... // Many pitfalls with X86 instruction encoding...
// Avr may give 130/65535 = 0.2% errors per instruction reverse decoded // Avr may give 130/65535 = 0.2% errors per instruction reverse decoded
procedure TDbgDisassembler.ReverseDisassemble(var AAddress: Pointer; out procedure TDbgAsmDecoder.ReverseDisassemble(var AAddress: Pointer; out
ACodeBytes: String; out ACode: String); ACodeBytes: String; out ACode: String);
var var
i, instrLen: integer; i, instrLen: integer;
@ -1335,7 +1335,7 @@ begin
AAddress := AAddress - instrLen; AAddress := AAddress - instrLen;
end; end;
function TDbgDisassembler.GetFunctionFrameInfo(AnAddress: TDBGPtr; out function TDbgAsmDecoder.GetFunctionFrameInfo(AnAddress: TDBGPtr; out
AnIsOutsideFrame: Boolean): Boolean; AnIsOutsideFrame: Boolean): Boolean;
begin begin
Result := False; Result := False;
@ -1957,7 +1957,7 @@ begin
Result := FLibMap.LastLibraryAdded; Result := FLibMap.LastLibraryAdded;
end; end;
function TDbgProcess.GetDisassembler: TDbgDisassembler; function TDbgProcess.GetDisassembler: TDbgAsmDecoder;
begin begin
if FDisassembler = nil then if FDisassembler = nil then
FDisassembler := OSDbgClasses.DbgDisassemblerClass.Create(Self); FDisassembler := OSDbgClasses.DbgDisassemblerClass.Create(Self);

6
components/fpdebug/fpdbgcontroller.pas
View File

@ -39,7 +39,7 @@ type
FProcess: TDbgProcess; FProcess: TDbgProcess;
FThreadRemoved: boolean; FThreadRemoved: boolean;
FIsInitialized: Boolean; FIsInitialized: Boolean;
FNextInstruction: TDbgDisassemblerInstruction; FNextInstruction: TDbgAsmInstruction;
procedure Init; virtual; procedure Init; virtual;
procedure DoResolveEvent(var AnEvent: TFPDEvent; AnEventThread: TDbgThread; out Finished: boolean); virtual; abstract; procedure DoResolveEvent(var AnEvent: TFPDEvent; AnEventThread: TDbgThread; out Finished: boolean); virtual; abstract;
public public
@ -48,7 +48,7 @@ type
procedure DoBeforeLoopStart; procedure DoBeforeLoopStart;
procedure DoContinue(AProcess: TDbgProcess; AThread: TDbgThread); virtual; abstract; procedure DoContinue(AProcess: TDbgProcess; AThread: TDbgThread); virtual; abstract;
procedure ResolveEvent(var AnEvent: TFPDEvent; AnEventThread: TDbgThread; out Finished: boolean); procedure ResolveEvent(var AnEvent: TFPDEvent; AnEventThread: TDbgThread; out Finished: boolean);
function NextInstruction: TDbgDisassemblerInstruction; inline; function NextInstruction: TDbgAsmInstruction; inline;
property Thread: TDbgThread read FThread write SetThread; property Thread: TDbgThread read FThread write SetThread;
end; end;
@ -342,7 +342,7 @@ begin
DoResolveEvent(AnEvent, AnEventThread, Finished); DoResolveEvent(AnEvent, AnEventThread, Finished);
end; end;
function TDbgControllerCmd.NextInstruction: TDbgDisassemblerInstruction; function TDbgControllerCmd.NextInstruction: TDbgAsmInstruction;
begin begin
if FNextInstruction = nil then begin if FNextInstruction = nil then begin
FNextInstruction := FProcess.Disassembler.GetInstructionInfo(FThread.GetInstructionPointerRegisterValue); FNextInstruction := FProcess.Disassembler.GetInstructionInfo(FThread.GetInstructionPointerRegisterValue);

2
components/fpdebug/fpdbgdarwinclasses.pas
View File

@ -967,7 +967,7 @@ initialization
RegisterDbgOsClasses(TOSDbgClasses.Create( RegisterDbgOsClasses(TOSDbgClasses.Create(
TDbgDarwinProcess, TDbgDarwinProcess,
TDbgDarwinThread, TDbgDarwinThread,
TX86Disassembler TX86AsmDecoder
)); ));
end. end.

60
components/fpdebug/fpdbgdisasavr.pp
View File

@ -44,17 +44,17 @@ type
//The function Disassemble decodes the instruction at the given address. //The function Disassemble decodes the instruction at the given address.
//Unrecognized instructions are assumed to be data statements [dw XXXX] //Unrecognized instructions are assumed to be data statements [dw XXXX]
TAvrDisassembler = class; TAvrAsmDecoder = class;
{ TX86DisassemblerInstruction } { TX86DisassemblerInstruction }
{ TAvrDisassemblerInstruction } { TAvrAsmInstruction }
TAvrDisassemblerInstruction = class(TDbgDisassemblerInstruction) TAvrAsmInstruction = class(TDbgAsmInstruction)
private const private const
INSTR_CODEBIN_LEN = 4; INSTR_CODEBIN_LEN = 4;
private private
FDisassembler: TAvrDisassembler; FAsmDecoder: TAvrAsmDecoder;
FAddress: TDBGPtr; FAddress: TDBGPtr;
FCodeBin: array[0..INSTR_CODEBIN_LEN-1] of byte; FCodeBin: array[0..INSTR_CODEBIN_LEN-1] of byte;
FInstrLen: Integer; FInstrLen: Integer;
@ -62,7 +62,7 @@ type
protected protected
procedure ReadCode; inline; procedure ReadCode; inline;
public public
constructor Create(ADisassembler: TAvrDisassembler); constructor Create(AAsmDecoder: TAvrAsmDecoder);
procedure SetAddress(AnAddress: TDBGPtr); procedure SetAddress(AnAddress: TDBGPtr);
function IsCallInstruction: boolean; override; function IsCallInstruction: boolean; override;
function IsReturnInstruction: boolean; override; function IsReturnInstruction: boolean; override;
@ -70,13 +70,13 @@ type
function InstructionLength: Integer; override; function InstructionLength: Integer; override;
end; end;
{ TAvrDisassembler } { TAvrAsmDecoder }
TAvrDisassembler = class(TDbgDisassembler) TAvrAsmDecoder = class(TDbgAsmDecoder)
private private
FProcess: TDbgProcess; FProcess: TDbgProcess;
FLastErrWasMem: Boolean; FLastErrWasMem: Boolean;
FLastInstr: TAvrDisassemblerInstruction; FLastInstr: TAvrAsmInstruction;
protected protected
function GetLastErrorWasMemReadErr: Boolean; override; function GetLastErrorWasMemReadErr: Boolean; override;
function GetMaxInstrSize: integer; override; function GetMaxInstrSize: integer; override;
@ -84,7 +84,7 @@ type
function GetCanReverseDisassemble: boolean; override; function GetCanReverseDisassemble: boolean; override;
procedure Disassemble(var AAddress: Pointer; out ACodeBytes: String; out ACode: String); override; procedure Disassemble(var AAddress: Pointer; out ACodeBytes: String; out ACode: String); override;
function GetInstructionInfo(AnAddress: TDBGPtr): TDbgDisassemblerInstruction; override; function GetInstructionInfo(AnAddress: TDBGPtr): TDbgAsmInstruction; override;
// returns byte len of call instruction at AAddress // 0 if not a call intruction // returns byte len of call instruction at AAddress // 0 if not a call intruction
function GetFunctionFrameInfo(AnAddress: TDBGPtr; out function GetFunctionFrameInfo(AnAddress: TDBGPtr; out
@ -145,31 +145,31 @@ begin
result := format(opConstHex16, ['dw', instr]); result := format(opConstHex16, ['dw', instr]);
end; end;
{ TAvrDisassemblerInstruction } { TAvrAsmInstruction }
procedure TAvrDisassemblerInstruction.ReadCode; procedure TAvrAsmInstruction.ReadCode;
begin begin
if not (diCodeRead in FFlags) then begin if not (diCodeRead in FFlags) then begin
if not FDisassembler.FProcess.ReadData(FAddress, INSTR_CODEBIN_LEN, FCodeBin) then if not FAsmDecoder.FProcess.ReadData(FAddress, INSTR_CODEBIN_LEN, FCodeBin) then
Include(FFlags, diCodeReadError); Include(FFlags, diCodeReadError);
Include(FFlags, diCodeRead); Include(FFlags, diCodeRead);
end; end;
end; end;
constructor TAvrDisassemblerInstruction.Create(ADisassembler: TAvrDisassembler); constructor TAvrAsmInstruction.Create(AAsmDecoder: TAvrAsmDecoder);
begin begin
FDisassembler := ADisassembler; FAsmDecoder := AAsmDecoder;
inherited Create; inherited Create;
AddReference; AddReference;
end; end;
procedure TAvrDisassemblerInstruction.SetAddress(AnAddress: TDBGPtr); procedure TAvrAsmInstruction.SetAddress(AnAddress: TDBGPtr);
begin begin
FAddress := AnAddress; FAddress := AnAddress;
FFlags := []; FFlags := [];
end; end;
function TAvrDisassemblerInstruction.IsCallInstruction: boolean; function TAvrAsmInstruction.IsCallInstruction: boolean;
var var
LoByte, HiByte: byte; LoByte, HiByte: byte;
begin begin
@ -183,7 +183,7 @@ begin
Result := true; Result := true;
end; end;
function TAvrDisassemblerInstruction.IsReturnInstruction: boolean; function TAvrAsmInstruction.IsReturnInstruction: boolean;
var var
LoByte, HiByte: byte; LoByte, HiByte: byte;
begin begin
@ -195,12 +195,12 @@ begin
Result := true; Result := true;
end; end;
function TAvrDisassemblerInstruction.IsLeaveStackFrame: boolean; function TAvrAsmInstruction.IsLeaveStackFrame: boolean;
begin begin
Result := false; Result := false;
end; end;
function TAvrDisassemblerInstruction.InstructionLength: Integer; function TAvrAsmInstruction.InstructionLength: Integer;
var var
LoByte, HiByte: byte; LoByte, HiByte: byte;
begin begin
@ -213,27 +213,27 @@ begin
Result := 4; Result := 4;
end; end;
function TAvrDisassembler.GetLastErrorWasMemReadErr: Boolean; function TAvrAsmDecoder.GetLastErrorWasMemReadErr: Boolean;
begin begin
Result := FLastErrWasMem; Result := FLastErrWasMem;
end; end;
function TAvrDisassembler.GetMaxInstrSize: integer; function TAvrAsmDecoder.GetMaxInstrSize: integer;
begin begin
Result := 4; Result := 4;
end; end;
function TAvrDisassembler.GetMinInstrSize: integer; function TAvrAsmDecoder.GetMinInstrSize: integer;
begin begin
Result := 2; Result := 2;
end; end;
function TAvrDisassembler.GetCanReverseDisassemble: boolean; function TAvrAsmDecoder.GetCanReverseDisassemble: boolean;
begin begin
Result := true; Result := true;
end; end;
procedure TAvrDisassembler.Disassemble(var AAddress: Pointer; out procedure TAvrAsmDecoder.Disassemble(var AAddress: Pointer; out
ACodeBytes: String; out ACode: String); ACodeBytes: String; out ACode: String);
var var
CodeIdx, r, d, k, q: byte; CodeIdx, r, d, k, q: byte;
@ -836,30 +836,30 @@ begin
Inc(AAddress, CodeIdx); Inc(AAddress, CodeIdx);
end; end;
function TAvrDisassembler.GetInstructionInfo(AnAddress: TDBGPtr function TAvrAsmDecoder.GetInstructionInfo(AnAddress: TDBGPtr
): TDbgDisassemblerInstruction; ): TDbgAsmInstruction;
begin begin
if (FLastInstr = nil) or (FLastInstr.RefCount > 1) then begin if (FLastInstr = nil) or (FLastInstr.RefCount > 1) then begin
ReleaseRefAndNil(FLastInstr); ReleaseRefAndNil(FLastInstr);
FLastInstr := TAvrDisassemblerInstruction.Create(Self); FLastInstr := TAvrAsmInstruction.Create(Self);
end; end;
FLastInstr.SetAddress(AnAddress); FLastInstr.SetAddress(AnAddress);
Result := FLastInstr; Result := FLastInstr;
end; end;
function TAvrDisassembler.GetFunctionFrameInfo(AnAddress: TDBGPtr; out function TAvrAsmDecoder.GetFunctionFrameInfo(AnAddress: TDBGPtr; out
AnIsOutsideFrame: Boolean): Boolean; AnIsOutsideFrame: Boolean): Boolean;
begin begin
result := false; result := false;
end; end;
constructor TAvrDisassembler.Create(AProcess: TDbgProcess); constructor TAvrAsmDecoder.Create(AProcess: TDbgProcess);
begin begin
FProcess := AProcess; FProcess := AProcess;
end; end;
destructor TAvrDisassembler.Destroy; destructor TAvrAsmDecoder.Destroy;
begin begin
ReleaseRefAndNil(FLastInstr); ReleaseRefAndNil(FLastInstr);
inherited Destroy; inherited Destroy;

74
components/fpdebug/fpdbgdisasx86.pp
View File

@ -201,15 +201,15 @@ type
ParseFlags: TFlags; ParseFlags: TFlags;
end; end;
TX86Disassembler = class; TX86AsmDecoder = class;
{ TX86DisassemblerInstruction } { TX86AsmInstruction }
TX86DisassemblerInstruction = class(TDbgDisassemblerInstruction) TX86AsmInstruction = class(TDbgAsmInstruction)
const const
INSTR_CODEBIN_LEN = 16; INSTR_CODEBIN_LEN = 16;
private private
FDisassembler: TX86Disassembler; FAsmDecoder: TX86AsmDecoder;
FAddress: TDBGPtr; FAddress: TDBGPtr;
FCodeBin: array[0..INSTR_CODEBIN_LEN-1] of byte; FCodeBin: array[0..INSTR_CODEBIN_LEN-1] of byte;
FInstruction: TInstruction; FInstruction: TInstruction;
@ -219,7 +219,7 @@ type
procedure ReadCode; inline; procedure ReadCode; inline;
procedure Disassemble; inline; procedure Disassemble; inline;
public public
constructor Create(ADisassembler: TX86Disassembler); constructor Create(AAsmDecoder: TX86AsmDecoder);
procedure SetAddress(AnAddress: TDBGPtr); procedure SetAddress(AnAddress: TDBGPtr);
function IsCallInstruction: boolean; override; function IsCallInstruction: boolean; override;
function IsReturnInstruction: boolean; override; function IsReturnInstruction: boolean; override;
@ -229,9 +229,9 @@ type
property X86Instruction: TInstruction read FInstruction; // only valid after call to X86OpCode property X86Instruction: TInstruction read FInstruction; // only valid after call to X86OpCode
end; end;
{ TX86Disassembler } { TX86AsmDecoder }
TX86Disassembler = class(TDBGDisassembler) TX86AsmDecoder = class(TDbgAsmDecoder)
private const private const
MAX_CODEBIN_LEN = 50; MAX_CODEBIN_LEN = 50;
FMaxInstructionSize = 16; FMaxInstructionSize = 16;
@ -240,7 +240,7 @@ type
FProcess: TDbgProcess; FProcess: TDbgProcess;
FLastErrWasMem: Boolean; FLastErrWasMem: Boolean;
FCodeBin: array[0..MAX_CODEBIN_LEN-1] of byte; FCodeBin: array[0..MAX_CODEBIN_LEN-1] of byte;
FLastInstr: TX86DisassemblerInstruction; FLastInstr: TX86AsmInstruction;
protected protected
function GetLastErrorWasMemReadErr: Boolean; override; function GetLastErrorWasMemReadErr: Boolean; override;
function GetMaxInstrSize: integer; override; function GetMaxInstrSize: integer; override;
@ -253,7 +253,7 @@ type
destructor Destroy; override; destructor Destroy; override;
procedure Disassemble(var AAddress: Pointer; out ACodeBytes: String; out ACode: String); override; procedure Disassemble(var AAddress: Pointer; out ACodeBytes: String; out ACode: String); override;
function GetInstructionInfo(AnAddress: TDBGPtr): TDbgDisassemblerInstruction; override; function GetInstructionInfo(AnAddress: TDBGPtr): TDbgAsmInstruction; override;
function GetFunctionFrameInfo(AnAddress: TDBGPtr; out function GetFunctionFrameInfo(AnAddress: TDBGPtr; out
AnIsOutsideFrame: Boolean): Boolean; override; AnIsOutsideFrame: Boolean): Boolean; override;
@ -372,44 +372,44 @@ const
'o', 'no', 'b', 'nb', 'z', 'nz', 'be', 'nbe', 's', 'ns', 'p', 'np', 'l', 'nl', 'le', 'nle' 'o', 'no', 'b', 'nb', 'z', 'nz', 'be', 'nbe', 's', 'ns', 'p', 'np', 'l', 'nl', 'le', 'nle'
); );
{ TX86DisassemblerInstruction } { TX86AsmInstruction }
procedure TX86DisassemblerInstruction.ReadCode; procedure TX86AsmInstruction.ReadCode;
begin begin
if not (diCodeRead in FFlags) then begin if not (diCodeRead in FFlags) then begin
if not FDisassembler.FProcess.ReadData(FAddress, INSTR_CODEBIN_LEN, FCodeBin) then if not FAsmDecoder.FProcess.ReadData(FAddress, INSTR_CODEBIN_LEN, FCodeBin) then
Include(FFlags, diCodeReadError); Include(FFlags, diCodeReadError);
Include(FFlags, diCodeRead); Include(FFlags, diCodeRead);
end; end;
end; end;
procedure TX86DisassemblerInstruction.Disassemble; procedure TX86AsmInstruction.Disassemble;
var var
a: PByte; a: PByte;
begin begin
if not (diDisAss in FFlags) then begin if not (diDisAss in FFlags) then begin
ReadCode; ReadCode;
a := @FCodeBin[0]; a := @FCodeBin[0];
FDisassembler.Disassemble(a, FInstruction); FAsmDecoder.Disassemble(a, FInstruction);
FInstrLen := a - @FCodeBin[0]; FInstrLen := a - @FCodeBin[0];
Include(FFlags, diDisAss); Include(FFlags, diDisAss);
end; end;
end; end;
constructor TX86DisassemblerInstruction.Create(ADisassembler: TX86Disassembler); constructor TX86AsmInstruction.Create(AAsmDecoder: TX86AsmDecoder);
begin begin
FDisassembler := ADisassembler; FAsmDecoder := AAsmDecoder;
inherited Create; inherited Create;
AddReference; AddReference;
end; end;
procedure TX86DisassemblerInstruction.SetAddress(AnAddress: TDBGPtr); procedure TX86AsmInstruction.SetAddress(AnAddress: TDBGPtr);
begin begin
FAddress := AnAddress; FAddress := AnAddress;
FFlags := []; FFlags := [];
end; end;
function TX86DisassemblerInstruction.IsCallInstruction: boolean; function TX86AsmInstruction.IsCallInstruction: boolean;
var var
a: PByte; a: PByte;
begin begin
@ -417,7 +417,7 @@ begin
ReadCode; ReadCode;
a := @FCodeBin[0]; a := @FCodeBin[0];
if (FDisassembler.FProcess.Mode = dm64) then begin if (FAsmDecoder.FProcess.Mode = dm64) then begin
while (a < @FCodeBin[0] + INSTR_CODEBIN_LEN) and (a^ in [$40..$4F, $64..$67]) do while (a < @FCodeBin[0] + INSTR_CODEBIN_LEN) and (a^ in [$40..$4F, $64..$67]) do
inc(a); inc(a);
if not (a^ in [$E8, $FF]) then if not (a^ in [$E8, $FF]) then
@ -434,31 +434,31 @@ begin
Result := FInstruction.OpCode = OPcall; Result := FInstruction.OpCode = OPcall;
end; end;
function TX86DisassemblerInstruction.IsReturnInstruction: boolean; function TX86AsmInstruction.IsReturnInstruction: boolean;
begin begin
Disassemble; Disassemble;
Result := (FInstruction.OpCode = OPret) or (FInstruction.OpCode = OPretf); Result := (FInstruction.OpCode = OPret) or (FInstruction.OpCode = OPretf);
end; end;
function TX86DisassemblerInstruction.IsLeaveStackFrame: boolean; function TX86AsmInstruction.IsLeaveStackFrame: boolean;
begin begin
Disassemble; Disassemble;
Result := (FInstruction.OpCode = OPleave); Result := (FInstruction.OpCode = OPleave);
end; end;
function TX86DisassemblerInstruction.InstructionLength: Integer; function TX86AsmInstruction.InstructionLength: Integer;
begin begin
Disassemble; Disassemble;
Result := FInstrLen; Result := FInstrLen;
end; end;
function TX86DisassemblerInstruction.X86OpCode: TOpCode; function TX86AsmInstruction.X86OpCode: TOpCode;
begin begin
Disassemble; Disassemble;
Result := FInstruction.OpCode; Result := FInstruction.OpCode;
end; end;
procedure TX86Disassembler.Disassemble(var AAddress: Pointer; out AnInstruction: TInstruction); procedure TX86AsmDecoder.Disassemble(var AAddress: Pointer; out AnInstruction: TInstruction);
var var
Code: PByte; Code: PByte;
CodeIdx: Byte; CodeIdx: Byte;
@ -3427,7 +3427,7 @@ begin
Inc(AAddress, CodeIdx); Inc(AAddress, CodeIdx);
end; end;
procedure TX86Disassembler.Disassemble(var AAddress: Pointer; procedure TX86AsmDecoder.Disassemble(var AAddress: Pointer;
out ACodeBytes: String; out ACode: String); out ACodeBytes: String; out ACode: String);
const const
MEMPTR: array[TOperandSize] of string = ('byte ptr ', 'word ptr ', 'dword ptr ', 'qword ptr ', '', 'tbyte ptr ', '16byte ptr '); MEMPTR: array[TOperandSize] of string = ('byte ptr ', 'word ptr ', 'dword ptr ', 'qword ptr ', '', 'tbyte ptr ', '16byte ptr ');
@ -3509,36 +3509,36 @@ begin
ACodeBytes := S; ACodeBytes := S;
end; end;
function TX86Disassembler.GetInstructionInfo(AnAddress: TDBGPtr function TX86AsmDecoder.GetInstructionInfo(AnAddress: TDBGPtr
): TDbgDisassemblerInstruction; ): TDbgAsmInstruction;
begin begin
if (FLastInstr = nil) or (FLastInstr.RefCount > 1) then begin if (FLastInstr = nil) or (FLastInstr.RefCount > 1) then begin
ReleaseRefAndNil(FLastInstr); ReleaseRefAndNil(FLastInstr);
FLastInstr := TX86DisassemblerInstruction.Create(Self); FLastInstr := TX86AsmInstruction.Create(Self);
end; end;
FLastInstr.SetAddress(AnAddress); FLastInstr.SetAddress(AnAddress);
Result := FLastInstr; Result := FLastInstr;
end; end;
{ TX86Disassembler } { TX86AsmDecoder }
function TX86Disassembler.GetLastErrorWasMemReadErr: Boolean; function TX86AsmDecoder.GetLastErrorWasMemReadErr: Boolean;
begin begin
Result := FLastErrWasMem; Result := FLastErrWasMem;
end; end;
function TX86Disassembler.GetMaxInstrSize: integer; function TX86AsmDecoder.GetMaxInstrSize: integer;
begin begin
Result := 16; Result := 16;
end; end;
function TX86Disassembler.GetMinInstrSize: integer; function TX86AsmDecoder.GetMinInstrSize: integer;
begin begin
Result := 1; Result := 1;
end; end;
function TX86Disassembler.GetCanReverseDisassemble: boolean; function TX86AsmDecoder.GetCanReverseDisassemble: boolean;
begin begin
{$IFDEF FPDEBUG_WITH_REVERSE_DISASM} {$IFDEF FPDEBUG_WITH_REVERSE_DISASM}
Result := true; Result := true;
@ -3547,25 +3547,25 @@ begin
{$ENDIF} {$ENDIF}
end; end;
function TX86Disassembler.ReadCodeAt(AnAddress: TDBGPtr; var ALen: Cardinal function TX86AsmDecoder.ReadCodeAt(AnAddress: TDBGPtr; var ALen: Cardinal
): Boolean; ): Boolean;
begin begin
FLastErrWasMem := not FProcess.ReadData(AnAddress, ALen, FCodeBin[0], ALen); FLastErrWasMem := not FProcess.ReadData(AnAddress, ALen, FCodeBin[0], ALen);
Result := FLastErrWasMem; Result := FLastErrWasMem;
end; end;
constructor TX86Disassembler.Create(AProcess: TDbgProcess); constructor TX86AsmDecoder.Create(AProcess: TDbgProcess);
begin begin
FProcess := AProcess; FProcess := AProcess;
end; end;
destructor TX86Disassembler.Destroy; destructor TX86AsmDecoder.Destroy;
begin begin
ReleaseRefAndNil(FLastInstr); ReleaseRefAndNil(FLastInstr);
inherited Destroy; inherited Destroy;
end; end;
function TX86Disassembler.GetFunctionFrameInfo(AnAddress: TDBGPtr; out function TX86AsmDecoder.GetFunctionFrameInfo(AnAddress: TDBGPtr; out
AnIsOutsideFrame: Boolean): Boolean; AnIsOutsideFrame: Boolean): Boolean;
var var
ADataLen: Cardinal; ADataLen: Cardinal;

2
components/fpdebug/fpdbglinuxclasses.pas
View File

@ -1378,7 +1378,7 @@ initialization
RegisterDbgOsClasses(TOSDbgClasses.Create( RegisterDbgOsClasses(TOSDbgClasses.Create(
TDbgLinuxProcess, TDbgLinuxProcess,
TDbgLinuxThread, TDbgLinuxThread,
TX86Disassembler TX86AsmDecoder
)); ));
end. end.

2
components/fpdebug/fpdbgwinclasses.pas
View File

@ -1747,7 +1747,7 @@ initialization
RegisterDbgOsClasses(TOSDbgClasses.Create( RegisterDbgOsClasses(TOSDbgClasses.Create(
TDbgWinProcess, TDbgWinProcess,
TDbgWinThread, TDbgWinThread,
TX86Disassembler TX86AsmDecoder
)); ));
end. end.

10
components/lazdebuggers/lazdebuggerfp/fpdebugdebugger.pas
View File

@ -523,7 +523,7 @@ end;
procedure TDbgControllerStepOverOrFinallyCmd.InternalContinue( procedure TDbgControllerStepOverOrFinallyCmd.InternalContinue(
AProcess: TDbgProcess; AThread: TDbgThread); AProcess: TDbgProcess; AThread: TDbgThread);
var var
Instr: TDbgDisassemblerInstruction; Instr: TDbgAsmInstruction;
begin begin
{ {
00000001000374AE 4889C1 mov rcx,rax 00000001000374AE 4889C1 mov rcx,rax
@ -534,10 +534,10 @@ begin
} }
if (AThread = FThread) then begin if (AThread = FThread) then begin
Instr := NextInstruction; Instr := NextInstruction;
if Instr is TX86DisassemblerInstruction then begin if Instr is TX86AsmInstruction then begin
case TX86DisassemblerInstruction(Instr).X86OpCode of case TX86AsmInstruction(Instr).X86OpCode of
OPmov: OPmov:
if UpperCase(TX86DisassemblerInstruction(Instr).X86Instruction.Operand[2].Value) = 'RBP' then if UpperCase(TX86AsmInstruction(Instr).X86Instruction.Operand[2].Value) = 'RBP' then
FFinState := fsMov; FFinState := fsMov;
OPcall: OPcall:
if FFinState = fsMov then begin if FFinState = fsMov then begin
@ -1309,7 +1309,7 @@ var
StatIndex: integer; StatIndex: integer;
FirstIndex: integer; FirstIndex: integer;
ALastAddr, tmpAddr, tmpPointer, prevInstructionSize: TDBGPtr; ALastAddr, tmpAddr, tmpPointer, prevInstructionSize: TDBGPtr;
ADisassembler: FpDbgClasses.TDbgDisassembler; ADisassembler: TDbgAsmDecoder;
begin begin
Result := False; Result := False;