src/plugins/debugger/gdb/trkgdbadapter.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_TRKGDBADAPTER_H
  35 #define DEBUGGER_TRKGDBADAPTER_H
  36
  37 #include "abstractgdbadapter.h"
  38 #include "localgdbprocess.h"
  39 #include "trkutils.h"
  40 #include "callback.h"
  41 #include "symbian.h"
  42
  43 #include <QtCore/QPointer>
  44 #include <QtCore/QSharedPointer>
  45 #include <QtCore/QStringList>
  46 #include <QtCore/QHash>
  47
  48 QT_BEGIN_NAMESPACE
  49 class QTcpServer;
  50 class QTcpSocket;
  51 QT_END_NAMESPACE
  52
  53 namespace trk {
  54 struct TrkResult;
  55 struct TrkMessage;
  56 class TrkDevice;
  57 }
  58
  59 namespace SymbianUtils {
  60 class SymbianDevice;
  61 }
  62
  63 namespace Debugger {
  64 namespace Internal {
  65
  66 struct MemoryRange;
  67 struct GdbResult;
  68
  69 ///////////////////////////////////////////////////////////////////////
  70 //
  71 // TrkGdbAdapter
  72 //
  73 ///////////////////////////////////////////////////////////////////////
  74
  75 class TrkGdbAdapter : public AbstractGdbAdapter
  76 {
  77     Q_OBJECT
  78
  79 public:
  80     typedef trk::TrkResult TrkResult;
  81     typedef trk::Callback<const TrkResult &> TrkCallback;
  82     typedef trk::Callback<const GdbResult &> GdbCallback;
  83
  84     TrkGdbAdapter(GdbEngine *engine);
  85     ~TrkGdbAdapter();
  86     void setGdbServerName(const QString &name);
  87     QString gdbServerName() const { return m_gdbServerName; }
  88     QString gdbServerIP() const;
  89     uint gdbServerPort() const;
  90     Q_SLOT void setVerbose(const QVariant &value);
  91     void setVerbose(int verbose);
  92     void setBufferedMemoryRead(bool b) { m_bufferedMemoryRead = b; }
  93     trk::Session &session() { return m_session; }
  94     void trkReloadRegisters();
  95     void trkReloadThreads();
  96
  97 signals:
  98     void output(const QString &msg);
  99
 100 private:
 101     QString m_gdbServerName; // 127.0.0.1:(2222+uid)
 102
 103     bool m_running;
 104
 105 public:
 106     //
 107     // Implementation of GdbProcessBase
 108     //
 109     void start(const QString &program, const QStringList &args,
 110         QIODevice::OpenMode mode = QIODevice::ReadWrite);
 111     void write(const QByteArray &data);
 112     bool isTrkAdapter() const { return true; }
 113
 114     virtual DumperHandling dumperHandling() const { return DumperNotAvailable; }
 115
 116 private:
 117     void startAdapter();
 118     bool initializeDevice(const QString &remoteChannel, QString *errorMessage);
 119     void setupInferior();
 120     void runEngine();
 121     void interruptInferior();
 122     void shutdownInferior();
 123     void shutdownAdapter();
 124     AbstractGdbProcess *gdbProc() { return &m_gdbProc; }
 125
 126     void cleanup();
 127     void emitDelayedInferiorSetupFailed(const QString &msg);
 128     Q_SLOT void slotEmitDelayedInferiorSetupFailed();
 129
 130     void handleTargetRemote(const GdbResponse &response);
 131
 132     //
 133     // TRK
 134     //
 135     void sendTrkMessage(trk::byte code,
 136         TrkCallback callback = TrkCallback(),
 137         const QByteArray &data = QByteArray(),
 138         const QVariant &cookie = QVariant());
 139     Q_SLOT void handleTrkResult(const trk::TrkResult &data);
 140     Q_SLOT void handleTrkError(const QString &msg);
 141     void trkContinueAll(const char *why);
 142     void trkKill();
 143     void handleTrkContinueNext(const TrkResult &result);
 144     void trkContinueNext(int threadIndex);
 145
 146     // convenience messages
 147     void sendTrkAck(trk::byte token);
 148
 149     void handleCpuType(const TrkResult &result);
 150     void handleCreateProcess(const TrkResult &result);
 151     void handleClearBreakpoint(const TrkResult &result);
 152     void handleStop(const TrkResult &result);
 153     void handleSupportMask(const TrkResult &result);
 154     void handleTrkVersionsStartGdb(const TrkResult &result);
 155     Q_SLOT void slotStartGdb();
 156     void handleDisconnect(const TrkResult &result);
 157     void handleDeleteProcess(const TrkResult &result);
 158     void handleDeleteProcess2(const TrkResult &result);
 159     void handleAndReportCreateProcess(const TrkResult &result);
 160     void handleAndReportReadRegisters(const TrkResult &result);
 161     void handleAndReportReadRegister(const TrkResult &result);
 162     void handleAndReportReadRegistersAfterStop(const TrkResult &result);
 163     void reportRegisters();
 164     void handleAndReportSetBreakpoint(const TrkResult &result);
 165     void handleReadMemoryBuffered(const TrkResult &result);
 166     void handleReadMemoryUnbuffered(const TrkResult &result);
 167     void handleStep(const TrkResult &result);
 168     void handleReadRegisters(const TrkResult &result);
 169     void handleWriteRegister(const TrkResult &result);
 170     void handleWriteMemory(const TrkResult &result);
 171     void reportToGdb(const TrkResult &result);
 172     void gdbSetCurrentThread(const QByteArray &cmd, const char *why);
 173     //void reportReadMemoryBuffered(const TrkResult &result);
 174     //void reportReadMemoryUnbuffered(const TrkResult &result);
 175
 176     void readMemory(uint addr, uint len, bool buffered);
 177     void writeMemory(uint addr, const QByteArray &data);
 178
 179     void handleDirectTrk(const TrkResult &response);
 180     void directStep(uint addr);
 181     void handleDirectStep1(const TrkResult &response);
 182     void handleDirectStep2(const TrkResult &response);
 183     void handleDirectStep3(const TrkResult &response);
 184
 185     void handleDirectWrite1(const TrkResult &response);
 186     void handleDirectWrite2(const TrkResult &response);
 187     void handleDirectWrite3(const TrkResult &response);
 188     void handleDirectWrite4(const TrkResult &response);
 189     void handleDirectWrite5(const TrkResult &response);
 190     void handleDirectWrite6(const TrkResult &response);
 191     void handleDirectWrite7(const TrkResult &response);
 192     void handleDirectWrite8(const TrkResult &response);
 193     void handleDirectWrite9(const TrkResult &response);
 194
 195     QByteArray trkContinueMessage(uint threadId);
 196     QByteArray trkWriteRegisterMessage(trk::byte reg, uint value);
 197     QByteArray trkReadMemoryMessage(const MemoryRange &range);
 198     QByteArray trkWriteMemoryMessage(uint addr, const QByteArray &date);
 199     QByteArray trkBreakpointMessage(uint addr, uint len, bool armMode = true);
 200     QByteArray trkStepRangeMessage();
 201     QByteArray trkDeleteProcessMessage();
 202     QByteArray trkInterruptMessage();
 203     Q_SLOT void trkDeviceRemoved(const SymbianUtils::SymbianDevice &);
 204
 205     QSharedPointer<trk::TrkDevice> m_trkDevice;
 206     QString m_adapterFailMessage;
 207
 208     Q_SLOT void handleGdbConnection();
 209     Q_SLOT void readGdbServerCommand();
 210     void readGdbResponse();
 211     void handleGdbServerCommand(const QByteArray &cmd);
 212     void sendGdbServerMessage(const QByteArray &msg,
 213         const QByteArray &logNote = QByteArray());
 214     void sendGdbServerMessageAfterTrkResponse(const QByteArray &msg,
 215         const QByteArray &logNote = QByteArray());
 216     void sendGdbServerAck();
 217     bool sendGdbServerPacket(const QByteArray &packet, bool doFlush);
 218     void tryAnswerGdbMemoryRequest(bool buffered);
 219
 220     void logMessage(const QString &msg, int logChannel = LogDebug);  // triggers output() if m_verbose
 221     Q_SLOT void trkLogMessage(const QString &msg);
 222
 223     QPointer<QTcpServer> m_gdbServer;
 224     QPointer<QTcpSocket> m_gdbConnection;
 225     QByteArray m_gdbReadBuffer;
 226     bool m_gdbAckMode;
 227
 228     // Debuggee state
 229     trk::Session m_session; // global-ish data (process id, target information)
 230     Symbian::Snapshot m_snapshot; // local-ish data (memory and registers)
 231     QString m_remoteExecutable;
 232     QString m_remoteArguments;
 233     QString m_symbolFile;
 234     QString m_symbolFileFolder;
 235     int m_verbose;
 236     bool m_bufferedMemoryRead;
 237     LocalGdbProcess m_gdbProc;
 238 };
 239
 240 } // namespace Internal
 241 } // namespace Debugger
 242
 243 #endif // DEBUGGER_TRKGDBADAPTER_H