src/plugins/debugger/cdb/cdbengine.h

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (qt-info@nokia.com)
   8 **
   9 ** No Commercial Usage
  10 **
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 **
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Nokia gives you certain additional
  26 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** If you have questions regarding the use of this file, please contact
  30 ** Nokia at qt-info@nokia.com.
  31 **
  32 **************************************************************************/
  33
  34 #ifndef DEBUGGER_CDBENGINE_H
  35 #define DEBUGGER_CDBENGINE_H
  36
  37 #include "debuggerengine.h"
  38 #include "breakpoint.h"
  39
  40 #include <QtCore/QSharedPointer>
  41 #include <QtCore/QProcess>
  42 #include <QtCore/QVariantList>
  43 #include <QtCore/QMap>
  44 #include <QtCore/QTime>
  45 #include <QtCore/QPair>
  46 #include <QtCore/QList>
  47
  48 namespace Utils {
  49 class ConsoleProcess;
  50 }
  51 namespace Debugger {
  52 namespace Internal {
  53
  54 class DisassemblerAgent;
  55 struct CdbBuiltinCommand;
  56 struct CdbExtensionCommand;
  57 struct CdbOptions;
  58 class ByteArrayInputStream;
  59 class GdbMi;
  60
  61 class CdbEngine : public Debugger::DebuggerEngine
  62 {
  63     Q_OBJECT
  64
  65 public:
  66     typedef QSharedPointer<CdbOptions> OptionsPtr;
  67
  68     enum CommandFlags { QuietCommand = 0x1 };
  69     // Flag bits for a sequence of commands
  70     enum CommandSequenceFlags {
  71         CommandListStack = 0x1,
  72         CommandListThreads = 0x2,
  73         CommandListRegisters = 0x4,
  74         CommandListModules = 0x8,
  75         CommandListBreakPoints = 0x10
  76     };
  77
  78     typedef QSharedPointer<CdbBuiltinCommand> CdbBuiltinCommandPtr;
  79     typedef QSharedPointer<CdbExtensionCommand> CdbExtensionCommandPtr;
  80     typedef void (CdbEngine::*BuiltinCommandHandler)(const CdbBuiltinCommandPtr &);
  81     typedef void (CdbEngine::*ExtensionCommandHandler)(const CdbExtensionCommandPtr &);
  82
  83     explicit CdbEngine(const DebuggerStartParameters &sp,
  84         DebuggerEngine *masterEngine,
  85         const OptionsPtr &options);
  86
  87     virtual ~CdbEngine();
  88     // Factory function that returns 0 if the debug engine library cannot be found.
  89
  90     virtual bool setToolTipExpression(const QPoint &mousePos, TextEditor::ITextEditor *editor,
  91                                       const DebuggerToolTipContext &ctx);
  92     virtual void setupEngine();
  93     virtual void setupInferior();
  94     virtual void runEngine();
  95     virtual void shutdownInferior();
  96     virtual void shutdownEngine();
  97     virtual void detachDebugger();
  98     virtual void updateWatchData(const WatchData &data,
  99                                  const WatchUpdateFlags & flags = WatchUpdateFlags());
 100     virtual unsigned debuggerCapabilities() const;
 101     virtual void watchPoint(const QPoint &);
 102     virtual void setRegisterValue(int regnr, const QString &value);
 103
 104     virtual void executeStep();
 105     virtual void executeStepOut();
 106     virtual void executeNext();
 107     virtual void executeStepI();
 108     virtual void executeNextI();
 109
 110     virtual void continueInferior();
 111     virtual void interruptInferior();
 112
 113     virtual void executeRunToLine(const ContextData &data);
 114     virtual void executeRunToFunction(const QString &functionName);
 115     virtual void executeJumpToLine(const ContextData &data);
 116     virtual void assignValueInDebugger(const WatchData *w, const QString &expr, const QVariant &value);
 117     virtual void executeDebuggerCommand(const QString &command);
 118
 119     virtual void activateFrame(int index);
 120     virtual void selectThread(int index);
 121
 122     virtual bool stateAcceptsBreakpointChanges() const;
 123     virtual bool acceptsBreakpoint(BreakpointId id) const;
 124     virtual void attemptBreakpointSynchronization();
 125
 126     virtual void fetchDisassembler(DisassemblerAgent *agent);
 127     virtual void fetchMemory(MemoryAgent *, QObject *, quint64 addr, quint64 length);
 128     virtual void changeMemory(Internal::MemoryAgent *, QObject *, quint64 addr, const QByteArray &data);
 129
 130     virtual void reloadModules();
 131     virtual void loadSymbols(const QString &moduleName);
 132     virtual void loadAllSymbols();
 133     virtual void requestModuleSymbols(const QString &moduleName);
 134
 135     virtual void reloadRegisters();
 136     virtual void reloadSourceFiles();
 137     virtual void reloadFullStack();
 138
 139     static QString extensionLibraryName(bool is64Bit);
 140
 141 private slots:
 142     void readyReadStandardOut();
 143     void readyReadStandardError();
 144     void processError();
 145     void processFinished();
 146     void postCommand(const QByteArray &cmd, unsigned flags);
 147     void postBuiltinCommand(const QByteArray &cmd,
 148                             unsigned flags,
 149                             BuiltinCommandHandler handler,
 150                             unsigned nextCommandFlag = 0,
 151                             const QVariant &cookie = QVariant());
 152
 153     void postExtensionCommand(const QByteArray &cmd,
 154                               const QByteArray &arguments,
 155                               unsigned flags,
 156                               ExtensionCommandHandler handler,
 157                               unsigned nextCommandFlag = 0,
 158                               const QVariant &cookie = QVariant());
 159
 160     void postCommandSequence(unsigned mask);
 161     void operateByInstructionTriggered(bool);
 162
 163     void consoleStubMessage(const QString &, bool);
 164     void consoleStubProcessStarted();
 165     void consoleStubExited();
 166
 167 private:
 168     typedef QHash<BreakpointId, BreakpointResponse> PendingBreakPointMap;
 169     typedef QPair<QString, QString> SourcePathMapping;
 170     struct NormalizedSourceFileName // Struct for caching mapped/normalized source files.
 171     {
 172         NormalizedSourceFileName(const QString &fn = QString(), bool e = false) : fileName(fn), exists(e) {}
 173
 174         QString fileName;
 175         bool exists;
 176     };
 177
 178     enum SpecialStopMode
 179     {
 180         NoSpecialStop,
 181         SpecialStopSynchronizeBreakpoints,
 182         SpecialStopGetWidgetAt,
 183         CustomSpecialStop // Associated with m_specialStopData, handleCustomSpecialStop()
 184     };
 185     enum ParseStackResultFlags // Flags returned by parseStackTrace
 186     {
 187         ParseStackStepInto = 1 // Need to execute a step, hit on a call frame in "Step into"
 188     };
 189
 190
 191     bool startConsole(const DebuggerStartParameters &sp, QString *errorMessage);
 192     void init();
 193     unsigned examineStopReason(const GdbMi &stopReason, QString *message,
 194                                QString *exceptionBoxMessage);
 195     bool commandsPending() const;
 196     void handleExtensionMessage(char t, int token, const QByteArray &what, const QByteArray &message);
 197     bool doSetupEngine(QString *errorMessage);
 198     bool launchCDB(const DebuggerStartParameters &sp, QString *errorMessage);
 199     void handleSessionAccessible(unsigned long cdbExState);
 200     void handleSessionInaccessible(unsigned long cdbExState);
 201     void handleSessionIdle(const QByteArray &message);
 202     void doInterruptInferior(SpecialStopMode sm);
 203     void doInterruptInferiorCustomSpecialStop(const QVariant &v);
 204     void doContinueInferior();
 205     inline void parseOutputLine(QByteArray line);
 206     inline bool isCdbProcessRunning() const { return m_process.state() != QProcess::NotRunning; }
 207     bool canInterruptInferior() const;
 208     void syncOperateByInstruction(bool operateByInstruction);
 209     void postWidgetAtCommand();
 210     void handleCustomSpecialStop(const QVariant &v);
 211
 212     // Builtin commands
 213     void dummyHandler(const CdbBuiltinCommandPtr &);
 214     void handleStackTrace(const CdbExtensionCommandPtr &);
 215     void handleRegisters(const CdbBuiltinCommandPtr &);
 216     void handleDisassembler(const CdbBuiltinCommandPtr &);
 217     void handleJumpToLineAddressResolution(const CdbBuiltinCommandPtr &);
 218     void jumpToAddress(quint64 address);
 219     // Extension commands
 220     void handleThreads(const CdbExtensionCommandPtr &);
 221     void handlePid(const CdbExtensionCommandPtr &reply);
 222     void handleLocals(const CdbExtensionCommandPtr &reply);
 223     void handleAddWatch(const CdbExtensionCommandPtr &reply);
 224     void handleExpandLocals(const CdbExtensionCommandPtr &reply);
 225     void handleRegisters(const CdbExtensionCommandPtr &reply);
 226     void handleModules(const CdbExtensionCommandPtr &reply);
 227     void handleMemory(const CdbExtensionCommandPtr &);
 228     void handleWidgetAt(const CdbExtensionCommandPtr &);
 229     void handleBreakPoints(const CdbExtensionCommandPtr &);
 230     void handleBreakPoints(const GdbMi &value);
 231     NormalizedSourceFileName sourceMapNormalizeFileNameFromDebugger(const QString &f);
 232     void updateLocalVariable(const QByteArray &iname);
 233     void updateLocals(bool forNewStackFrame = false);
 234     int elapsedLogTime() const;
 235     void addLocalsOptions(ByteArrayInputStream &s) const;
 236     unsigned parseStackTrace(const GdbMi &data, bool sourceStepInto);
 237     void parseThreads(const GdbMi &, int forceCurrentThreadId = -1);
 238
 239     const QByteArray m_creatorExtPrefix;
 240     const QByteArray m_tokenPrefix;
 241     const OptionsPtr m_options;
 242
 243     QProcess m_process;
 244     QScopedPointer<Utils::ConsoleProcess> m_consoleStub;
 245     DebuggerStartMode m_effectiveStartMode;
 246     QByteArray m_outputBuffer;
 247     unsigned long m_inferiorPid;
 248     //! Debugger accessible (expecting commands)
 249     bool m_accessible;
 250     SpecialStopMode m_specialStopMode;
 251     int m_nextCommandToken;
 252     QList<CdbBuiltinCommandPtr> m_builtinCommandQueue;
 253     int m_currentBuiltinCommandIndex; //!< Current command whose output is recorded.
 254     QList<CdbExtensionCommandPtr> m_extensionCommandQueue;
 255     QMap<QString, NormalizedSourceFileName> m_normalizedFileCache;
 256     const QByteArray m_extensionCommandPrefixBA; //!< Library name used as prefix
 257     bool m_operateByInstructionPending; //!< Creator operate by instruction action changed.
 258     bool m_operateByInstruction;
 259     bool m_notifyEngineShutdownOnTermination;
 260     bool m_hasDebuggee;
 261     QTime m_logTime;
 262     mutable int m_elapsedLogTime;
 263     QByteArray m_extensionMessageBuffer;
 264     bool m_sourceStepInto;
 265     int m_watchPointX;
 266     int m_watchPointY;
 267     PendingBreakPointMap m_pendingBreakpointMap;
 268     QHash<QString, QString> m_fileNameModuleHash;
 269     bool m_ignoreCdbOutput;
 270     QVariantList m_customSpecialStopData;
 271     QList<SourcePathMapping> m_sourcePathMappings;
 272 };
 273
 274 } // namespace Internal
 275 } // namespace Debugger
 276
 277 #endif // DEBUGGER_CDBENGINE_H