kdbg/debugger.h

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #ifndef DEBUGGER_H
   7 #define DEBUGGER_H
   8
   9 #include <qtimer.h>
  10 #include <qdict.h>
  11 #include <qptrvector.h>
  12 #include <qstringlist.h>
  13 #include "envvar.h"
  14 #include "exprwnd.h"                    /* some compilers require this */
  15
  16 #ifdef HAVE_CONFIG_H
  17 #include "config.h"
  18 #endif
  19
  20 class ExprWnd;
  21 class VarTree;
  22 class ProgramTypeTable;
  23 class KTreeViewItem;
  24 class KConfig;
  25 class KConfigBase;
  26 class ProgramConfig;
  27 class QListBox;
  28 class RegisterInfo;
  29 class ThreadInfo;
  30 class DebuggerDriver;
  31 class CmdQueueItem;
  32 class Breakpoint;
  33 struct DisassembledCode;
  34 struct MemoryDump;
  35 struct DbgAddr;
  36 class KProcess;
  37
  38
  39 class KDebugger : public QObject
  40 {
  41     Q_OBJECT
  42 public:
  43     KDebugger(QWidget* parent,          /* will be used as the parent for dialogs */
  44               ExprWnd* localVars,
  45               ExprWnd* watchVars,
  46               QListBox* backtrace);
  47     ~KDebugger();
  48
  49     /**
  50      * This function starts to debug the specified executable using the
  51      * specified driver. If a program is currently being debugged, it is
  52      * terminated first. Ownership of driver is taken if and only if
  53      * true is returned.
  54      *
  55      * @return false if an error occurs.
  56      */
  57     bool debugProgram(const QString& executable,
  58                       DebuggerDriver* driver);
  59
  60     /**
  61      * Uses the specified core to debug the active program.
  62      * @param batch tells whether the core file was given on the
  63      * command line.
  64      */
  65     void useCoreFile(QString corefile, bool batch);
  66
  67     /**
  68      * Uses the specified pid to attach to the active program.
  69      */
  70     void setAttachPid(const QString& pid);
  71
  72     /**
  73      * Attaches to the specified process and debugs it.
  74      */
  75     void attachProgram(const QString& pid);
  76
  77     /**
  78      * Returns the file name of the per-program config file for the
  79      * specified program.
  80      */
  81     static QString getConfigForExe(const QString& exe);
  82
  83     /**
  84      * The driver name entry in the per-program config file.
  85      */
  86     static const char DriverNameEntry[];
  87
  88 public slots:
  89     /**
  90      * Runs the program or continues it if it is stopped at a breakpoint.
  91      */
  92     void programRun();
  93
  94     /**
  95      * Restarts the debuggee.
  96      */
  97     void programRunAgain();
  98
  99     /**
 100      * Performs a single-step, possibly stepping into a function call.
 101      * If byInsn is true, a step by instruction is performed.
 102      */
 103     void programStep();
 104
 105     /**
 106      * Performs a single-step, stepping over a function call.
 107      * If byInsn is true, a step by instruction is performed.
 108      */
 109     void programNext();
 110
 111     /**
 112      * Performs a single-step by instruction, possibly stepping into a
 113      * function call.
 114      */
 115     void programStepi();
 116
 117     /**
 118      * Performs a single-step by instruction, stepping over a function
 119      * call.
 120      */
 121     void programNexti();
 122
 123     /**
 124      * Runs the program until it returns from the current function.
 125      */
 126     void programFinish();
 127
 128     /**
 129      * Kills the program (removes it from memory).
 130      */
 131     void programKill();
 132
 133     /**
 134      * Interrupts the program if it is currently running.
 135      */
 136     void programBreak();
 137
 138     /**
 139      * Moves the program counter to the specified line.
 140      * If an address is given, it is moved to the address.
 141      */
 142     void setProgramCounter(const QString&, int, const DbgAddr&);
 143
 144 public:
 145     /**
 146      * Queries the user for program arguments.
 147      */
 148     void programArgs(QWidget* parent);
 149
 150     /**
 151      * Queries the user for program settings: Debugger command, terminal
 152      * emulator.
 153      */
 154     void programSettings(QWidget* parent);
 155
 156     /**
 157      * Setup remote debugging device
 158      */
 159     void setRemoteDevice(const QString& remoteDevice) { m_remoteDevice = remoteDevice; }
 160
 161     /**
 162      * Run the debuggee until the specified line in the specified file is
 163      * reached.
 164      *
 165      * @return false if the command was not executed, e.g. because the
 166      * debuggee is running at the moment.
 167      */
 168     bool runUntil(const QString& fileName, int lineNo);
 169
 170     /**
 171      * Set a breakpoint.
 172      *
 173      * @param fileName The source file in which to set the breakpoint.
 174      * @param lineNo The zero-based line number.
 175      * @param address The exact address of the breakpoint.
 176      * @param temporary Specifies whether this is a temporary breakpoint
 177      * @return false if the command was not executed, e.g. because the
 178      * debuggee is running at the moment.
 179      */
 180     bool setBreakpoint(QString fileName, int lineNo,
 181                        const DbgAddr& address, bool temporary);
 182
 183     /**
 184      * Set a breakpoint.
 185      *
 186      * @param bp Describes the breakpoint.
 187      * @param queueOnly If false, the breakpoint is set using a high-priority command.
 188      */
 189     void setBreakpoint(Breakpoint* bp, bool queueOnly);
 190
 191     /**
 192      * Enable or disable a breakpoint at the specified location.
 193      *
 194      * @param fileName The source file in which the breakpoint is.
 195      * @param lineNo The zero-based line number.
 196      * @param address The exact address of the breakpoint.
 197      * @return false if the command was not executed, e.g. because the
 198      * debuggee is running at the moment.
 199      */
 200     bool enableDisableBreakpoint(QString fileName, int lineNo,
 201                                  const DbgAddr& address);
 202
 203     /**
 204      * Enables or disables the specified breakpoint.
 205      *
 206      * @return false if the command was not executed, e.g. because the
 207      * debuggee is running at the moment.
 208      */
 209     bool enableDisableBreakpoint(Breakpoint* bp);
 210
 211     /**
 212      * Removes the specified breakpoint. Note that if bp is an orphaned
 213      * breakpoint, then bp is an invalid pointer if (and only if) this
 214      * function returns true.
 215      *
 216      * @return false if the command was not executed, e.g. because the
 217      * debuggee is running at the moment.
 218      */
 219     bool deleteBreakpoint(Breakpoint* bp);
 220
 221     /**
 222      * Changes the specified breakpoint's condition and ignore count.
 223      *
 224      * @return false if the command was not executed, e.g. because the
 225      * debuggee is running at the moment.
 226      */
 227     bool conditionalBreakpoint(Breakpoint* bp,
 228                                const QString& condition,
 229                                int ignoreCount);
 230
 231     /**
 232      * Tells whether one of the single stepping commands can be invoked
 233      * (step, next, finish, until, also run).
 234      */
 235     bool canSingleStep();
 236
 237     /**
 238      * Tells whether a breakpoints can be set, deleted, enabled, or disabled.
 239      */
 240     bool canChangeBreakpoints();
 241
 242     /**
 243      * Tells whether a the program is loaded, but not active.
 244      */
 245     bool canStart();
 246
 247     /**
 248      * Add a watch expression.
 249      */
 250     void addWatch(const QString& expr);
 251
 252     /**
 253      * Retrieves the current status message.
 254      */
 255     const QString& statusMessage() const { return m_statusMessage; }
 256
 257     /**
 258      * Is the debugger ready to receive another high-priority command?
 259      */
 260     bool isReady() const;
 261
 262     /**
 263      * Is the debuggee running (not just active)?
 264      */
 265     bool isProgramRunning() { return m_haveExecutable && m_programRunning; }
 266
 267     /**
 268      * Do we have an executable set?
 269      */
 270     bool haveExecutable() { return m_haveExecutable; }
 271
 272     /**
 273      * Is the debuggee active, i.e. was it started by the debugger?
 274      */
 275     bool isProgramActive() { return m_programActive; }
 276
 277     /**
 278      * Is the debugger driver idle?
 279      */
 280     bool isIdle() const;
 281
 282     /** The list of breakpoints. */
 283     int numBreakpoints() const { return m_brkpts.size(); }
 284     const Breakpoint* breakpoint(int i) const { return m_brkpts[i]; }
 285
 286     /**
 287      * Returns the breakpoint with the specified \a id.
 288      */
 289     Breakpoint* breakpointById(int id);
 290
 291     const QString& executable() const { return m_executable; }
 292
 293     /**
 294      * Terminal emulation level.
 295      */
 296     enum TTYLevel {
 297         ttyNone = 0,                    /* ignore output, input triggers EOF */
 298         ttySimpleOutputOnly = 1,        /* minmal output emulation, input triggers EOF */
 299         ttyFull = 7                     /* program needs full emulation */
 300     };
 301
 302     /**
 303      * Returns the level of terminal emulation requested by the inferior.
 304      */
 305     TTYLevel ttyLevel() const { return m_ttyLevel; }
 306
 307     /** Sets the terminal that is to be used by the debugger. */
 308     void setTerminal(const QString& term) { m_inferiorTerminal = term; }
 309
 310     /** Returns the debugger driver. */
 311     DebuggerDriver* driver() { return m_d; }
 312
 313     /** Returns the pid that the debugger is currently attached to. */
 314     const QString& attachedPid() const { return m_attachedPid; }
 315
 316     /**
 317      * The memory at that the expression evaluates to is watched. Can be
 318      * empty. Triggers a redisplay even if the expression did not change.
 319      */
 320     void setMemoryExpression(const QString& memexpr);
 321
 322     /**
 323      * Sets how the watched memory location is displayed.
 324      * Call setMemoryExpression() to force a redisplay.
 325      */
 326     void setMemoryFormat(unsigned format) { m_memoryFormat = format; }
 327
 328     // settings
 329     void saveSettings(KConfig*);
 330     void restoreSettings(KConfig*);
 331
 332 protected:
 333     QString m_inferiorTerminal;
 334     QString m_debuggerCmd;              /* per-program setting */
 335     TTYLevel m_ttyLevel;                /* level of terminal emulation */
 336     bool startDriver();
 337     void stopDriver();
 338     void writeCommand();
 339
 340     QList<VarTree> m_watchEvalExpr;     /* exprs to evaluate for watch windows */
 341     QPtrVector<Breakpoint> m_brkpts;
 342     QString m_memoryExpression;         /* memory location to watch */
 343     unsigned m_memoryFormat;            /* how that output should look */
 344
 345 protected slots:
 346     void parse(CmdQueueItem* cmd, const char* output);
 347 protected:
 348     VarTree* parseExpr(const char* output, bool wantErrorValue);
 349     void handleRunCommands(const char* output);
 350     void updateAllExprs();
 351     void updateProgEnvironment(const QString& args, const QString& wd,
 352                                const QDict<EnvVar>& newVars,
 353                                const QStringList& newOptions);
 354     void parseLocals(const char* output, QList<VarTree>& newVars);
 355     void handleLocals(const char* output);
 356     bool handlePrint(CmdQueueItem* cmd, const char* output);
 357     bool handlePrintDeref(CmdQueueItem* cmd, const char* output);
 358     void handleBacktrace(const char* output);
 359     void handleFrameChange(const char* output);
 360     void handleFindType(CmdQueueItem* cmd, const char* output);
 361     void handlePrintStruct(CmdQueueItem* cmd, const char* output);
 362     void handleSharedLibs(const char* output);
 363     void handleRegisters(const char* output);
 364     void handleMemoryDump(const char* output);
 365     void handleInfoLine(CmdQueueItem* cmd, const char* output);
 366     void handleDisassemble(CmdQueueItem* cmd, const char* output);
 367     void handleThreadList(const char* output);
 368     void handleSetPC(const char* output);
 369     void handleSetVariable(CmdQueueItem* cmd, const char* output);
 370     void evalExpressions();
 371     void evalInitialStructExpression(VarTree* var, ExprWnd* wnd, bool immediate);
 372     void evalStructExpression(VarTree* var, ExprWnd* wnd, bool immediate);
 373     void exprExpandingHelper(ExprWnd* wnd, KTreeViewItem* item, bool& allow);
 374     void dereferencePointer(ExprWnd* wnd, VarTree* var, bool immediate);
 375     void determineType(ExprWnd* wnd, VarTree* var);
 376     void removeExpr(ExprWnd* wnd, VarTree* var);
 377     void queueMemoryDump(bool immediate);
 378     CmdQueueItem* loadCoreFile();
 379     void openProgramConfig(const QString& name);
 380
 381     Breakpoint* breakpointByFilePos(QString file, int lineNo,
 382                                     const DbgAddr& address);
 383     void newBreakpoint(CmdQueueItem* cmd, const char* output);
 384     void updateBreakList(const char* output);
 385     bool stopMayChangeBreakList() const;
 386     void saveBreakpoints(ProgramConfig* config);
 387     void restoreBreakpoints(ProgramConfig* config);
 388
 389     bool m_haveExecutable;              /* has an executable been specified */
 390     bool m_programActive;               /* is the program active (possibly halting in a brkpt)? */
 391     bool m_programRunning;              /* is the program executing (not stopped)? */
 392     bool m_sharedLibsListed;            /* do we know the shared libraries loaded by the prog? */
 393     QString m_executable;
 394     QString m_corefile;
 395     QString m_attachedPid;              /* user input of attaching to pid */
 396     QString m_programArgs;
 397     QString m_remoteDevice;
 398     QString m_programWD;                /* working directory of gdb */
 399     QDict<EnvVar> m_envVars;            /* environment variables set by user */
 400     QStringList m_boolOptions;          /* boolean options */
 401     QStrList m_sharedLibs;              /* shared libraries used by program */
 402     ProgramTypeTable* m_typeTable;      /* known types used by the program */
 403     ProgramConfig* m_programConfig;     /* program-specific settings (brkpts etc) */
 404     void saveProgramSettings();
 405     void restoreProgramSettings();
 406     QString readDebuggerCmd();
 407
 408     // debugger process
 409     DebuggerDriver* m_d;
 410     bool m_explicitKill;                /* whether we are killing gdb ourselves */
 411
 412     QString m_statusMessage;
 413
 414 protected slots:
 415     void gdbExited(KProcess*);
 416     void slotInferiorRunning();
 417     void backgroundUpdate();
 418     void gotoFrame(int);
 419     void slotLocalsExpanding(KTreeViewItem*, bool&);
 420     void slotWatchExpanding(KTreeViewItem*, bool&);
 421     void slotDeleteWatch();
 422     void slotValuePopup(const QString&);
 423     void slotDisassemble(const QString&, int);
 424     void slotValueEdited(int, const QString&);
 425 public slots:
 426     void setThread(int);
 427     void shutdown();
 428
 429 signals:
 430     /**
 431      * This signal is emitted before the debugger is started. The slot is
 432      * supposed to set up m_inferiorTerminal.
 433      */
 434     void debuggerStarting();
 435
 436     /**
 437      * This signal is emitted whenever a part of the debugger needs to
 438      * highlight the specfied source code line (e.g. when the program
 439      * stops).
 440      *
 441      * @param file specifies the file; this is not necessarily a full path
 442      * name, and if it is relative, you won't know relative to what, you
 443      * can only guess.
 444      * @param lineNo specifies the line number (0-based!) (this may be
 445      * negative, in which case the file should be activated, but the line
 446      * should NOT be changed).
 447      * @param address specifies the exact address of the PC or is empty.
 448      */
 449     void activateFileLine(const QString& file, int lineNo, const DbgAddr& address);
 450
 451     /**
 452      * This signal indicates that the program counter has changed.
 453      *
 454      * @param filename specifies the filename where the program stopped
 455      * @param lineNo specifies the line number (zero-based); it can be -1
 456      * if it is unknown
 457      * @param address specifies the address that the instruction pointer
 458      * points to.
 459      * @param frameNo specifies the frame number: 0 is the innermost frame,
 460      * positive numbers are frames somewhere up the stack (indicates points
 461      * where a function was called); the latter cases should be indicated
 462      * differently in the source window.
 463      */
 464     void updatePC(const QString& filename, int lineNo,
 465                   const DbgAddr& address, int frameNo);
 466
 467     /**
 468      * This signal is emitted when gdb detects that the executable has been
 469      * updated, e.g. recompiled. (You usually need not handle this signal
 470      * if you are the editor which changed the executable.)
 471      */
 472     void executableUpdated();
 473
 474     /**
 475      * Indicates that a new status message is available.
 476      */
 477     void updateStatusMessage();
 478
 479     /**
 480      * Indicates that the internal state of the debugger has changed, and
 481      * that this will very likely have an impact on the UI.
 482      */
 483     void updateUI();
 484
 485     /**
 486      * Indicates that the list of breakpoints has possibly changed.
 487      */
 488     void breakpointsChanged();
 489
 490     /**
 491      * Indicates that the register values have possibly changed.
 492      */
 493     void registersChanged(QList<RegisterInfo>&);
 494
 495     /**
 496      * Indicates that the list of threads has possibly changed.
 497      */
 498     void threadsChanged(QList<ThreadInfo>&);
 499
 500     /**
 501      * Indicates that the value for a value popup is ready.
 502      */
 503     void valuePopup(const QString&);
 504
 505     /**
 506      * Provides the disassembled code of the location given by file and
 507      * line number (zero-based).
 508      */
 509     void disassembled(const QString& file, int line, const QList<DisassembledCode>& code);
 510
 511     /**
 512      * Indicates that the program has stopped for any reason: by a
 513      * breakpoint, by a signal that the debugger driver caught, by a single
 514      * step instruction.
 515      */
 516     void programStopped();
 517
 518     /**
 519      * Indicates that a new memory dump output is ready.
 520      * @param msg is an error message or empty
 521      * @param memdump is the memory dump
 522      */
 523     void memoryDumpChanged(const QString&, QList<MemoryDump>&);
 524
 525     /**
 526      * Gives other objects a chance to save program specific settings.
 527      */
 528     void saveProgramSpecific(KConfigBase* config);
 529
 530     /**
 531      * Gives other objects a chance to restore program specific settings.
 532      */
 533     void restoreProgramSpecific(KConfigBase* config);
 534
 535 protected:
 536     ExprWnd& m_localVariables;
 537     ExprWnd& m_watchVariables;
 538     QListBox& m_btWindow;
 539
 540     // implementation helpers
 541 protected:
 542     QWidget* parentWidget() { return static_cast<QWidget*>(parent()); }
 543
 544     friend class BreakpointTable;
 545 };
 546
 547 #endif // DEBUGGER_H