2 * Copyright Johannes Sixt
3 * This file is licensed under the GNU General Public License Version 2.
4 * See the file COPYING in the toplevel directory of the source directory.
25 * A type representing an address.
32 DbgAddr(const QString
& aa
);
33 DbgAddr(const DbgAddr
& src
) : a(src
.a
), fnoffs(src
.fnoffs
) { }
34 void operator=(const QString
& aa
);
35 void operator=(const DbgAddr
& src
) { a
= src
.a
; fnoffs
= src
.fnoffs
; }
36 QString
asString() const;
37 bool isEmpty() const { return a
.isEmpty(); }
41 bool operator==(const DbgAddr
& a1
, const DbgAddr
& a2
);
42 bool operator>(const DbgAddr
& a1
, const DbgAddr
& a2
);
61 DCsetoption
, /* debugger options */
71 DCuntil
, /* line number is zero-based! */
75 DCbreakline
, /* line number is zero-based! */
76 DCtbreakline
, /* line number is zero-based! */
102 RDNstdin
= 0x1, /* redirect stdin to /dev/null */
103 RDNstdout
= 0x2, /* redirect stdout to /dev/null */
104 RDNstderr
= 0x4 /* redirect stderr to /dev/null */
108 * How the memory dump is formated. The lowest 4 bits define the size of
109 * the entities. The higher bits define how these are formatted. Note that
110 * not all combinations make sense.
112 enum MemoryDumpType
{
136 * Debugger commands are placed in a queue. Only one command at a time is
137 * sent down to the debugger. All other commands in the queue are retained
138 * until the sent command has been processed by gdb. The debugger tells us
139 * that it's done with the command by sending the prompt. The output of the
140 * debugger is parsed at that time. Then, if more commands are in the
141 * queue, the next one is sent to the debugger.
147 bool m_committed
; /* just a debugging aid */
148 // remember which expression when printing an expression
151 // remember file position
155 // the breakpoint info
158 // whether command was emitted due to direct user request (only set when relevant)
160 // used to store the expression to print in case of DCprintPopup is executed
163 CmdQueueItem(DbgCommand cmd
, const QString
& str
) :
177 IsEqualCmd(DbgCommand cmd
, const QString
& str
) : m_cmd(cmd
), m_str(str
) { }
178 bool operator()(CmdQueueItem
*) const;
180 const QString
& m_str
;
185 * The information about a breakpoint that is parsed from the list of
190 int id
; /* gdb's number */
192 breakpoint
, watchpoint
197 QString text
; /* text if set using DCbreaktext */
198 DbgAddr address
; /* exact address of breakpoint */
199 QString condition
; /* condition as printed by gdb */
200 int ignoreCount
; /* ignore next that may hits */
201 int hitCount
; /* as reported by gdb */
202 // the following items repeat the location, but in a better usable way
204 int lineNo
; /* zero-based line number */
206 bool isOrphaned() const { return id
< 0; }
210 * Information about a stack frame.
215 int lineNo
; /* zero-based line number */
216 DbgAddr address
; /* exact address of PC */
220 * The information about a stack frame as parsed from the backtrace.
222 struct StackFrame
: FrameInfo
225 ExprValue
* var
; /* more information if non-zero */
226 StackFrame() : var(0) { }
231 * The information about a thread as parsed from the threads list.
233 struct ThreadInfo
: FrameInfo
235 int id
; /* gdb's number */
236 QString threadName
; /* the SYSTAG */
237 QString function
; /* where thread is halted */
238 bool hasFocus
; /* the thread whose stack we are watching */
242 * Register information
248 QString cookedValue
; /* may be empty */
249 QString type
; /* of vector register if not empty */
255 struct DisassembledCode
268 bool littleendian
= true;
269 bool endOfDump
= false;
273 * This is an abstract base class for debugger process.
275 * This class represents the debugger program. It provides the low-level
276 * interface to the commandline debugger. As such it implements the
277 * commands and parses the output.
279 class DebuggerDriver
: public QProcess
284 virtual ~DebuggerDriver() = 0;
286 virtual QString
driverName() const = 0;
288 * Returns the default command string to invoke the debugger driver.
290 virtual QString
defaultInvocation() const = 0;
293 * Returns a list of options that can be turned on and off.
295 virtual QStringList
boolOptionList() const = 0;
297 virtual bool startup(QString cmdStr
);
298 void setLogFileName(const QString
& fname
) { m_logFileName
= fname
; }
299 bool isRunning() { return state() != NotRunning
; }
305 DSidle
, /* gdb waits for input */
306 DSinterrupted
, /* a command was interrupted */
307 DSrunningLow
, /* gdb is running a low-priority command */
308 DSrunning
, /* gdb waits for program */
309 DScommandSent
, /* command has been sent, we wait for wroteStdin signal */
310 DScommandSentLow
/* low-prioritycommand has been sent */
312 DebuggerState m_state
;
315 bool isIdle() const { return m_state
== DSidle
; }
317 * Tells whether a high prority command would be executed immediately.
319 bool canExecuteImmediately() const { return m_hipriCmdQueue
.empty(); }
322 QByteArray m_output
; // normal gdb output
323 std::queue
<QByteArray
> m_delayedOutput
; // output colleced before signal bytesWritten() arrived
327 * Enqueues a high-priority command. High-priority commands are
328 * executed before any low-priority commands. No user interaction is
329 * possible as long as there is a high-priority command in the queue.
331 template<class... ARGS
>
332 CmdQueueItem
* executeCmd(DbgCommand cmd
, ARGS
&&... args
)
334 return executeCmdString(cmd
,
335 makeCmdString(cmd
, std::forward
<ARGS
>(args
)...), false);
337 template<class... ARGS
>
338 CmdQueueItem
* executeCmdOnce(DbgCommand cmd
, ARGS
&&... args
)
340 return executeCmdString(cmd
,
341 makeCmdString(cmd
, std::forward
<ARGS
>(args
)...), true);
345 QMnormal
, /* queues the command last */
346 QMoverride
, /* removes an already queued command */
347 QMoverrideMoreEqual
/* ditto, also puts the command first in the queue */
351 * Enqueues a low-priority command irrespective of whether it as already
353 * Low-priority commands are executed after any high-priority commands.
355 template<class... ARGS
>
356 CmdQueueItem
* queueCmdAgain(DbgCommand cmd
, ARGS
&&... args
)
358 return queueCmdString(cmd
,
359 makeCmdString(cmd
, std::forward
<ARGS
>(args
)...), QMnormal
);
363 * Enqueues a low-priority command, unless it is already in the queue.
364 * Low-priority commands are executed after any high-priority commands.
366 template<class... ARGS
>
367 CmdQueueItem
* queueCmd(DbgCommand cmd
, ARGS
&&... args
)
369 return queueCmdString(cmd
,
370 makeCmdString(cmd
, std::forward
<ARGS
>(args
)...), QMoverride
);
374 * Enqueues a low-priority command in front of all other low-prority
376 * Low-priority commands are executed after any high-priority commands.
378 template<class... ARGS
>
379 CmdQueueItem
* queueCmdPrio(DbgCommand cmd
, ARGS
&&... args
)
381 return queueCmdString(cmd
,
382 makeCmdString(cmd
, std::forward
<ARGS
>(args
)...), QMoverrideMoreEqual
);
386 * Flushes the command queues.
387 * @param hipriOnly if true, only the high priority queue is flushed.
389 virtual void flushCommands(bool hipriOnly
= false);
392 * Terminates the debugger process.
394 virtual void terminate() = 0;
397 * Terminates the debugger process, but also detaches any program that
398 * it has been attached to.
400 virtual void detachAndTerminate() = 0;
403 * Interrupts the debuggee.
405 virtual void interruptInferior() = 0;
408 * Specifies the command that prints the QString data.
410 virtual void setPrintQStringDataCmd(const char* cmd
) = 0;
413 * Parses the output as an array of QChars.
415 virtual ExprValue
* parseQCharArray(const char* output
, bool wantErrorValue
, bool qt3like
) = 0;
418 * Parses a back-trace (the output of the DCbt command).
420 virtual void parseBackTrace(const char* output
, std::list
<StackFrame
>& stack
) = 0;
423 * Parses the output of the DCframe command;
424 * @param frameNo Returns the frame number.
425 * @param file Returns the source file name.
426 * @param lineNo The zero-based line number.
427 * @param address Returns the exact address.
428 * @return false if the frame could not be parsed successfully. The
429 * output values are undefined in this case.
431 virtual bool parseFrameChange(const char* output
, int& frameNo
,
432 QString
& file
, int& lineNo
, DbgAddr
& address
) = 0;
435 * Parses a list of breakpoints.
436 * @param output The output of the debugger.
437 * @param brks The list of new #Breakpoint objects. The list
438 * must initially be empty.
439 * @return False if there was an error before the first breakpoint
440 * was found. Even if true is returned, #brks may be empty.
442 virtual bool parseBreakList(const char* output
, std::list
<Breakpoint
>& brks
) = 0;
445 * Parses a list of threads.
446 * @param output The output of the debugger.
447 * @return The new thread list. There is no indication if there was
450 virtual std::list
<ThreadInfo
> parseThreadList(const char* output
) = 0;
453 * Parses the output when the program stops to see whether this it
454 * stopped due to a breakpoint.
455 * @param output The output of the debugger.
456 * @param id Returns the breakpoint id.
457 * @param file Returns the file name in which the breakpoint is.
458 * @param lineNo Returns the zero-based line number of the breakpoint.
459 * @param address Returns the address of the breakpoint.
460 * @return False if there was no breakpoint.
462 virtual bool parseBreakpoint(const char* output
, int& id
,
463 QString
& file
, int& lineNo
, QString
& address
) = 0;
466 * Parses the output of the DCinfolocals command.
467 * @param output The output of the debugger.
468 * @param newVars Receives the parsed variable values. The values are
469 * simply append()ed to the supplied list.
471 virtual void parseLocals(const char* output
, std::list
<ExprValue
*>& newVars
) = 0;
474 * Parses the output of a DCprint or DCprintStruct command.
475 * @param output The output of the debugger.
476 * @param wantErrorValue Specifies whether the error message should be
477 * provided as the value of a NKplain variable. If this is false,
478 * 0 is returned if the printed value is an error message.
479 * @return the parsed value. It is 0 if there was a parse error
480 * or if the output is an error message and #wantErrorValue
481 * is \c false. The returned object's text() is undefined.
483 virtual ExprValue
* parsePrintExpr(const char* output
, bool wantErrorValue
) = 0;
486 * Parses the output of the DCcd command.
487 * @return false if the message is an error message.
489 virtual bool parseChangeWD(const char* output
, QString
& message
) = 0;
492 * Parses the output of the DCexecutable command.
493 * @return false if an error occured.
495 virtual bool parseChangeExecutable(const char* output
, QString
& message
) = 0;
498 * Parses the output of the DCcorefile command.
499 * @return false if the core file was not loaded successfully.
501 virtual bool parseCoreFile(const char* output
) = 0;
504 SFrefreshSource
= 1, /* refresh of source code is needed */
505 SFrefreshBreak
= 2, /* refresh breakpoints */
506 SFrefreshThreads
= 4, /* refresh thread list */
507 SFprogramActive
= 128 /* program remains active */
510 * Parses the output of commands that execute (a piece of) the program.
511 * \a haveCoreFile indicates whether the "stop" could be due to
512 * a core file being loaded.
513 * @return The inclusive OR of zero or more of the StopFlags.
515 virtual uint
parseProgramStopped(const char* output
, bool haveCoreFile
,
516 QString
& message
) = 0;
519 * Parses the output of the DCsharedlibs command.
521 virtual QStringList
parseSharedLibs(const char* output
) = 0;
524 * Parses the output of the DCfindType command.
525 * @return true if a type was found.
527 virtual bool parseFindType(const char* output
, QString
& type
) = 0;
530 * Parses the output of the DCinforegisters command.
532 virtual std::list
<RegisterInfo
> parseRegisters(const char* output
) = 0;
535 * Parses the output of the DCinfoline command. Returns false if the
536 * two addresses could not be found.
538 virtual bool parseInfoLine(const char* output
,
539 QString
& addrFrom
, QString
& addrTo
) = 0;
542 * Parses the ouput of the DCdisassemble command.
544 virtual std::list
<DisassembledCode
> parseDisassemble(const char* output
) = 0;
547 * Parses a memory dump. Returns an empty string if no error was found;
548 * otherwise it contains an error message.
550 virtual QString
parseMemoryDump(const char* output
, std::list
<MemoryDump
>& memdump
) = 0;
553 * Parses the output of the DCsetvariable command. Returns an empty
554 * string if no error was found; otherwise it contains an error
557 virtual QString
parseSetVariable(const char* output
) = 0;
560 * Returns a value that the user can edit.
562 virtual QString
editableValue(VarTree
* value
);
565 /** Removes all commands from the low-priority queue. */
566 void flushLoPriQueue();
567 /** Removes all commands from the high-priority queue. */
568 void flushHiPriQueue();
570 std::queue
<CmdQueueItem
*> m_hipriCmdQueue
;
571 std::list
<CmdQueueItem
*> m_lopriCmdQueue
;
573 * The active command is kept separately from other pending commands.
575 CmdQueueItem
* m_activeCmd
;
577 * Helper function that queues the given command string in the
578 * low-priority queue.
580 CmdQueueItem
* queueCmdString(DbgCommand cmd
, QString cmdString
,
583 * Helper function that queues the given command string in the
584 * high-priority queue.
586 CmdQueueItem
* executeCmdString(DbgCommand cmd
, QString cmdString
,
589 virtual void commandFinished(CmdQueueItem
* cmd
) = 0;
590 virtual QString
makeCmdString(DbgCommand cmd
) = 0;
591 virtual QString
makeCmdString(DbgCommand cmd
, QString strArg
) = 0;
592 virtual QString
makeCmdString(DbgCommand cmd
, int intArg
) = 0;
593 virtual QString
makeCmdString(DbgCommand cmd
, QString strArg
, int intArg
) = 0;
594 virtual QString
makeCmdString(DbgCommand cmd
, QString strArg1
, QString strArg2
) = 0;
595 virtual QString
makeCmdString(DbgCommand cmd
, int intArg1
, int intArg2
) = 0;
596 virtual QString
makeCmdString(DbgCommand cmd
, QString strArg
, int intArg1
, int intArg2
) = 0;
599 void processOutput(const QByteArray
& data
);
602 * Returns the start of the prompt in \a output or -1.
603 * \a len specifies the size of \a output, but in addition, the contents
604 * of \a output are NUL-terminated, i.e., \c output[len] is zero.
606 virtual int findPrompt(const QByteArray
& output
) const = 0;
609 QString m_logFileName
;
613 void dequeueCmdByVar(VarTree
* var
);
616 virtual void slotReceiveOutput();
617 virtual void slotCommandRead();
618 virtual void slotExited();
622 * This signal is emitted when the output of a command has been fully
623 * collected and is ready to be interpreted.
625 void commandReceived(CmdQueueItem
* cmd
, const char* output
);
628 * This signal is emitted when the debugger recognizes that a specific
629 * location in a file ought to be displayed.
631 * Gdb's --fullname option supports this for the step, next, frame, and
632 * run commands (and possibly others).
634 * @param file specifies the file; this is not necessarily a full path
635 * name, and if it is relative, you won't know relative to what, you
637 * @param lineNo specifies the line number (0-based!) (this may be
638 * negative, in which case the file should be activated, but the line
639 * should NOT be changed).
640 * @param address specifies the exact address of the PC or is empty.
642 void activateFileLine(const QString
& file
, int lineNo
, const DbgAddr
& address
);
645 * This signal is emitted when a command that starts the inferior has
646 * been submitted to the debugger.
648 void inferiorRunning();
651 * This signal is emitted when all output from the debugger has been
652 * consumed and no more commands are in the queues.
654 void enterIdleState();
657 #endif // DBGDRIVER_H