1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
|
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include <debugger/debuggerengine.h>
#include <debugger/breakhandler.h>
#include <cplusplus/CppDocument.h>
#include <projectexplorer/devicesupport/idevice.h>
#include <QTime>
namespace Debugger {
namespace Internal {
class CdbCommand;
struct MemoryViewCookie;
class StringInputStream;
class CdbEngine : public DebuggerEngine
{
Q_OBJECT
public:
using CdbCommandPtr = QSharedPointer<CdbCommand>;
using CommandHandler = std::function<void (const DebuggerResponse &)>;
explicit CdbEngine();
~CdbEngine() override;
bool canHandleToolTip(const DebuggerToolTipContext &context) const override;
void setupEngine() override;
void runEngine() override;
void shutdownInferior() override;
void shutdownEngine() override;
void abortDebuggerProcess() override;
void detachDebugger() override;
bool hasCapability(unsigned cap) const override;
void watchPoint(const QPoint &) override;
void setRegisterValue(const QString &name, const QString &value) override;
void executeStep() override;
void executeStepOut() override;
void executeNext() override;
void executeStepI() override;
void executeNextI() override;
void continueInferior() override;
void interruptInferior() override;
void executeRunToLine(const ContextData &data) override;
void executeRunToFunction(const QString &functionName) override;
void executeJumpToLine(const ContextData &data) override;
void assignValueInDebugger(WatchItem *w, const QString &expr, const QVariant &value) override;
void executeDebuggerCommand(const QString &command) override;
void activateFrame(int index) override;
void selectThread(ThreadId threadId) override;
bool stateAcceptsBreakpointChanges() const override;
bool acceptsBreakpoint(const BreakpointParameters ¶ms) const override;
void insertBreakpoint(const Breakpoint &bp) override;
void removeBreakpoint(const Breakpoint &bp) override;
void updateBreakpoint(const Breakpoint &bp) override;
void enableSubBreakpoint(const SubBreakpoint &sbp, bool on) override;
void fetchDisassembler(DisassemblerAgent *agent) override;
void fetchMemory(MemoryAgent *, quint64 addr, quint64 length) override;
void changeMemory(MemoryAgent *, quint64 addr, const QByteArray &data) override;
void reloadModules() override;
void loadSymbols(const QString &moduleName) override;
void loadAllSymbols() override;
void requestModuleSymbols(const QString &moduleName) override;
void reloadRegisters() override;
void reloadSourceFiles() override;
void reloadFullStack() override;
void loadAdditionalQmlStack() override;
void listBreakpoints();
static QString extensionLibraryName(bool is64Bit);
private:
void readyReadStandardOut();
void readyReadStandardError();
void processError();
void processFinished();
void runCommand(const DebuggerCommand &cmd) override;
void operateByInstructionTriggered(bool);
void createFullBacktrace();
void handleDoInterruptInferior(const QString &errorMessage);
typedef QPair<QString, QString> SourcePathMapping;
struct NormalizedSourceFileName // Struct for caching mapped/normalized source files.
{
NormalizedSourceFileName(const QString &fn = QString(), bool e = false) : fileName(fn), exists(e) {}
QString fileName;
bool exists;
};
enum StopMode {
NoStopRequested,
Interrupt,
Callback
};
enum ParseStackResultFlags // Flags returned by parseStackTrace
{
ParseStackStepInto = 1, // Need to execute a step, hit on a call frame in "Step into"
ParseStackStepOut = 2, // Need to step out, hit on a frame without debug information
ParseStackWow64 = 3 // Hit on a frame with 32bit emulation, switch debugger to 32 bit mode
};
enum CommandFlags {
NoFlags = 0,
BuiltinCommand,
ExtensionCommand,
ScriptCommand
};
void init();
unsigned examineStopReason(const GdbMi &stopReason, QString *message,
QString *exceptionBoxMessage,
bool conditionalBreakPointTriggered = false);
void processStop(const GdbMi &stopReason, bool conditionalBreakPointTriggered = false);
bool commandsPending() const;
void handleExtensionMessage(char t, int token, const QString &what, const QString &message);
bool doSetupEngine(QString *errorMessage);
void handleSessionAccessible(unsigned long cdbExState);
void handleSessionInaccessible(unsigned long cdbExState);
void handleSessionIdle(const QString &message);
using InterruptCallback = std::function<void()>;
void doInterruptInferior(const InterruptCallback &cb = InterruptCallback());
void doContinueInferior();
void parseOutputLine(QString line);
bool isCdbProcessRunning() const { return m_process.state() != QProcess::NotRunning; }
bool canInterruptInferior() const;
inline void postDisassemblerCommand(quint64 address, DisassemblerAgent *agent);
void postDisassemblerCommand(quint64 address, quint64 endAddress,
DisassemblerAgent *agent);
void postResolveSymbol(const QString &module, const QString &function,
DisassemblerAgent *agent);
void showScriptMessages(const QString &message) const;
void handleInitialSessionIdle();
// Builtin commands
void handleStackTrace(const DebuggerResponse &);
void handleRegisters(const DebuggerResponse &);
void handleJumpToLineAddressResolution(const DebuggerResponse &response, const ContextData &context);
void handleExpression(const DebuggerResponse &command, const Breakpoint &bp, const GdbMi &stopReason);
void handleResolveSymbol(const DebuggerResponse &command, const QString &symbol, DisassemblerAgent *agent);
void handleResolveSymbolHelper(const QList<quint64> &addresses, DisassemblerAgent *agent);
void handleBreakInsert(const DebuggerResponse &response, const Breakpoint &bp);
void handleCheckWow64(const DebuggerResponse &response, const GdbMi &stack);
void ensureUsing32BitStackInWow64(const DebuggerResponse &response, const GdbMi &stack);
void handleSwitchWow64Stack(const DebuggerResponse &response);
void jumpToAddress(quint64 address);
// Extension commands
void handleThreads(const DebuggerResponse &response);
void handleLocals(const DebuggerResponse &response, bool partialUpdate);
void handleExpandLocals(const DebuggerResponse &response);
void handleRegistersExt(const DebuggerResponse &response);
void handleModules(const DebuggerResponse &response);
void handleWidgetAt(const DebuggerResponse &response);
void handleBreakPoints(const DebuggerResponse &response);
void handleAdditionalQmlStack(const DebuggerResponse &response);
void setupScripting(const DebuggerResponse &response);
NormalizedSourceFileName sourceMapNormalizeFileNameFromDebugger(const QString &f);
void doUpdateLocals(const UpdateParameters ¶ms) override;
void updateAll() override;
int elapsedLogTime() const;
unsigned parseStackTrace(const GdbMi &data, bool sourceStepInto);
void mergeStartParametersSourcePathMap();
const QString m_tokenPrefix;
void handleSetupFailure(const QString &errorMessage);
QProcess m_process;
DebuggerStartMode m_effectiveStartMode = NoStartMode;
QByteArray m_outputBuffer;
//! Debugger accessible (expecting commands)
bool m_accessible = false;
StopMode m_stopMode = NoStopRequested;
ProjectExplorer::DeviceProcessSignalOperation::Ptr m_signalOperation;
int m_nextCommandToken = 0;
QHash<int, DebuggerCommand> m_commandForToken;
QString m_currentBuiltinResponse;
int m_currentBuiltinResponseToken = -1;
QMap<QString, NormalizedSourceFileName> m_normalizedFileCache;
const QString m_extensionCommandPrefix; //!< Library name used as prefix
bool m_operateByInstruction = true; // Default CDB setting.
bool m_hasDebuggee = false;
enum Wow64State {
wow64Uninitialized,
noWow64Stack,
wow64Stack32Bit,
wow64Stack64Bit
} m_wow64State = wow64Uninitialized;
QTime m_logTime;
mutable int m_elapsedLogTime = 0;
QString m_extensionMessageBuffer;
bool m_sourceStepInto = false;
int m_watchPointX = 0;
int m_watchPointY = 0;
QSet<Breakpoint> m_pendingBreakpointMap;
bool m_autoBreakPointCorrection = false;
QMultiHash<QString, quint64> m_symbolAddressCache;
bool m_ignoreCdbOutput = false;
QList<InterruptCallback> m_interrupCallbacks;
QList<SourcePathMapping> m_sourcePathMappings;
QScopedPointer<GdbMi> m_coreStopReason;
int m_pythonVersion = 0; // 0xMMmmpp MM = major; mm = minor; pp = patch
bool m_initialSessionIdleHandled = false;
mutable CPlusPlus::Snapshot m_codeModelSnapshot;
};
} // namespace Internal
} // namespace Debugger
|
