kdbg/dbgdriver.h

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #ifndef DBGDRIVER_H
   7 #define DBGDRIVER_H
   8
   9 #include <qqueue.h>
  10 #include <qlist.h>
  11 #include <qfile.h>
  12 #include <kprocess.h>
  13
  14
  15 class VarTree;
  16 class ExprWnd;
  17 class KDebugger;
  18
  19
  20 /**
  21  * A type representing an address.
  22  */
  23 struct DbgAddr
  24 {
  25     QString a;
  26     QString fnoffs;
  27     DbgAddr() { }
  28     DbgAddr(const QString& aa);
  29     DbgAddr(const DbgAddr& src) : a(src.a), fnoffs(src.fnoffs) { }
  30     void operator=(const QString& aa);
  31     void operator=(const DbgAddr& src) { a = src.a; fnoffs = src.fnoffs; }
  32     QString asString() const;
  33     bool isEmpty() const { return a.isEmpty(); }
  34 protected:
  35     void cleanAddr();
  36 };
  37 bool operator==(const DbgAddr& a1, const DbgAddr& a2);
  38 bool operator>(const DbgAddr& a1, const DbgAddr& a2);
  39
  40
  41 enum DbgCommand {
  42         DCinitialize,
  43         DCtty,
  44         DCexecutable,
  45         DCtargetremote,
  46         DCcorefile,
  47         DCattach,
  48         DCinfolinemain,
  49         DCinfolocals,
  50         DCinforegisters,
  51         DCexamine,
  52         DCinfoline,
  53         DCdisassemble,
  54         DCsetargs,
  55         DCsetenv,
  56         DCunsetenv,
  57         DCcd,
  58         DCbt,
  59         DCrun,
  60         DCcont,
  61         DCstep,
  62         DCstepi,
  63         DCnext,
  64         DCnexti,
  65         DCfinish,
  66         DCuntil,                        /* line number is zero-based! */
  67         DCkill,
  68         DCbreaktext,
  69         DCbreakline,                    /* line number is zero-based! */
  70         DCtbreakline,                   /* line number is zero-based! */
  71         DCbreakaddr,
  72         DCtbreakaddr,
  73         DCwatchpoint,
  74         DCdelete,
  75         DCenable,
  76         DCdisable,
  77         DCprint,
  78         DCprintStruct,
  79         DCprintQStringStruct,
  80         DCframe,
  81         DCfindType,
  82         DCinfosharedlib,
  83         DCthread,
  84         DCinfothreads,
  85         DCinfobreak,
  86         DCcondition,
  87         DCignore
  88 };
  89
  90 enum RunDevNull {
  91     RDNstdin = 0x1,                     /* redirect stdin to /dev/null */
  92     RDNstdout = 0x2,                    /* redirect stdout to /dev/null */
  93     RDNstderr = 0x4                     /* redirect stderr to /dev/null */
  94 };
  95
  96 /**
  97  * How the memory dump is formated. The lowest 4 bits define the size of
  98  * the entities. The higher bits define how these are formatted. Note that
  99  * not all combinations make sense.
 100  */
 101 enum MemoryDumpType {
 102     // sizes
 103     MDTbyte = 0x1,
 104     MDThalfword = 0x2,
 105     MDTword = 0x3,
 106     MDTgiantword = 0x4,
 107     MDTsizemask = 0xf,
 108     // formats
 109     MDThex = 0x10,
 110     MDTsigned = 0x20,
 111     MDTunsigned = 0x30,
 112     MDToctal = 0x40,
 113     MDTbinary = 0x50,
 114     MDTaddress = 0x60,
 115     MDTchar = 0x70,
 116     MDTfloat = 0x80,
 117     MDTstring = 0x90,
 118     MDTinsn = 0xa0,
 119     MDTformatmask = 0xf0
 120 };
 121
 122 /**
 123  * Debugger commands are placed in a queue. Only one command at a time is
 124  * sent down to the debugger. All other commands in the queue are retained
 125  * until the sent command has been processed by gdb. The debugger tells us
 126  * that it's done with the command by sending the prompt. The output of the
 127  * debugger is parsed at that time. Then, if more commands are in the
 128  * queue, the next one is sent to the debugger.
 129  */
 130 struct CmdQueueItem
 131 {
 132     DbgCommand m_cmd;
 133     QString m_cmdString;
 134     bool m_committed;                   /* just a debugging aid */
 135     // remember which expression when printing an expression
 136     VarTree* m_expr;
 137     ExprWnd* m_exprWnd;
 138     // remember file position
 139     QString m_fileName;
 140     int m_lineNo;
 141     // whether command was emitted due to direct user request (only set when relevant)
 142     bool m_byUser;
 143
 144     CmdQueueItem(DbgCommand cmd, const QString& str) :
 145         m_cmd(cmd),
 146         m_cmdString(str),
 147         m_committed(false),
 148         m_expr(0),
 149         m_exprWnd(0),
 150         m_lineNo(0),
 151         m_byUser(false)
 152     { }
 153 };
 154
 155 /**
 156  * The information about a breakpoint that is parsed from the list of
 157  * breakpoints.
 158  */
 159 struct Breakpoint
 160 {
 161     int id;                             /* gdb's number */
 162     enum Type {
 163         breakpoint, watchpoint
 164     } type;
 165     bool temporary;
 166     bool enabled;
 167     QString location;
 168     DbgAddr address;                    /* exact address of breakpoint */
 169     QString condition;                  /* condition as printed by gdb */
 170     int ignoreCount;                    /* ignore next that may hits */
 171     int hitCount;                       /* as reported by gdb */
 172     // the following items repeat the location, but in a better usable way
 173     QString fileName;
 174     int lineNo;                         /* zero-based line number */
 175 };
 176
 177 /**
 178  * Information about a stack frame.
 179  */
 180 struct FrameInfo
 181 {
 182     QString fileName;
 183     int lineNo;                         /* zero-based line number */
 184     DbgAddr address;                    /* exact address of PC */
 185 };
 186
 187 /**
 188  * The information about a stack frame as parsed from the backtrace.
 189  */
 190 struct StackFrame : FrameInfo
 191 {
 192     int frameNo;
 193     VarTree* var;                       /* more information if non-zero */
 194     StackFrame() : var(0) { }
 195     ~StackFrame();
 196 };
 197
 198 /**
 199  * The information about a thread as parsed from the threads list.
 200  */
 201 struct ThreadInfo : FrameInfo
 202 {
 203     int id;                             /* gdb's number */
 204     QString threadName;                 /* the SYSTAG */
 205     QString function;                   /* where thread is halted */
 206     bool hasFocus;                      /* the thread whose stack we are watching */
 207 };
 208
 209 /**
 210  * Register information
 211  */
 212 struct RegisterInfo
 213 {
 214     QString regName;
 215     QString rawValue;
 216     QString cookedValue;                /* may be empty */
 217 };
 218
 219 /**
 220  * Disassembled code
 221  */
 222 struct DisassembledCode
 223 {
 224     DbgAddr address;
 225     QString code;
 226 };
 227
 228 /**
 229  * Memory contents
 230  */
 231 struct MemoryDump
 232 {
 233     DbgAddr address;
 234     QString dump;
 235 };
 236
 237 /**
 238  * This is an abstract base class for debugger process.
 239  *
 240  * This class represents the debugger program. It provides the low-level
 241  * interface to the commandline debugger. As such it implements the
 242  * commands and parses the output.
 243  */
 244 class DebuggerDriver : public KProcess
 245 {
 246     Q_OBJECT
 247 public:
 248     DebuggerDriver();
 249     virtual ~DebuggerDriver() = 0;
 250
 251     virtual QString driverName() const = 0;
 252     /**
 253      * Returns the default command string to invoke the debugger driver.
 254      */
 255     virtual QString defaultInvocation() const = 0;
 256
 257     virtual bool startup(QString cmdStr);
 258     void dequeueCmdByVar(VarTree* var);
 259     void setLogFileName(const QString& fname) { m_logFileName = fname; }
 260
 261 protected:
 262     QString m_runCmd;
 263
 264     enum DebuggerState {
 265         DSidle,                         /* gdb waits for input */
 266         DSinterrupted,                  /* a command was interrupted */
 267         DSrunningLow,                   /* gdb is running a low-priority command */
 268         DSrunning,                      /* gdb waits for program */
 269         DScommandSent,                  /* command has been sent, we wait for wroteStdin signal */
 270         DScommandSentLow                /* low-prioritycommand has been sent */
 271     };
 272     DebuggerState m_state;
 273
 274 public:
 275     bool isIdle() const { return m_state == DSidle; }
 276     /**
 277      * Tells whether a high prority command would be executed immediately.
 278      */
 279     bool canExecuteImmediately() const { return m_hipriCmdQueue.isEmpty(); }
 280
 281 protected:
 282     char* m_output;                     /* normal gdb output */
 283     int m_outputLen;                    /* current accumulated output */
 284     int m_outputAlloc;                  /* space available in m_gdbOutput */
 285 #if QT_VERSION < 200
 286     typedef QString DelayedStr;
 287 #else
 288     typedef QCString DelayedStr;
 289 #endif
 290     QQueue<DelayedStr> m_delayedOutput; /* output colleced while we have receivedOutput */
 291                                         /* but before signal wroteStdin arrived */
 292
 293 public:
 294     /**
 295      * Enqueues a high-priority command. High-priority commands are
 296      * executed before any low-priority commands. No user interaction is
 297      * possible as long as there is a high-priority command in the queue.
 298      */
 299     virtual CmdQueueItem* executeCmd(DbgCommand,
 300                                      bool clearLow = false) = 0;
 301     virtual CmdQueueItem* executeCmd(DbgCommand, QString strArg,
 302                                      bool clearLow = false) = 0;
 303     virtual CmdQueueItem* executeCmd(DbgCommand, int intArg,
 304                                      bool clearLow = false) = 0;
 305     virtual CmdQueueItem* executeCmd(DbgCommand, QString strArg, int intArg,
 306                                      bool clearLow = false) = 0;
 307     virtual CmdQueueItem* executeCmd(DbgCommand, QString strArg1, QString strArg2,
 308                                      bool clearLow = false) = 0;
 309     virtual CmdQueueItem* executeCmd(DbgCommand, int intArg1, int intArg2,
 310                                      bool clearLow = false) = 0;
 311
 312     enum QueueMode {
 313         QMnormal,                       /* queues the command last */
 314         QMoverride,                     /* removes an already queued command */
 315         QMoverrideMoreEqual             /* ditto, also puts the command first in the queue */
 316     };
 317
 318     /**
 319      * Enqueues a low-priority command. Low-priority commands are executed
 320      * after any high-priority commands.
 321      */
 322     virtual CmdQueueItem* queueCmd(DbgCommand,
 323                                    QueueMode mode) = 0;
 324     virtual CmdQueueItem* queueCmd(DbgCommand, QString strArg,
 325                                    QueueMode mode) = 0;
 326     virtual CmdQueueItem* queueCmd(DbgCommand, int intArg,
 327                                    QueueMode mode) = 0;
 328     virtual CmdQueueItem* queueCmd(DbgCommand, QString strArg, int intArg,
 329                                    QueueMode mode) = 0;
 330     virtual CmdQueueItem* queueCmd(DbgCommand, QString strArg1, QString strArg2,
 331                                    QueueMode mode) = 0;
 332
 333     /**
 334      * Flushes the command queues.
 335      * @param hipriOnly if true, only the high priority queue is flushed.
 336      */
 337     virtual void flushCommands(bool hipriOnly = false);
 338
 339     /**
 340      * Terminates the debugger process.
 341      */
 342     virtual void terminate() = 0;
 343
 344     /**
 345      * Terminates the debugger process, but also detaches any program that
 346      * it has been attached to.
 347      */
 348     virtual void detachAndTerminate() = 0;
 349
 350     /**
 351      * Interrupts the debuggee.
 352      */
 353     virtual void interruptInferior() = 0;
 354
 355     /**
 356      * Parses the output as an array of QChars.
 357      */
 358     virtual VarTree* parseQCharArray(const char* output, bool wantErrorValue) = 0;
 359
 360     /**
 361      * Parses a back-trace (the output of the DCbt command).
 362      */
 363     virtual void parseBackTrace(const char* output, QList<StackFrame>& stack) = 0;
 364
 365     /**
 366      * Parses the output of the DCframe command;
 367      * @param frameNo Returns the frame number.
 368      * @param file Returns the source file name.
 369      * @param lineNo The zero-based line number.
 370      * @param address Returns the exact address.
 371      * @return false if the frame could not be parsed successfully. The
 372      * output values are undefined in this case.
 373      */
 374     virtual bool parseFrameChange(const char* output, int& frameNo,
 375                                   QString& file, int& lineNo, DbgAddr& address) = 0;
 376
 377     /**
 378      * Parses a list of breakpoints.
 379      * @param output The output of the debugger.
 380      * @param brks The list of new #Breakpoint objects. The list
 381      * must initially be empty.
 382      * @return False if there was an error before the first breakpoint
 383      * was found. Even if true is returned, #brks may be empty.
 384      */
 385     virtual bool parseBreakList(const char* output, QList<Breakpoint>& brks) = 0;
 386
 387     /**
 388      * Parses a list of threads.
 389      * @param output The output of the debugger.
 390      * @param threads The list of new #ThreadInfo objects. The list
 391      * must initially be empty.
 392      * @return False if there was an error before the first thread entry
 393      * was found. Even if true is returned, #threads may be empty.
 394      */
 395     virtual bool parseThreadList(const char* output, QList<ThreadInfo>& threads) = 0;
 396
 397     /**
 398      * Parses the output when the program stops to see whether this it
 399      * stopped due to a breakpoint.
 400      * @param output The output of the debugger.
 401      * @param id Returns the breakpoint id.
 402      * @param file Returns the file name in which the breakpoint is.
 403      * @param lineNo Returns he zero-based line number of the breakpoint.
 404      * @return False if there was no breakpoint.
 405      */
 406     virtual bool parseBreakpoint(const char* output, int& id,
 407                                  QString& file, int& lineNo) = 0;
 408
 409     /**
 410      * Parses the output of the DCinfolocals command.
 411      * @param output The output of the debugger.
 412      * @param newVars Receives the parsed variable values. The values are
 413      * simply append()ed to the supplied list.
 414      */
 415     virtual void parseLocals(const char* output, QList<VarTree>& newVars) = 0;
 416
 417     /**
 418      * Parses the output of a DCprint or DCprintStruct command.
 419      * @param output The output of the debugger.
 420      * @param wantErrorValue Specifies whether the error message should be
 421      * provided as the value of a NKplain variable. If this is false,
 422      * #var will be 0 if the printed value is an error message.
 423      * @param var Returns the variable value. It is set to 0 if there was
 424      * a parse error or if the output is an error message and wantErrorValue
 425      * is false. If it is not 0, #var->text() will return junk and must be
 426      * set using #var->setText().
 427      * @return false if the output is an error message. Even if true is
 428      * returned, #var might still be 0 (due to a parse error).
 429      */
 430     virtual bool parsePrintExpr(const char* output, bool wantErrorValue,
 431                                 VarTree*& var) = 0;
 432
 433     /**
 434      * Parses the output of the DCcd command.
 435      * @return false if the message is an error message.
 436      */
 437     virtual bool parseChangeWD(const char* output, QString& message) = 0;
 438
 439     /**
 440      * Parses the output of the DCexecutable command.
 441      * @return false if an error occured.
 442      */
 443     virtual bool parseChangeExecutable(const char* output, QString& message) = 0;
 444
 445     /**
 446      * Parses the output of the DCcorefile command.
 447      * @return false if the core file was not loaded successfully.
 448      */
 449     virtual bool parseCoreFile(const char* output) = 0;
 450
 451     enum StopFlags {
 452         SFrefreshSource = 1,            /* refresh of source code is needed */
 453         SFrefreshBreak = 2,             /* refresh breakpoints */
 454         SFrefreshThreads = 4,           /* refresh thread list */
 455         SFprogramActive = 128           /* program remains active */
 456     };
 457     /**
 458      * Parses the output of commands that execute (a piece of) the program.
 459      * @return The inclusive OR of zero or more of the StopFlags.
 460      */
 461     virtual uint parseProgramStopped(const char* output, QString& message) = 0;
 462
 463     /**
 464      * Parses the output of the DCsharedlibs command.
 465      */
 466     virtual void parseSharedLibs(const char* output, QStrList& shlibs) = 0;
 467
 468     /**
 469      * Parses the output of the DCfindType command.
 470      * @return true if a type was found.
 471      */
 472     virtual bool parseFindType(const char* output, QString& type) = 0;
 473
 474     /**
 475      * Parses the output of the DCinforegisters command.
 476      */
 477     virtual void parseRegisters(const char* output, QList<RegisterInfo>& regs) = 0;
 478
 479     /**
 480      * Parses the output of the DCinfoline command. Returns false if the
 481      * two addresses could not be found.
 482      */
 483     virtual bool parseInfoLine(const char* output,
 484                                QString& addrFrom, QString& addrTo) = 0;
 485
 486     /**
 487      * Parses the ouput of the DCdisassemble command.
 488      */
 489     virtual void parseDisassemble(const char* output, QList<DisassembledCode>& code) = 0;
 490
 491     /**
 492      * Parses a memory dump. Returns an empty string if no error was found;
 493      * otherwise it contains an error message.
 494      */
 495     virtual QString parseMemoryDump(const char* output, QList<MemoryDump>& memdump) = 0;
 496
 497 protected:
 498     /** Removes all commands from the low-priority queue. */
 499     void flushLoPriQueue();
 500     /** Removes all commands from  the high-priority queue. */
 501     void flushHiPriQueue();
 502
 503     QQueue<CmdQueueItem> m_hipriCmdQueue;
 504     QList<CmdQueueItem> m_lopriCmdQueue;
 505     /**
 506      * The active command is kept separately from other pending commands.
 507      */
 508     CmdQueueItem* m_activeCmd;
 509     /**
 510      * Helper function that queues the given command string in the
 511      * low-priority queue.
 512      */
 513     CmdQueueItem* queueCmdString(DbgCommand cmd, QString cmdString,
 514                                  QueueMode mode);
 515     /**
 516      * Helper function that queues the given command string in the
 517      * high-priority queue.
 518      */
 519     CmdQueueItem* executeCmdString(DbgCommand cmd, QString cmdString,
 520                                    bool clearLow);
 521     void writeCommand();
 522     virtual void commandFinished(CmdQueueItem* cmd) = 0;
 523
 524 protected:
 525     /** @internal */
 526     virtual int commSetupDoneC();
 527
 528     char m_prompt[10];
 529     int m_promptLen;
 530     char m_promptLastChar;
 531
 532     // log file
 533     QString m_logFileName;
 534     QFile m_logFile;
 535
 536 protected slots:
 537     void slotReceiveOutput(KProcess*, char* buffer, int buflen);
 538     void slotCommandRead(KProcess*);
 539     void slotExited(KProcess*);
 540
 541 signals:
 542     /**
 543      * This signal is emitted when the output of a command has been fully
 544      * collected and is ready to be interpreted.
 545      */
 546     void commandReceived(CmdQueueItem* cmd, const char* output);
 547
 548     /**
 549      * This signal is emitted when the debugger recognizes that a specific
 550      * location in a file ought to be displayed.
 551      *
 552      * Gdb's --fullname option supports this for the step, next, frame, and
 553      * run commands (and possibly others).
 554      *
 555      * @param file specifies the file; this is not necessarily a full path
 556      * name, and if it is relative, you won't know relative to what, you
 557      * can only guess.
 558      * @param lineNo specifies the line number (0-based!) (this may be
 559      * negative, in which case the file should be activated, but the line
 560      * should NOT be changed).
 561      * @param address specifies the exact address of the PC or is empty.
 562      */
 563     void activateFileLine(const QString& file, int lineNo, const DbgAddr& address);
 564
 565     /**
 566      * This signal is emitted when a command that starts the inferior has
 567      * been submitted to the debugger.
 568      */
 569     void inferiorRunning();
 570
 571     /**
 572      * This signal is emitted when all output from the debugger has been
 573      * consumed and no more commands are in the queues.
 574      */
 575     void enterIdleState();
 576 };
 577
 578 #endif // DBGDRIVER_H