This is gdb.info, produced by makeinfo version 4.13 from ./gdb.texinfo.

INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
* Gdb: (gdb).                     The GNU debugger.
END-INFO-DIR-ENTRY

   Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
2010 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "Free Software" and "Free Software Needs Free
Documentation", with the Front-Cover Texts being "A GNU Manual," and
with the Back-Cover Texts as in (a) below.

   (a) The FSF's Back-Cover Text is: "You are free to copy and modify
this GNU Manual.  Buying copies from GNU Press supports the FSF in
developing GNU and promoting software freedom."

   This file documents the GNU debugger GDB.

   This is the Tenth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (Linaro GDB) Version 7.3-2011.12.

   Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
2010 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "Free Software" and "Free Software Needs Free
Documentation", with the Front-Cover Texts being "A GNU Manual," and
with the Back-Cover Texts as in (a) below.

   (a) The FSF's Back-Cover Text is: "You are free to copy and modify
this GNU Manual.  Buying copies from GNU Press supports the FSF in
developing GNU and promoting software freedom."


File: gdb.info,  Node: Debug Session,  Prev: Bootstrapping,  Up: Remote Stub

20.5.3 Putting it All Together
------------------------------

In summary, when your program is ready to debug, you must follow these
steps.

  1. Make sure you have defined the supporting low-level routines
     (*note What You Must Do for the Stub: Bootstrapping.):
          `getDebugChar', `putDebugChar',
          `flush_i_cache', `memset', `exceptionHandler'.

  2. Insert these lines near the top of your program:

          set_debug_traps();
          breakpoint();

  3. For the 680x0 stub only, you need to provide a variable called
     `exceptionHook'.  Normally you just use:

          void (*exceptionHook)() = 0;

     but if before calling `set_debug_traps', you set it to point to a
     function in your program, that function is called when `GDB'
     continues after stopping on a trap (for example, bus error).  The
     function indicated by `exceptionHook' is called with one
     parameter: an `int' which is the exception number.

  4. Compile and link together: your program, the GDB debugging stub for
     your target architecture, and the supporting subroutines.

  5. Make sure you have a serial connection between your target machine
     and the GDB host, and identify the serial port on the host.

  6. Download your program to your target machine (or get it there by
     whatever means the manufacturer provides), and start it.

  7. Start GDB on the host, and connect to the target (*note Connecting
     to a Remote Target: Connecting.).



File: gdb.info,  Node: Configurations,  Next: Controlling GDB,  Prev: Remote Debugging,  Up: Top

21 Configuration-Specific Information
*************************************

While nearly all GDB commands are available for all native and cross
versions of the debugger, there are some exceptions.  This chapter
describes things that are only available in certain configurations.

   There are three major categories of configurations: native
configurations, where the host and target are the same, embedded
operating system configurations, which are usually the same for several
different processor architectures, and bare embedded processors, which
are quite different from each other.

* Menu:

* Native::
* Embedded OS::
* Embedded Processors::
* Architectures::


File: gdb.info,  Node: Native,  Next: Embedded OS,  Up: Configurations

21.1 Native
===========

This section describes details specific to particular native
configurations.

* Menu:

* HP-UX::                       HP-UX
* BSD libkvm Interface::	Debugging BSD kernel memory images
* SVR4 Process Information::    SVR4 process information
* DJGPP Native::                Features specific to the DJGPP port
* Cygwin Native::		Features specific to the Cygwin port
* Hurd Native::                 Features specific to GNU Hurd
* Neutrino::                    Features specific to QNX Neutrino
* Darwin::			Features specific to Darwin


File: gdb.info,  Node: HP-UX,  Next: BSD libkvm Interface,  Up: Native

21.1.1 HP-UX
------------

On HP-UX systems, if you refer to a function or variable name that
begins with a dollar sign, GDB searches for a user or system name
first, before it searches for a convenience variable.


File: gdb.info,  Node: BSD libkvm Interface,  Next: SVR4 Process Information,  Prev: HP-UX,  Up: Native

21.1.2 BSD libkvm Interface
---------------------------

BSD-derived systems (FreeBSD/NetBSD/OpenBSD) have a kernel memory
interface that provides a uniform interface for accessing kernel virtual
memory images, including live systems and crash dumps.  GDB uses this
interface to allow you to debug live kernels and kernel crash dumps on
many native BSD configurations.  This is implemented as a special `kvm'
debugging target.  For debugging a live system, load the currently
running kernel into GDB and connect to the `kvm' target:

     (gdb) target kvm

   For debugging crash dumps, provide the file name of the crash dump
as an argument:

     (gdb) target kvm /var/crash/bsd.0

   Once connected to the `kvm' target, the following commands are
available:

`kvm pcb'
     Set current context from the "Process Control Block" (PCB) address.

`kvm proc'
     Set current context from proc address.  This command isn't
     available on modern FreeBSD systems.


File: gdb.info,  Node: SVR4 Process Information,  Next: DJGPP Native,  Prev: BSD libkvm Interface,  Up: Native

21.1.3 SVR4 Process Information
-------------------------------

Many versions of SVR4 and compatible systems provide a facility called
`/proc' that can be used to examine the image of a running process
using file-system subroutines.  If GDB is configured for an operating
system with this facility, the command `info proc' is available to
report information about the process running your program, or about any
process running on your system.  `info proc' works only on SVR4 systems
that include the `procfs' code.  This includes, as of this writing,
GNU/Linux, OSF/1 (Digital Unix), Solaris, Irix, and Unixware, but not
HP-UX, for example.

`info proc'
`info proc PROCESS-ID'
     Summarize available information about any running process.  If a
     process ID is specified by PROCESS-ID, display information about
     that process; otherwise display information about the program being
     debugged.  The summary includes the debugged process ID, the
     command line used to invoke it, its current working directory, and
     its executable file's absolute file name.

     On some systems, PROCESS-ID can be of the form `[PID]/TID' which
     specifies a certain thread ID within a process.  If the optional
     PID part is missing, it means a thread from the process being
     debugged (the leading `/' still needs to be present, or else GDB
     will interpret the number as a process ID rather than a thread ID).

`info proc mappings'
     Report the memory address space ranges accessible in the program,
     with information on whether the process has read, write, or
     execute access rights to each range.  On GNU/Linux systems, each
     memory range includes the object file which is mapped to that
     range, instead of the memory access rights to that range.

`info proc stat'
`info proc status'
     These subcommands are specific to GNU/Linux systems.  They show
     the process-related information, including the user ID and group
     ID; how many threads are there in the process; its virtual memory
     usage; the signals that are pending, blocked, and ignored; its
     TTY; its consumption of system and user time; its stack size; its
     `nice' value; etc.  For more information, see the `proc' man page
     (type `man 5 proc' from your shell prompt).

`info proc all'
     Show all the information about the process described under all of
     the above `info proc' subcommands.

`set procfs-trace'
     This command enables and disables tracing of `procfs' API calls.

`show procfs-trace'
     Show the current state of `procfs' API call tracing.

`set procfs-file FILE'
     Tell GDB to write `procfs' API trace to the named FILE.  GDB
     appends the trace info to the previous contents of the file.  The
     default is to display the trace on the standard output.

`show procfs-file'
     Show the file to which `procfs' API trace is written.

`proc-trace-entry'
`proc-trace-exit'
`proc-untrace-entry'
`proc-untrace-exit'
     These commands enable and disable tracing of entries into and exits
     from the `syscall' interface.

`info pidlist'
     For QNX Neutrino only, this command displays the list of all the
     processes and all the threads within each process.

`info meminfo'
     For QNX Neutrino only, this command displays the list of all
     mapinfos.


File: gdb.info,  Node: DJGPP Native,  Next: Cygwin Native,  Prev: SVR4 Process Information,  Up: Native

21.1.4 Features for Debugging DJGPP Programs
--------------------------------------------

DJGPP is a port of the GNU development tools to MS-DOS and MS-Windows.
DJGPP programs are 32-bit protected-mode programs that use the "DPMI"
(DOS Protected-Mode Interface) API to run on top of real-mode DOS
systems and their emulations.

   GDB supports native debugging of DJGPP programs, and defines a few
commands specific to the DJGPP port.  This subsection describes those
commands.

`info dos'
     This is a prefix of DJGPP-specific commands which print
     information about the target system and important OS structures.

`info dos sysinfo'
     This command displays assorted information about the underlying
     platform: the CPU type and features, the OS version and flavor, the
     DPMI version, and the available conventional and DPMI memory.

`info dos gdt'
`info dos ldt'
`info dos idt'
     These 3 commands display entries from, respectively, Global, Local,
     and Interrupt Descriptor Tables (GDT, LDT, and IDT).  The
     descriptor tables are data structures which store a descriptor for
     each segment that is currently in use.  The segment's selector is
     an index into a descriptor table; the table entry for that index
     holds the descriptor's base address and limit, and its attributes
     and access rights.

     A typical DJGPP program uses 3 segments: a code segment, a data
     segment (used for both data and the stack), and a DOS segment
     (which allows access to DOS/BIOS data structures and absolute
     addresses in conventional memory).  However, the DPMI host will
     usually define additional segments in order to support the DPMI
     environment.

     These commands allow to display entries from the descriptor tables.
     Without an argument, all entries from the specified table are
     displayed.  An argument, which should be an integer expression,
     means display a single entry whose index is given by the argument.
     For example, here's a convenient way to display information about
     the debugged program's data segment:

     `(gdb) info dos ldt $ds'
     `0x13f: base=0x11970000 limit=0x0009ffff 32-Bit Data (Read/Write, Exp-up)'


     This comes in handy when you want to see whether a pointer is
     outside the data segment's limit (i.e. "garbled").

`info dos pde'
`info dos pte'
     These two commands display entries from, respectively, the Page
     Directory and the Page Tables.  Page Directories and Page Tables
     are data structures which control how virtual memory addresses are
     mapped into physical addresses.  A Page Table includes an entry
     for every page of memory that is mapped into the program's address
     space; there may be several Page Tables, each one holding up to
     4096 entries.  A Page Directory has up to 4096 entries, one each
     for every Page Table that is currently in use.

     Without an argument, `info dos pde' displays the entire Page
     Directory, and `info dos pte' displays all the entries in all of
     the Page Tables.  An argument, an integer expression, given to the
     `info dos pde' command means display only that entry from the Page
     Directory table.  An argument given to the `info dos pte' command
     means display entries from a single Page Table, the one pointed to
     by the specified entry in the Page Directory.

     These commands are useful when your program uses "DMA" (Direct
     Memory Access), which needs physical addresses to program the DMA
     controller.

     These commands are supported only with some DPMI servers.

`info dos address-pte ADDR'
     This command displays the Page Table entry for a specified linear
     address.  The argument ADDR is a linear address which should
     already have the appropriate segment's base address added to it,
     because this command accepts addresses which may belong to _any_
     segment.  For example, here's how to display the Page Table entry
     for the page where a variable `i' is stored:

     `(gdb) info dos address-pte __djgpp_base_address + (char *)&i'
     `Page Table entry for address 0x11a00d30:'
     `Base=0x02698000 Dirty Acc. Not-Cached Write-Back Usr Read-Write +0xd30'


     This says that `i' is stored at offset `0xd30' from the page whose
     physical base address is `0x02698000', and shows all the
     attributes of that page.

     Note that you must cast the addresses of variables to a `char *',
     since otherwise the value of `__djgpp_base_address', the base
     address of all variables and functions in a DJGPP program, will be
     added using the rules of C pointer arithmetics: if `i' is declared
     an `int', GDB will add 4 times the value of `__djgpp_base_address'
     to the address of `i'.

     Here's another example, it displays the Page Table entry for the
     transfer buffer:

     `(gdb) info dos address-pte *((unsigned *)&_go32_info_block + 3)'
     `Page Table entry for address 0x29110:'
     `Base=0x00029000 Dirty Acc. Not-Cached Write-Back Usr Read-Write +0x110'


     (The `+ 3' offset is because the transfer buffer's address is the
     3rd member of the `_go32_info_block' structure.)  The output
     clearly shows that this DPMI server maps the addresses in
     conventional memory 1:1, i.e. the physical (`0x00029000' +
     `0x110') and linear (`0x29110') addresses are identical.

     This command is supported only with some DPMI servers.

   In addition to native debugging, the DJGPP port supports remote
debugging via a serial data link.  The following commands are specific
to remote serial debugging in the DJGPP port of GDB.

`set com1base ADDR'
     This command sets the base I/O port address of the `COM1' serial
     port.

`set com1irq IRQ'
     This command sets the "Interrupt Request" (`IRQ') line to use for
     the `COM1' serial port.

     There are similar commands `set com2base', `set com3irq', etc. for
     setting the port address and the `IRQ' lines for the other 3 COM
     ports.

     The related commands `show com1base', `show com1irq' etc.  display
     the current settings of the base address and the `IRQ' lines used
     by the COM ports.

`info serial'
     This command prints the status of the 4 DOS serial ports.  For each
     port, it prints whether it's active or not, its I/O base address
     and IRQ number, whether it uses a 16550-style FIFO, its baudrate,
     and the counts of various errors encountered so far.


File: gdb.info,  Node: Cygwin Native,  Next: Hurd Native,  Prev: DJGPP Native,  Up: Native

21.1.5 Features for Debugging MS Windows PE Executables
-------------------------------------------------------

GDB supports native debugging of MS Windows programs, including DLLs
with and without symbolic debugging information.

   MS-Windows programs that call `SetConsoleMode' to switch off the
special meaning of the `Ctrl-C' keystroke cannot be interrupted by
typing `C-c'.  For this reason, GDB on MS-Windows supports `C-<BREAK>'
as an alternative interrupt key sequence, which can be used to
interrupt the debuggee even if it ignores `C-c'.

   There are various additional Cygwin-specific commands, described in
this section.  Working with DLLs that have no debugging symbols is
described in *note Non-debug DLL Symbols::.

`info w32'
     This is a prefix of MS Windows-specific commands which print
     information about the target system and important OS structures.

`info w32 selector'
     This command displays information returned by the Win32 API
     `GetThreadSelectorEntry' function.  It takes an optional argument
     that is evaluated to a long value to give the information about
     this given selector.  Without argument, this command displays
     information about the six segment registers.

`info w32 thread-information-block'
     This command displays thread specific information stored in the
     Thread Information Block (readable on the X86 CPU family using
     `$fs' selector for 32-bit programs and `$gs' for 64-bit programs).

`info dll'
     This is a Cygwin-specific alias of `info shared'.

`dll-symbols'
     This command loads symbols from a dll similarly to add-sym command
     but without the need to specify a base address.

`set cygwin-exceptions MODE'
     If MODE is `on', GDB will break on exceptions that happen inside
     the Cygwin DLL.  If MODE is `off', GDB will delay recognition of
     exceptions, and may ignore some exceptions which seem to be caused
     by internal Cygwin DLL "bookkeeping".  This option is meant
     primarily for debugging the Cygwin DLL itself; the default value
     is `off' to avoid annoying GDB users with false `SIGSEGV' signals.

`show cygwin-exceptions'
     Displays whether GDB will break on exceptions that happen inside
     the Cygwin DLL itself.

`set new-console MODE'
     If MODE is `on' the debuggee will be started in a new console on
     next start.  If MODE is `off', the debuggee will be started in the
     same console as the debugger.

`show new-console'
     Displays whether a new console is used when the debuggee is
     started.

`set new-group MODE'
     This boolean value controls whether the debuggee should start a
     new group or stay in the same group as the debugger.  This affects
     the way the Windows OS handles `Ctrl-C'.

`show new-group'
     Displays current value of new-group boolean.

`set debugevents'
     This boolean value adds debug output concerning kernel events
     related to the debuggee seen by the debugger.  This includes
     events that signal thread and process creation and exit, DLL
     loading and unloading, console interrupts, and debugging messages
     produced by the Windows `OutputDebugString' API call.

`set debugexec'
     This boolean value adds debug output concerning execute events
     (such as resume thread) seen by the debugger.

`set debugexceptions'
     This boolean value adds debug output concerning exceptions in the
     debuggee seen by the debugger.

`set debugmemory'
     This boolean value adds debug output concerning debuggee memory
     reads and writes by the debugger.

`set shell'
     This boolean values specifies whether the debuggee is called via a
     shell or directly (default value is on).

`show shell'
     Displays if the debuggee will be started with a shell.


* Menu:

* Non-debug DLL Symbols::  Support for DLLs without debugging symbols


File: gdb.info,  Node: Non-debug DLL Symbols,  Up: Cygwin Native

21.1.5.1 Support for DLLs without Debugging Symbols
...................................................

Very often on windows, some of the DLLs that your program relies on do
not include symbolic debugging information (for example,
`kernel32.dll').  When GDB doesn't recognize any debugging symbols in a
DLL, it relies on the minimal amount of symbolic information contained
in the DLL's export table.  This section describes working with such
symbols, known internally to GDB as "minimal symbols".

   Note that before the debugged program has started execution, no DLLs
will have been loaded.  The easiest way around this problem is simply to
start the program -- either by setting a breakpoint or letting the
program run once to completion.  It is also possible to force GDB to
load a particular DLL before starting the executable -- see the shared
library information in *note Files::, or the `dll-symbols' command in
*note Cygwin Native::.  Currently, explicitly loading symbols from a
DLL with no debugging information will cause the symbol names to be
duplicated in GDB's lookup table, which may adversely affect symbol
lookup performance.

21.1.5.2 DLL Name Prefixes
..........................

In keeping with the naming conventions used by the Microsoft debugging
tools, DLL export symbols are made available with a prefix based on the
DLL name, for instance `KERNEL32!CreateFileA'.  The plain name is also
entered into the symbol table, so `CreateFileA' is often sufficient.
In some cases there will be name clashes within a program (particularly
if the executable itself includes full debugging symbols) necessitating
the use of the fully qualified name when referring to the contents of
the DLL.  Use single-quotes around the name to avoid the exclamation
mark ("!")  being interpreted as a language operator.

   Note that the internal name of the DLL may be all upper-case, even
though the file name of the DLL is lower-case, or vice-versa.  Since
symbols within GDB are _case-sensitive_ this may cause some confusion.
If in doubt, try the `info functions' and `info variables' commands or
even `maint print msymbols' (*note Symbols::). Here's an example:

     (gdb) info function CreateFileA
     All functions matching regular expression "CreateFileA":

     Non-debugging symbols:
     0x77e885f4  CreateFileA
     0x77e885f4  KERNEL32!CreateFileA

     (gdb) info function !
     All functions matching regular expression "!":

     Non-debugging symbols:
     0x6100114c  cygwin1!__assert
     0x61004034  cygwin1!_dll_crt0@0
     0x61004240  cygwin1!dll_crt0(per_process *)
     [etc...]

21.1.5.3 Working with Minimal Symbols
.....................................

Symbols extracted from a DLL's export table do not contain very much
type information. All that GDB can do is guess whether a symbol refers
to a function or variable depending on the linker section that contains
the symbol. Also note that the actual contents of the memory contained
in a DLL are not available unless the program is running. This means
that you cannot examine the contents of a variable or disassemble a
function within a DLL without a running program.

   Variables are generally treated as pointers and dereferenced
automatically. For this reason, it is often necessary to prefix a
variable name with the address-of operator ("&") and provide explicit
type information in the command. Here's an example of the type of
problem:

     (gdb) print 'cygwin1!__argv'
     $1 = 268572168

     (gdb) x 'cygwin1!__argv'
     0x10021610:      "\230y\""

   And two possible solutions:

     (gdb) print ((char **)'cygwin1!__argv')[0]
     $2 = 0x22fd98 "/cygdrive/c/mydirectory/myprogram"

     (gdb) x/2x &'cygwin1!__argv'
     0x610c0aa8 <cygwin1!__argv>:    0x10021608      0x00000000
     (gdb) x/x 0x10021608
     0x10021608:     0x0022fd98
     (gdb) x/s 0x0022fd98
     0x22fd98:        "/cygdrive/c/mydirectory/myprogram"

   Setting a break point within a DLL is possible even before the
program starts execution. However, under these circumstances, GDB can't
examine the initial instructions of the function in order to skip the
function's frame set-up code. You can work around this by using "*&" to
set the breakpoint at a raw memory address:

     (gdb) break *&'python22!PyOS_Readline'
     Breakpoint 1 at 0x1e04eff0

   The author of these extensions is not entirely convinced that
setting a break point within a shared DLL like `kernel32.dll' is
completely safe.


File: gdb.info,  Node: Hurd Native,  Next: Neutrino,  Prev: Cygwin Native,  Up: Native

21.1.6 Commands Specific to GNU Hurd Systems
--------------------------------------------

This subsection describes GDB commands specific to the GNU Hurd native
debugging.

`set signals'
`set sigs'
     This command toggles the state of inferior signal interception by
     GDB.  Mach exceptions, such as breakpoint traps, are not affected
     by this command.  `sigs' is a shorthand alias for `signals'.

`show signals'
`show sigs'
     Show the current state of intercepting inferior's signals.

`set signal-thread'
`set sigthread'
     This command tells GDB which thread is the `libc' signal thread.
     That thread is run when a signal is delivered to a running
     process.  `set sigthread' is the shorthand alias of `set
     signal-thread'.

`show signal-thread'
`show sigthread'
     These two commands show which thread will run when the inferior is
     delivered a signal.

`set stopped'
     This commands tells GDB that the inferior process is stopped, as
     with the `SIGSTOP' signal.  The stopped process can be continued
     by delivering a signal to it.

`show stopped'
     This command shows whether GDB thinks the debuggee is stopped.

`set exceptions'
     Use this command to turn off trapping of exceptions in the
     inferior.  When exception trapping is off, neither breakpoints nor
     single-stepping will work.  To restore the default, set exception
     trapping on.

`show exceptions'
     Show the current state of trapping exceptions in the inferior.

`set task pause'
     This command toggles task suspension when GDB has control.
     Setting it to on takes effect immediately, and the task is
     suspended whenever GDB gets control.  Setting it to off will take
     effect the next time the inferior is continued.  If this option is
     set to off, you can use `set thread default pause on' or `set
     thread pause on' (see below) to pause individual threads.

`show task pause'
     Show the current state of task suspension.

`set task detach-suspend-count'
     This command sets the suspend count the task will be left with when
     GDB detaches from it.

`show task detach-suspend-count'
     Show the suspend count the task will be left with when detaching.

`set task exception-port'
`set task excp'
     This command sets the task exception port to which GDB will
     forward exceptions.  The argument should be the value of the "send
     rights" of the task.  `set task excp' is a shorthand alias.

`set noninvasive'
     This command switches GDB to a mode that is the least invasive as
     far as interfering with the inferior is concerned.  This is the
     same as using `set task pause', `set exceptions', and `set
     signals' to values opposite to the defaults.

`info send-rights'
`info receive-rights'
`info port-rights'
`info port-sets'
`info dead-names'
`info ports'
`info psets'
     These commands display information about, respectively, send
     rights, receive rights, port rights, port sets, and dead names of
     a task.  There are also shorthand aliases: `info ports' for `info
     port-rights' and `info psets' for `info port-sets'.

`set thread pause'
     This command toggles current thread suspension when GDB has
     control.  Setting it to on takes effect immediately, and the
     current thread is suspended whenever GDB gets control.  Setting it
     to off will take effect the next time the inferior is continued.
     Normally, this command has no effect, since when GDB has control,
     the whole task is suspended.  However, if you used `set task pause
     off' (see above), this command comes in handy to suspend only the
     current thread.

`show thread pause'
     This command shows the state of current thread suspension.

`set thread run'
     This command sets whether the current thread is allowed to run.

`show thread run'
     Show whether the current thread is allowed to run.

`set thread detach-suspend-count'
     This command sets the suspend count GDB will leave on a thread
     when detaching.  This number is relative to the suspend count
     found by GDB when it notices the thread; use `set thread
     takeover-suspend-count' to force it to an absolute value.

`show thread detach-suspend-count'
     Show the suspend count GDB will leave on the thread when detaching.

`set thread exception-port'
`set thread excp'
     Set the thread exception port to which to forward exceptions.  This
     overrides the port set by `set task exception-port' (see above).
     `set thread excp' is the shorthand alias.

`set thread takeover-suspend-count'
     Normally, GDB's thread suspend counts are relative to the value
     GDB finds when it notices each thread.  This command changes the
     suspend counts to be absolute instead.

`set thread default'
`show thread default'
     Each of the above `set thread' commands has a `set thread default'
     counterpart (e.g., `set thread default pause', `set thread default
     exception-port', etc.).  The `thread default' variety of commands
     sets the default thread properties for all threads; you can then
     change the properties of individual threads with the non-default
     commands.


File: gdb.info,  Node: Neutrino,  Next: Darwin,  Prev: Hurd Native,  Up: Native

21.1.7 QNX Neutrino
-------------------

GDB provides the following commands specific to the QNX Neutrino target:

`set debug nto-debug'
     When set to on, enables debugging messages specific to the QNX
     Neutrino support.

`show debug nto-debug'
     Show the current state of QNX Neutrino messages.


File: gdb.info,  Node: Darwin,  Prev: Neutrino,  Up: Native

21.1.8 Darwin
-------------

GDB provides the following commands specific to the Darwin target:

`set debug darwin NUM'
     When set to a non zero value, enables debugging messages specific
     to the Darwin support.  Higher values produce more verbose output.

`show debug darwin'
     Show the current state of Darwin messages.

`set debug mach-o NUM'
     When set to a non zero value, enables debugging messages while GDB
     is reading Darwin object files.  ("Mach-O" is the file format used
     on Darwin for object and executable files.)  Higher values produce
     more verbose output.  This is a command to diagnose problems
     internal to GDB and should not be needed in normal usage.

`show debug mach-o'
     Show the current state of Mach-O file messages.

`set mach-exceptions on'
`set mach-exceptions off'
     On Darwin, faults are first reported as a Mach exception and are
     then mapped to a Posix signal.  Use this command to turn on
     trapping of Mach exceptions in the inferior.  This might be
     sometimes useful to better understand the cause of a fault.  The
     default is off.

`show mach-exceptions'
     Show the current state of exceptions trapping.


File: gdb.info,  Node: Embedded OS,  Next: Embedded Processors,  Prev: Native,  Up: Configurations

21.2 Embedded Operating Systems
===============================

This section describes configurations involving the debugging of
embedded operating systems that are available for several different
architectures.

* Menu:

* VxWorks::                     Using GDB with VxWorks

   GDB includes the ability to debug programs running on various
real-time operating systems.


File: gdb.info,  Node: VxWorks,  Up: Embedded OS

21.2.1 Using GDB with VxWorks
-----------------------------

`target vxworks MACHINENAME'
     A VxWorks system, attached via TCP/IP.  The argument MACHINENAME
     is the target system's machine name or IP address.


   On VxWorks, `load' links FILENAME dynamically on the current target
system as well as adding its symbols in GDB.

   GDB enables developers to spawn and debug tasks running on networked
VxWorks targets from a Unix host.  Already-running tasks spawned from
the VxWorks shell can also be debugged.  GDB uses code that runs on
both the Unix host and on the VxWorks target.  The program `gdb' is
installed and executed on the Unix host.  (It may be installed with the
name `vxgdb', to distinguish it from a GDB for debugging programs on
the host itself.)

`VxWorks-timeout ARGS'
     All VxWorks-based targets now support the option `vxworks-timeout'.
     This option is set by the user, and  ARGS represents the number of
     seconds GDB waits for responses to rpc's.  You might use this if
     your VxWorks target is a slow software simulator or is on the far
     side of a thin network line.

   The following information on connecting to VxWorks was current when
this manual was produced; newer releases of VxWorks may use revised
procedures.

   To use GDB with VxWorks, you must rebuild your VxWorks kernel to
include the remote debugging interface routines in the VxWorks library
`rdb.a'.  To do this, define `INCLUDE_RDB' in the VxWorks configuration
file `configAll.h' and rebuild your VxWorks kernel.  The resulting
kernel contains `rdb.a', and spawns the source debugging task
`tRdbTask' when VxWorks is booted.  For more information on configuring
and remaking VxWorks, see the manufacturer's manual.

   Once you have included `rdb.a' in your VxWorks system image and set
your Unix execution search path to find GDB, you are ready to run GDB.
From your Unix host, run `gdb' (or `vxgdb', depending on your
installation).

   GDB comes up showing the prompt:

     (vxgdb)

* Menu:

* VxWorks Connection::          Connecting to VxWorks
* VxWorks Download::            VxWorks download
* VxWorks Attach::              Running tasks


File: gdb.info,  Node: VxWorks Connection,  Next: VxWorks Download,  Up: VxWorks

21.2.1.1 Connecting to VxWorks
..............................

The GDB command `target' lets you connect to a VxWorks target on the
network.  To connect to a target whose host name is "`tt'", type:

     (vxgdb) target vxworks tt

   GDB displays messages like these:

     Attaching remote machine across net...
     Connected to tt.

   GDB then attempts to read the symbol tables of any object modules
loaded into the VxWorks target since it was last booted.  GDB locates
these files by searching the directories listed in the command search
path (*note Your Program's Environment: Environment.); if it fails to
find an object file, it displays a message such as:

     prog.o: No such file or directory.

   When this happens, add the appropriate directory to the search path
with the GDB command `path', and execute the `target' command again.


File: gdb.info,  Node: VxWorks Download,  Next: VxWorks Attach,  Prev: VxWorks Connection,  Up: VxWorks

21.2.1.2 VxWorks Download
.........................

If you have connected to the VxWorks target and you want to debug an
object that has not yet been loaded, you can use the GDB `load' command
to download a file from Unix to VxWorks incrementally.  The object file
given as an argument to the `load' command is actually opened twice:
first by the VxWorks target in order to download the code, then by GDB
in order to read the symbol table.  This can lead to problems if the
current working directories on the two systems differ.  If both systems
have NFS mounted the same filesystems, you can avoid these problems by
using absolute paths.  Otherwise, it is simplest to set the working
directory on both systems to the directory in which the object file
resides, and then to reference the file by its name, without any path.
For instance, a program `prog.o' may reside in `VXPATH/vw/demo/rdb' in
VxWorks and in `HOSTPATH/vw/demo/rdb' on the host.  To load this
program, type this on VxWorks:

     -> cd "VXPATH/vw/demo/rdb"

Then, in GDB, type:

     (vxgdb) cd HOSTPATH/vw/demo/rdb
     (vxgdb) load prog.o

   GDB displays a response similar to this:

     Reading symbol data from wherever/vw/demo/rdb/prog.o... done.

   You can also use the `load' command to reload an object module after
editing and recompiling the corresponding source file.  Note that this
makes GDB delete all currently-defined breakpoints, auto-displays, and
convenience variables, and to clear the value history.  (This is
necessary in order to preserve the integrity of debugger's data
structures that reference the target system's symbol table.)


File: gdb.info,  Node: VxWorks Attach,  Prev: VxWorks Download,  Up: VxWorks

21.2.1.3 Running Tasks
......................

You can also attach to an existing task using the `attach' command as
follows:

     (vxgdb) attach TASK

where TASK is the VxWorks hexadecimal task ID.  The task can be running
or suspended when you attach to it.  Running tasks are suspended at the
time of attachment.


File: gdb.info,  Node: Embedded Processors,  Next: Architectures,  Prev: Embedded OS,  Up: Configurations

21.3 Embedded Processors
========================

This section goes into details specific to particular embedded
configurations.

   Whenever a specific embedded processor has a simulator, GDB allows
to send an arbitrary command to the simulator.

`sim COMMAND'
     Send an arbitrary COMMAND string to the simulator.  Consult the
     documentation for the specific simulator in use for information
     about acceptable commands.

* Menu:

* ARM::                         ARM RDI
* M32R/D::                      Renesas M32R/D
* M68K::                        Motorola M68K
* MicroBlaze::			Xilinx MicroBlaze
* MIPS Embedded::               MIPS Embedded
* OpenRISC 1000::               OpenRisc 1000
* PA::                          HP PA Embedded
* PowerPC Embedded::            PowerPC Embedded
* Sparclet::                    Tsqware Sparclet
* Sparclite::                   Fujitsu Sparclite
* Z8000::                       Zilog Z8000
* AVR::                         Atmel AVR
* CRIS::                        CRIS
* Super-H::                     Renesas Super-H


File: gdb.info,  Node: ARM,  Next: M32R/D,  Up: Embedded Processors

21.3.1 ARM
----------

`target rdi DEV'
     ARM Angel monitor, via RDI library interface to ADP protocol.  You
     may use this target to communicate with both boards running the
     Angel monitor, or with the EmbeddedICE JTAG debug device.

`target rdp DEV'
     ARM Demon monitor.


   GDB provides the following ARM-specific commands:

`set arm disassembler'
     This commands selects from a list of disassembly styles.  The
     `"std"' style is the standard style.

`show arm disassembler'
     Show the current disassembly style.

`set arm apcs32'
     This command toggles ARM operation mode between 32-bit and 26-bit.

`show arm apcs32'
     Display the current usage of the ARM 32-bit mode.

`set arm fpu FPUTYPE'
     This command sets the ARM floating-point unit (FPU) type.  The
     argument FPUTYPE can be one of these:

    `auto'
          Determine the FPU type by querying the OS ABI.

    `softfpa'
          Software FPU, with mixed-endian doubles on little-endian ARM
          processors.

    `fpa'
          GCC-compiled FPA co-processor.

    `softvfp'
          Software FPU with pure-endian doubles.

    `vfp'
          VFP co-processor.

`show arm fpu'
     Show the current type of the FPU.

`set arm abi'
     This command forces GDB to use the specified ABI.

`show arm abi'
     Show the currently used ABI.

`set arm fallback-mode (arm|thumb|auto)'
     GDB uses the symbol table, when available, to determine whether
     instructions are ARM or Thumb.  This command controls GDB's
     default behavior when the symbol table is not available.  The
     default is `auto', which causes GDB to use the current execution
     mode (from the `T' bit in the `CPSR' register).

`show arm fallback-mode'
     Show the current fallback instruction mode.

`set arm force-mode (arm|thumb|auto)'
     This command overrides use of the symbol table to determine whether
     instructions are ARM or Thumb.  The default is `auto', which
     causes GDB to use the symbol table and then the setting of `set
     arm fallback-mode'.

`show arm force-mode'
     Show the current forced instruction mode.

`set debug arm'
     Toggle whether to display ARM-specific debugging messages from the
     ARM target support subsystem.

`show debug arm'
     Show whether ARM-specific debugging messages are enabled.

   The following commands are available when an ARM target is debugged
using the RDI interface:

`rdilogfile [FILE]'
     Set the filename for the ADP (Angel Debugger Protocol) packet log.
     With an argument, sets the log file to the specified FILE.  With
     no argument, show the current log file name.  The default log file
     is `rdi.log'.

`rdilogenable [ARG]'
     Control logging of ADP packets.  With an argument of 1 or `"yes"'
     enables logging, with an argument 0 or `"no"' disables it.  With
     no arguments displays the current setting.  When logging is
     enabled, ADP packets exchanged between GDB and the RDI target
     device are logged to a file.

`set rdiromatzero'
     Tell GDB whether the target has ROM at address 0.  If on, vector
     catching is disabled, so that zero address can be used.  If off
     (the default), vector catching is enabled.  For this command to
     take effect, it needs to be invoked prior to the `target rdi'
     command.

`show rdiromatzero'
     Show the current setting of ROM at zero address.

`set rdiheartbeat'
     Enable or disable RDI heartbeat packets.  It is not recommended to
     turn on this option, since it confuses ARM and EPI JTAG interface,
     as well as the Angel monitor.

`show rdiheartbeat'
     Show the setting of RDI heartbeat packets.

`target sim [SIMARGS] ...'
     The GDB ARM simulator accepts the following optional arguments.

    `--swi-support=TYPE'
          Tell the simulator which SWI interfaces to support.  TYPE may
          be a comma separated list of the following values.  The
          default value is `all'.

         `none'

         `demon'

         `angel'

         `redboot'

         `all'


File: gdb.info,  Node: M32R/D,  Next: M68K,  Prev: ARM,  Up: Embedded Processors

21.3.2 Renesas M32R/D and M32R/SDI
----------------------------------

`target m32r DEV'
     Renesas M32R/D ROM monitor.

`target m32rsdi DEV'
     Renesas M32R SDI server, connected via parallel port to the board.

   The following GDB commands are specific to the M32R monitor:

`set download-path PATH'
     Set the default path for finding downloadable SREC files.

`show download-path'
     Show the default path for downloadable SREC files.

`set board-address ADDR'
     Set the IP address for the M32R-EVA target board.

`show board-address'
     Show the current IP address of the target board.

`set server-address ADDR'
     Set the IP address for the download server, which is the GDB's
     host machine.

`show server-address'
     Display the IP address of the download server.

`upload [FILE]'
     Upload the specified SREC FILE via the monitor's Ethernet upload
     capability.  If no FILE argument is given, the current executable
     file is uploaded.

`tload [FILE]'
     Test the `upload' command.

   The following commands are available for M32R/SDI:

`sdireset'
     This command resets the SDI connection.

`sdistatus'
     This command shows the SDI connection status.

`debug_chaos'
     Instructs the remote that M32R/Chaos debugging is to be used.

`use_debug_dma'
     Instructs the remote to use the DEBUG_DMA method of accessing
     memory.

`use_mon_code'
     Instructs the remote to use the MON_CODE method of accessing
     memory.

`use_ib_break'
     Instructs the remote to set breakpoints by IB break.

`use_dbt_break'
     Instructs the remote to set breakpoints by DBT.


File: gdb.info,  Node: M68K,  Next: MicroBlaze,  Prev: M32R/D,  Up: Embedded Processors

21.3.3 M68k
-----------

The Motorola m68k configuration includes ColdFire support, and a target
command for the following ROM monitor.

`target dbug DEV'
     dBUG ROM monitor for Motorola ColdFire.



File: gdb.info,  Node: MicroBlaze,  Next: MIPS Embedded,  Prev: M68K,  Up: Embedded Processors

21.3.4 MicroBlaze
-----------------

The MicroBlaze is a soft-core processor supported on various Xilinx
FPGAs, such as Spartan or Virtex series.  Boards with these processors
usually have JTAG ports which connect to a host system running the
Xilinx Embedded Development Kit (EDK) or Software Development Kit (SDK).
This host system is used to download the configuration bitstream to the
target FPGA.  The Xilinx Microprocessor Debugger (XMD) program
communicates with the target board using the JTAG interface and
presents a `gdbserver' interface to the board.  By default `xmd' uses
port `1234'.  (While it is possible to change this default port, it
requires the use of undocumented `xmd' commands.  Contact Xilinx
support if you need to do this.)

   Use these GDB commands to connect to the MicroBlaze target processor.

`target remote :1234'
     Use this command to connect to the target if you are running GDB
     on the same system as `xmd'.

`target remote XMD-HOST:1234'
     Use this command to connect to the target if it is connected to
     `xmd' running on a different system named XMD-HOST.

`load'
     Use this command to download a program to the MicroBlaze target.

`set debug microblaze N'
     Enable MicroBlaze-specific debugging messages if non-zero.

`show debug microblaze N'
     Show MicroBlaze-specific debugging level.


File: gdb.info,  Node: MIPS Embedded,  Next: OpenRISC 1000,  Prev: MicroBlaze,  Up: Embedded Processors

21.3.5 MIPS Embedded
--------------------

GDB can use the MIPS remote debugging protocol to talk to a MIPS board
attached to a serial line.  This is available when you configure GDB
with `--target=mips-idt-ecoff'.

   Use these GDB commands to specify the connection to your target
board:

`target mips PORT'
     To run a program on the board, start up `gdb' with the name of
     your program as the argument.  To connect to the board, use the
     command `target mips PORT', where PORT is the name of the serial
     port connected to the board.  If the program has not already been
     downloaded to the board, you may use the `load' command to
     download it.  You can then use all the usual GDB commands.

     For example, this sequence connects to the target board through a
     serial port, and loads and runs a program called PROG through the
     debugger:

          host$ gdb PROG
          GDB is free software and ...
          (gdb) target mips /dev/ttyb
          (gdb) load PROG
          (gdb) run

`target mips HOSTNAME:PORTNUMBER'
     On some GDB host configurations, you can specify a TCP connection
     (for instance, to a serial line managed by a terminal
     concentrator) instead of a serial port, using the syntax
     `HOSTNAME:PORTNUMBER'.

`target pmon PORT'
     PMON ROM monitor.

`target ddb PORT'
     NEC's DDB variant of PMON for Vr4300.

`target lsi PORT'
     LSI variant of PMON.

`target r3900 DEV'
     Densan DVE-R3900 ROM monitor for Toshiba R3900 Mips.

`target array DEV'
     Array Tech LSI33K RAID controller board.


GDB also supports these special commands for MIPS targets:

`set mipsfpu double'
`set mipsfpu single'
`set mipsfpu none'
`set mipsfpu auto'
`show mipsfpu'
     If your target board does not support the MIPS floating point
     coprocessor, you should use the command `set mipsfpu none' (if you
     need this, you may wish to put the command in your GDB init file).
     This tells GDB how to find the return value of functions which
     return floating point values.  It also allows GDB to avoid saving
     the floating point registers when calling functions on the board.
     If you are using a floating point coprocessor with only single
     precision floating point support, as on the R4650 processor, use
     the command `set mipsfpu single'.  The default double precision
     floating point coprocessor may be selected using `set mipsfpu
     double'.

     In previous versions the only choices were double precision or no
     floating point, so `set mipsfpu on' will select double precision
     and `set mipsfpu off' will select no floating point.

     As usual, you can inquire about the `mipsfpu' variable with `show
     mipsfpu'.

`set timeout SECONDS'
`set retransmit-timeout SECONDS'
`show timeout'
`show retransmit-timeout'
     You can control the timeout used while waiting for a packet, in
     the MIPS remote protocol, with the `set timeout SECONDS' command.
     The default is 5 seconds.  Similarly, you can control the timeout
     used while waiting for an acknowledgment of a packet with the `set
     retransmit-timeout SECONDS' command.  The default is 3 seconds.
     You can inspect both values with `show timeout' and `show
     retransmit-timeout'.  (These commands are _only_ available when
     GDB is configured for `--target=mips-idt-ecoff'.)

     The timeout set by `set timeout' does not apply when GDB is
     waiting for your program to stop.  In that case, GDB waits forever
     because it has no way of knowing how long the program is going to
     run before stopping.

`set syn-garbage-limit NUM'
     Limit the maximum number of characters GDB should ignore when it
     tries to synchronize with the remote target.  The default is 10
     characters.  Setting the limit to -1 means there's no limit.

`show syn-garbage-limit'
     Show the current limit on the number of characters to ignore when
     trying to synchronize with the remote system.

`set monitor-prompt PROMPT'
     Tell GDB to expect the specified PROMPT string from the remote
     monitor.  The default depends on the target:
    pmon target
          `PMON'

    ddb target
          `NEC010'

    lsi target
          `PMON>'

`show monitor-prompt'
     Show the current strings GDB expects as the prompt from the remote
     monitor.

`set monitor-warnings'
     Enable or disable monitor warnings about hardware breakpoints.
     This has effect only for the `lsi' target.  When on, GDB will
     display warning messages whose codes are returned by the `lsi'
     PMON monitor for breakpoint commands.

`show monitor-warnings'
     Show the current setting of printing monitor warnings.

`pmon COMMAND'
     This command allows sending an arbitrary COMMAND string to the
     monitor.  The monitor must be in debug mode for this to work.


File: gdb.info,  Node: OpenRISC 1000,  Next: PA,  Prev: MIPS Embedded,  Up: Embedded Processors

21.3.6 OpenRISC 1000
--------------------

See OR1k Architecture document (`www.opencores.org') for more
information about platform and commands.

`target jtag jtag://HOST:PORT'
     Connects to remote JTAG server.  JTAG remote server can be either
     an or1ksim or JTAG server, connected via parallel port to the
     board.

     Example: `target jtag jtag://localhost:9999'

`or1ksim COMMAND'
     If connected to `or1ksim' OpenRISC 1000 Architectural Simulator,
     proprietary commands can be executed.

`info or1k spr'
     Displays spr groups.

`info or1k spr GROUP'
`info or1k spr GROUPNO'
     Displays register names in selected group.

`info or1k spr GROUP REGISTER'
`info or1k spr REGISTER'
`info or1k spr GROUPNO REGISTERNO'
`info or1k spr REGISTERNO'
     Shows information about specified spr register.

`spr GROUP REGISTER VALUE'
`spr REGISTER VALUE'
`spr GROUPNO REGISTERNO VALUE'
`spr REGISTERNO VALUE'
     Writes VALUE to specified spr register.

   Some implementations of OpenRISC 1000 Architecture also have
hardware trace.  It is very similar to GDB trace, except it does not
interfere with normal program execution and is thus much faster.
Hardware breakpoints/watchpoint triggers can be set using:
`$LEA/$LDATA'
     Load effective address/data

`$SEA/$SDATA'
     Store effective address/data

`$AEA/$ADATA'
     Access effective address ($SEA or $LEA) or data ($SDATA/$LDATA)

`$FETCH'
     Fetch data

   When triggered, it can capture low level data, like: `PC', `LSEA',
`LDATA', `SDATA', `READSPR', `WRITESPR', `INSTR'.

   `htrace' commands: 
`hwatch CONDITIONAL'
     Set hardware watchpoint on combination of Load/Store Effective
     Address(es) or Data.  For example:

     `hwatch ($LEA == my_var) && ($LDATA < 50) || ($SEA == my_var) &&
     ($SDATA >= 50)'

     `hwatch ($LEA == my_var) && ($LDATA < 50) || ($SEA == my_var) &&
     ($SDATA >= 50)'

`htrace info'
     Display information about current HW trace configuration.

`htrace trigger CONDITIONAL'
     Set starting criteria for HW trace.

`htrace qualifier CONDITIONAL'
     Set acquisition qualifier for HW trace.

`htrace stop CONDITIONAL'
     Set HW trace stopping criteria.

`htrace record [DATA]*'
     Selects the data to be recorded, when qualifier is met and HW
     trace was triggered.

`htrace enable'
`htrace disable'
     Enables/disables the HW trace.

`htrace rewind [FILENAME]'
     Clears currently recorded trace data.

     If filename is specified, new trace file is made and any newly
     collected data will be written there.

`htrace print [START [LEN]]'
     Prints trace buffer, using current record configuration.

`htrace mode continuous'
     Set continuous trace mode.

`htrace mode suspend'
     Set suspend trace mode.



File: gdb.info,  Node: PowerPC Embedded,  Next: Sparclet,  Prev: PA,  Up: Embedded Processors

21.3.7 PowerPC Embedded
-----------------------

GDB supports using the DVC (Data Value Compare) register to implement
in hardware simple hardware watchpoint conditions of the form:

     (gdb) watch ADDRESS|VARIABLE \
       if  ADDRESS|VARIABLE == CONSTANT EXPRESSION

   The DVC register will be automatically used when GDB detects such
pattern in a condition expression, and the created watchpoint uses one
debug register (either the `exact-watchpoints' option is on and the
variable is scalar, or the variable has a length of one byte).  This
feature is available in native GDB running on a Linux kernel version
2.6.34 or newer.

   When running on PowerPC embedded processors, GDB automatically uses
ranged hardware watchpoints, unless the `exact-watchpoints' option is
on, in which case watchpoints using only one debug register are created
when watching variables of scalar types.

   You can create an artificial array to watch an arbitrary memory
region using one of the following commands (*note Expressions::):

     (gdb) watch *((char *) ADDRESS)@LENGTH
     (gdb) watch {char[LENGTH]} ADDRESS

   PowerPC embedded processors support hardware accelerated "ranged
breakpoints".  A ranged breakpoint stops execution of the inferior
whenever it executes an instruction at any address within the range it
specifies.  To set a ranged breakpoint in GDB, use the `break-range'
command.

   GDB provides the following PowerPC-specific commands:

`break-range START-LOCATION, END-LOCATION'
     Set a breakpoint for an address range.  START-LOCATION and
     END-LOCATION can specify a function name, a line number, an offset
     of lines from the current line or from the start location, or an
     address of an instruction (see *note Specify Location::, for a
     list of all the possible ways to specify a LOCATION.)  The
     breakpoint will stop execution of the inferior whenever it
     executes an instruction at any address within the specified range,
     (including START-LOCATION and END-LOCATION.)

`set powerpc soft-float'
`show powerpc soft-float'
     Force GDB to use (or not use) a software floating point calling
     convention.  By default, GDB selects the calling convention based
     on the selected architecture and the provided executable file.

`set powerpc vector-abi'
`show powerpc vector-abi'
     Force GDB to use the specified calling convention for vector
     arguments and return values.  The valid options are `auto';
     `generic', to avoid vector registers even if they are present;
     `altivec', to use AltiVec registers; and `spe' to use SPE
     registers.  By default, GDB selects the calling convention based
     on the selected architecture and the provided executable file.

`set powerpc exact-watchpoints'
`show powerpc exact-watchpoints'
     Allow GDB to use only one debug register when watching a variable
     of scalar type, thus assuming that the variable is accessed
     through the address of its first byte.

`target dink32 DEV'
     DINK32 ROM monitor.

`target ppcbug DEV'

`target ppcbug1 DEV'
     PPCBUG ROM monitor for PowerPC.

`target sds DEV'
     SDS monitor, running on a PowerPC board (such as Motorola's ADS).

   The following commands specific to the SDS protocol are supported by
GDB:

`set sdstimeout NSEC'
     Set the timeout for SDS protocol reads to be NSEC seconds.  The
     default is 2 seconds.

`show sdstimeout'
     Show the current value of the SDS timeout.

`sds COMMAND'
     Send the specified COMMAND string to the SDS monitor.


File: gdb.info,  Node: PA,  Next: PowerPC Embedded,  Prev: OpenRISC 1000,  Up: Embedded Processors

21.3.8 HP PA Embedded
---------------------

`target op50n DEV'
     OP50N monitor, running on an OKI HPPA board.

`target w89k DEV'
     W89K monitor, running on a Winbond HPPA board.



File: gdb.info,  Node: Sparclet,  Next: Sparclite,  Prev: PowerPC Embedded,  Up: Embedded Processors

21.3.9 Tsqware Sparclet
-----------------------

GDB enables developers to debug tasks running on Sparclet targets from
a Unix host.  GDB uses code that runs on both the Unix host and on the
Sparclet target.  The program `gdb' is installed and executed on the
Unix host.

`remotetimeout ARGS'
     GDB supports the option `remotetimeout'.  This option is set by
     the user, and  ARGS represents the number of seconds GDB waits for
     responses.

   When compiling for debugging, include the options `-g' to get debug
information and `-Ttext' to relocate the program to where you wish to
load it on the target.  You may also want to add the options `-n' or
`-N' in order to reduce the size of the sections.  Example:

     sparclet-aout-gcc prog.c -Ttext 0x12010000 -g -o prog -N

   You can use `objdump' to verify that the addresses are what you
intended:

     sparclet-aout-objdump --headers --syms prog

   Once you have set your Unix execution search path to find GDB, you
are ready to run GDB.  From your Unix host, run `gdb' (or
`sparclet-aout-gdb', depending on your installation).

   GDB comes up showing the prompt:

     (gdbslet)

* Menu:

* Sparclet File::                Setting the file to debug
* Sparclet Connection::          Connecting to Sparclet
* Sparclet Download::            Sparclet download
* Sparclet Execution::           Running and debugging


File: gdb.info,  Node: Sparclet File,  Next: Sparclet Connection,  Up: Sparclet

21.3.9.1 Setting File to Debug
..............................

The GDB command `file' lets you choose with program to debug.

     (gdbslet) file prog

   GDB then attempts to read the symbol table of `prog'.  GDB locates
the file by searching the directories listed in the command search path.
If the file was compiled with debug information (option `-g'), source
files will be searched as well.  GDB locates the source files by
searching the directories listed in the directory search path (*note
Your Program's Environment: Environment.).  If it fails to find a file,
it displays a message such as:

     prog: No such file or directory.

   When this happens, add the appropriate directories to the search
paths with the GDB commands `path' and `dir', and execute the `target'
command again.


File: gdb.info,  Node: Sparclet Connection,  Next: Sparclet Download,  Prev: Sparclet File,  Up: Sparclet

21.3.9.2 Connecting to Sparclet
...............................

The GDB command `target' lets you connect to a Sparclet target.  To
connect to a target on serial port "`ttya'", type:

     (gdbslet) target sparclet /dev/ttya
     Remote target sparclet connected to /dev/ttya
     main () at ../prog.c:3

   GDB displays messages like these:

     Connected to ttya.


File: gdb.info,  Node: Sparclet Download,  Next: Sparclet Execution,  Prev: Sparclet Connection,  Up: Sparclet

21.3.9.3 Sparclet Download
..........................

Once connected to the Sparclet target, you can use the GDB `load'
command to download the file from the host to the target.  The file
name and load offset should be given as arguments to the `load' command.
Since the file format is aout, the program must be loaded to the
starting address.  You can use `objdump' to find out what this value
is.  The load offset is an offset which is added to the VMA (virtual
memory address) of each of the file's sections.  For instance, if the
program `prog' was linked to text address 0x1201000, with data at
0x12010160 and bss at 0x12010170, in GDB, type:

     (gdbslet) load prog 0x12010000
     Loading section .text, size 0xdb0 vma 0x12010000

   If the code is loaded at a different address then what the program
was linked to, you may need to use the `section' and `add-symbol-file'
commands to tell GDB where to map the symbol table.


File: gdb.info,  Node: Sparclet Execution,  Prev: Sparclet Download,  Up: Sparclet

21.3.9.4 Running and Debugging
..............................

You can now begin debugging the task using GDB's execution control
commands, `b', `step', `run', etc.  See the GDB manual for the list of
commands.

     (gdbslet) b main
     Breakpoint 1 at 0x12010000: file prog.c, line 3.
     (gdbslet) run
     Starting program: prog
     Breakpoint 1, main (argc=1, argv=0xeffff21c) at prog.c:3
     3        char *symarg = 0;
     (gdbslet) step
     4        char *execarg = "hello!";
     (gdbslet)


File: gdb.info,  Node: Sparclite,  Next: Z8000,  Prev: Sparclet,  Up: Embedded Processors

21.3.10 Fujitsu Sparclite
-------------------------

`target sparclite DEV'
     Fujitsu sparclite boards, used only for the purpose of loading.
     You must use an additional command to debug the program.  For
     example: target remote DEV using GDB standard remote protocol.



File: gdb.info,  Node: Z8000,  Next: AVR,  Prev: Sparclite,  Up: Embedded Processors

21.3.11 Zilog Z8000
-------------------

When configured for debugging Zilog Z8000 targets, GDB includes a Z8000
simulator.

   For the Z8000 family, `target sim' simulates either the Z8002 (the
unsegmented variant of the Z8000 architecture) or the Z8001 (the
segmented variant).  The simulator recognizes which architecture is
appropriate by inspecting the object code.

`target sim ARGS'
     Debug programs on a simulated CPU.  If the simulator supports setup
     options, specify them via ARGS.

After specifying this target, you can debug programs for the simulated
CPU in the same style as programs for your host computer; use the
`file' command to load a new program image, the `run' command to run
your program, and so on.

   As well as making available all the usual machine registers (*note
Registers: Registers.), the Z8000 simulator provides three additional
items of information as specially named registers:

`cycles'
     Counts clock-ticks in the simulator.

`insts'
     Counts instructions run in the simulator.

`time'
     Execution time in 60ths of a second.


   You can refer to these values in GDB expressions with the usual
conventions; for example, `b fputc if $cycles>5000' sets a conditional
breakpoint that suspends only after at least 5000 simulated clock ticks.


File: gdb.info,  Node: AVR,  Next: CRIS,  Prev: Z8000,  Up: Embedded Processors

21.3.12 Atmel AVR
-----------------

When configured for debugging the Atmel AVR, GDB supports the following
AVR-specific commands:

`info io_registers'
     This command displays information about the AVR I/O registers.  For
     each register, GDB prints its number and value.


File: gdb.info,  Node: CRIS,  Next: Super-H,  Prev: AVR,  Up: Embedded Processors

21.3.13 CRIS
------------

When configured for debugging CRIS, GDB provides the following
CRIS-specific commands:

`set cris-version VER'
     Set the current CRIS version to VER, either `10' or `32'.  The
     CRIS version affects register names and sizes.  This command is
     useful in case autodetection of the CRIS version fails.

`show cris-version'
     Show the current CRIS version.

`set cris-dwarf2-cfi'
     Set the usage of DWARF-2 CFI for CRIS debugging.  The default is
     `on'.  Change to `off' when using `gcc-cris' whose version is below
     `R59'.

`show cris-dwarf2-cfi'
     Show the current state of using DWARF-2 CFI.

`set cris-mode MODE'
     Set the current CRIS mode to MODE.  It should only be changed when
     debugging in guru mode, in which case it should be set to `guru'
     (the default is `normal').

`show cris-mode'
     Show the current CRIS mode.


File: gdb.info,  Node: Super-H,  Prev: CRIS,  Up: Embedded Processors

21.3.14 Renesas Super-H
-----------------------

For the Renesas Super-H processor, GDB provides these commands:

`regs'
     Show the values of all Super-H registers.

`set sh calling-convention CONVENTION'
     Set the calling-convention used when calling functions from GDB.
     Allowed values are `gcc', which is the default setting, and
     `renesas'.  With the `gcc' setting, functions are called using the
     GCC calling convention.  If the DWARF-2 information of the called
     function specifies that the function follows the Renesas calling
     convention, the function is called using the Renesas calling
     convention.  If the calling convention is set to `renesas', the
     Renesas calling convention is always used, regardless of the
     DWARF-2 information.  This can be used to override the default of
     `gcc' if debug information is missing, or the compiler does not
     emit the DWARF-2 calling convention entry for a function.

`show sh calling-convention'
     Show the current calling convention setting.



File: gdb.info,  Node: Architectures,  Prev: Embedded Processors,  Up: Configurations

21.4 Architectures
==================

This section describes characteristics of architectures that affect all
uses of GDB with the architecture, both native and cross.

* Menu:

* i386::
* A29K::
* Alpha::
* MIPS::
* HPPA::               HP PA architecture
* SPU::                Cell Broadband Engine SPU architecture
* PowerPC::


File: gdb.info,  Node: i386,  Next: A29K,  Up: Architectures

21.4.1 x86 Architecture-specific Issues
---------------------------------------

`set struct-convention MODE'
     Set the convention used by the inferior to return `struct's and
     `union's from functions to MODE.  Possible values of MODE are
     `"pcc"', `"reg"', and `"default"' (the default).  `"default"' or
     `"pcc"' means that `struct's are returned on the stack, while
     `"reg"' means that a `struct' or a `union' whose size is 1, 2, 4,
     or 8 bytes will be returned in a register.

`show struct-convention'
     Show the current setting of the convention to return `struct's
     from functions.


File: gdb.info,  Node: A29K,  Next: Alpha,  Prev: i386,  Up: Architectures

21.4.2 A29K
-----------

`set rstack_high_address ADDRESS'
     On AMD 29000 family processors, registers are saved in a separate
     "register stack".  There is no way for GDB to determine the extent
     of this stack.  Normally, GDB just assumes that the stack is
     "large enough".  This may result in GDB referencing memory
     locations that do not exist.  If necessary, you can get around
     this problem by specifying the ending address of the register
     stack with the `set rstack_high_address' command.  The argument
     should be an address, which you probably want to precede with `0x'
     to specify in hexadecimal.

`show rstack_high_address'
     Display the current limit of the register stack, on AMD 29000
     family processors.



File: gdb.info,  Node: Alpha,  Next: MIPS,  Prev: A29K,  Up: Architectures

21.4.3 Alpha
------------

See the following section.


File: gdb.info,  Node: MIPS,  Next: HPPA,  Prev: Alpha,  Up: Architectures

21.4.4 MIPS
-----------

Alpha- and MIPS-based computers use an unusual stack frame, which
sometimes requires GDB to search backward in the object code to find
the beginning of a function.

   To improve response time (especially for embedded applications, where
GDB may be restricted to a slow serial line for this search) you may
want to limit the size of this search, using one of these commands:

`set heuristic-fence-post LIMIT'
     Restrict GDB to examining at most LIMIT bytes in its search for
     the beginning of a function.  A value of 0 (the default) means
     there is no limit.  However, except for 0, the larger the limit
     the more bytes `heuristic-fence-post' must search and therefore
     the longer it takes to run.  You should only need to use this
     command when debugging a stripped executable.

`show heuristic-fence-post'
     Display the current limit.

These commands are available _only_ when GDB is configured for
debugging programs on Alpha or MIPS processors.

   Several MIPS-specific commands are available when debugging MIPS
programs:

`set mips abi ARG'
     Tell GDB which MIPS ABI is used by the inferior.  Possible values
     of ARG are:

    `auto'
          The default ABI associated with the current binary (this is
          the default).

    `o32'

    `o64'

    `n32'

    `n64'

    `eabi32'

    `eabi64'

    `auto'

`show mips abi'
     Show the MIPS ABI used by GDB to debug the inferior.

`set mipsfpu'
`show mipsfpu'
     *Note set mipsfpu: MIPS Embedded.

`set mips mask-address ARG'
     This command determines whether the most-significant 32 bits of
     64-bit MIPS addresses are masked off.  The argument ARG can be
     `on', `off', or `auto'.  The latter is the default setting, which
     lets GDB determine the correct value.

`show mips mask-address'
     Show whether the upper 32 bits of MIPS addresses are masked off or
     not.

`set remote-mips64-transfers-32bit-regs'
     This command controls compatibility with 64-bit MIPS targets that
     transfer data in 32-bit quantities.  If you have an old MIPS 64
     target that transfers 32 bits for some registers, like SR and FSR,
     and 64 bits for other registers, set this option to `on'.

`show remote-mips64-transfers-32bit-regs'
     Show the current setting of compatibility with older MIPS 64
     targets.

`set debug mips'
     This command turns on and off debugging messages for the
     MIPS-specific target code in GDB.

`show debug mips'
     Show the current setting of MIPS debugging messages.


File: gdb.info,  Node: HPPA,  Next: SPU,  Prev: MIPS,  Up: Architectures

21.4.5 HPPA
-----------

When GDB is debugging the HP PA architecture, it provides the following
special commands:

`set debug hppa'
     This command determines whether HPPA architecture-specific
     debugging messages are to be displayed.

`show debug hppa'
     Show whether HPPA debugging messages are displayed.

`maint print unwind ADDRESS'
     This command displays the contents of the unwind table entry at the
     given ADDRESS.



File: gdb.info,  Node: SPU,  Next: PowerPC,  Prev: HPPA,  Up: Architectures

21.4.6 Cell Broadband Engine SPU architecture
---------------------------------------------

When GDB is debugging the Cell Broadband Engine SPU architecture, it
provides the following special commands:

`info spu event'
     Display SPU event facility status.  Shows current event mask and
     pending event status.

`info spu signal'
     Display SPU signal notification facility status.  Shows pending
     signal-control word and signal notification mode of both signal
     notification channels.

`info spu mailbox'
     Display SPU mailbox facility status.  Shows all pending entries,
     in order of processing, in each of the SPU Write Outbound, SPU
     Write Outbound Interrupt, and SPU Read Inbound mailboxes.

`info spu dma'
     Display MFC DMA status.  Shows all pending commands in the MFC DMA
     queue.  For each entry, opcode, tag, class IDs, effective and
     local store addresses and transfer size are shown.

`info spu proxydma'
     Display MFC Proxy-DMA status.  Shows all pending commands in the
     MFC Proxy-DMA queue.  For each entry, opcode, tag, class IDs,
     effective and local store addresses and transfer size are shown.


   When GDB is debugging a combined PowerPC/SPU application on the Cell
Broadband Engine, it provides in addition the following special
commands:

`set spu stop-on-load ARG'
     Set whether to stop for new SPE threads.  When set to `on', GDB
     will give control to the user when a new SPE thread enters its
     `main' function.  The default is `off'.

`show spu stop-on-load'
     Show whether to stop for new SPE threads.

`set spu auto-flush-cache ARG'
     Set whether to automatically flush the software-managed cache.
     When set to `on', GDB will automatically cause the SPE
     software-managed cache to be flushed whenever SPE execution stops.
     This provides a consistent view of PowerPC memory that is accessed
     via the cache.  If an application does not use the
     software-managed cache, this option has no effect.

`show spu auto-flush-cache'
     Show whether to automatically flush the software-managed cache.



File: gdb.info,  Node: PowerPC,  Prev: SPU,  Up: Architectures

21.4.7 PowerPC
--------------

When GDB is debugging the PowerPC architecture, it provides a set of
pseudo-registers to enable inspection of 128-bit wide Decimal Floating
Point numbers stored in the floating point registers. These values must
be stored in two consecutive registers, always starting at an even
register like `f0' or `f2'.

   The pseudo-registers go from `$dl0' through `$dl15', and are formed
by joining the even/odd register pairs `f0' and `f1' for `$dl0', `f2'
and `f3' for `$dl1' and so on.

   For POWER7 processors, GDB provides a set of pseudo-registers, the
64-bit wide Extended Floating Point Registers (`f32' through `f63').


File: gdb.info,  Node: Controlling GDB,  Next: Extending GDB,  Prev: Configurations,  Up: Top

22 Controlling GDB
******************

You can alter the way GDB interacts with you by using the `set'
command.  For commands controlling how GDB displays data, see *note
Print Settings: Print Settings.  Other settings are described here.

* Menu:

* Prompt::                      Prompt
* Editing::                     Command editing
* Command History::             Command history
* Screen Size::                 Screen size
* Numbers::                     Numbers
* ABI::                         Configuring the current ABI
* Messages/Warnings::           Optional warnings and messages
* Debugging Output::            Optional messages about internal happenings
* Other Misc Settings::         Other Miscellaneous Settings


File: gdb.info,  Node: Prompt,  Next: Editing,  Up: Controlling GDB

22.1 Prompt
===========

GDB indicates its readiness to read a command by printing a string
called the "prompt".  This string is normally `(gdb)'.  You can change
the prompt string with the `set prompt' command.  For instance, when
debugging GDB with GDB, it is useful to change the prompt in one of the
GDB sessions so that you can always tell which one you are talking to.

   _Note:_  `set prompt' does not add a space for you after the prompt
you set.  This allows you to set a prompt which ends in a space or a
prompt that does not.

`set prompt NEWPROMPT'
     Directs GDB to use NEWPROMPT as its prompt string henceforth.

`show prompt'
     Prints a line of the form: `Gdb's prompt is: YOUR-PROMPT'


File: gdb.info,  Node: Editing,  Next: Command History,  Prev: Prompt,  Up: Controlling GDB

22.2 Command Editing
====================

GDB reads its input commands via the "Readline" interface.  This GNU
library provides consistent behavior for programs which provide a
command line interface to the user.  Advantages are GNU Emacs-style or
"vi"-style inline editing of commands, `csh'-like history substitution,
and a storage and recall of command history across debugging sessions.

   You may control the behavior of command line editing in GDB with the
command `set'.

`set editing'
`set editing on'
     Enable command line editing (enabled by default).

`set editing off'
     Disable command line editing.

`show editing'
     Show whether command line editing is enabled.

   *Note Command Line Editing::, for more details about the Readline
interface.  Users unfamiliar with GNU Emacs or `vi' are encouraged to
read that chapter.


File: gdb.info,  Node: Command History,  Next: Screen Size,  Prev: Editing,  Up: Controlling GDB

22.3 Command History
====================

GDB can keep track of the commands you type during your debugging
sessions, so that you can be certain of precisely what happened.  Use
these commands to manage the GDB command history facility.

   GDB uses the GNU History library, a part of the Readline package, to
provide the history facility.  *Note Using History Interactively::, for
the detailed description of the History library.

   To issue a command to GDB without affecting certain aspects of the
state which is seen by users, prefix it with `server ' (*note Server
Prefix::).  This means that this command will not affect the command
history, nor will it affect GDB's notion of which command to repeat if
<RET> is pressed on a line by itself.

   The server prefix does not affect the recording of values into the
value history; to print a value without recording it into the value
history, use the `output' command instead of the `print' command.

   Here is the description of GDB commands related to command history.

`set history filename FNAME'
     Set the name of the GDB command history file to FNAME.  This is
     the file where GDB reads an initial command history list, and
     where it writes the command history from this session when it
     exits.  You can access this list through history expansion or
     through the history command editing characters listed below.  This
     file defaults to the value of the environment variable
     `GDBHISTFILE', or to `./.gdb_history' (`./_gdb_history' on MS-DOS)
     if this variable is not set.

`set history save'
`set history save on'
     Record command history in a file, whose name may be specified with
     the `set history filename' command.  By default, this option is
     disabled.

`set history save off'
     Stop recording command history in a file.

`set history size SIZE'
     Set the number of commands which GDB keeps in its history list.
     This defaults to the value of the environment variable `HISTSIZE',
     or to 256 if this variable is not set.

   History expansion assigns special meaning to the character `!'.
*Note Event Designators::, for more details.

   Since `!' is also the logical not operator in C, history expansion
is off by default. If you decide to enable history expansion with the
`set history expansion on' command, you may sometimes need to follow
`!' (when it is used as logical not, in an expression) with a space or
a tab to prevent it from being expanded.  The readline history
facilities do not attempt substitution on the strings `!=' and `!(',
even when history expansion is enabled.

   The commands to control history expansion are:

`set history expansion on'
`set history expansion'
     Enable history expansion.  History expansion is off by default.

`set history expansion off'
     Disable history expansion.

`show history'
`show history filename'
`show history save'
`show history size'
`show history expansion'
     These commands display the state of the GDB history parameters.
     `show history' by itself displays all four states.

`show commands'
     Display the last ten commands in the command history.

`show commands N'
     Print ten commands centered on command number N.

`show commands +'
     Print ten commands just after the commands last printed.


File: gdb.info,  Node: Screen Size,  Next: Numbers,  Prev: Command History,  Up: Controlling GDB

22.4 Screen Size
================

Certain commands to GDB may produce large amounts of information output
to the screen.  To help you read all of it, GDB pauses and asks you for
input at the end of each page of output.  Type <RET> when you want to
continue the output, or `q' to discard the remaining output.  Also, the
screen width setting determines when to wrap lines of output.
Depending on what is being printed, GDB tries to break the line at a
readable place, rather than simply letting it overflow onto the
following line.

   Normally GDB knows the size of the screen from the terminal driver
software.  For example, on Unix GDB uses the termcap data base together
with the value of the `TERM' environment variable and the `stty rows'
and `stty cols' settings.  If this is not correct, you can override it
with the `set height' and `set width' commands:

`set height LPP'
`show height'
`set width CPL'
`show width'
     These `set' commands specify a screen height of LPP lines and a
     screen width of CPL characters.  The associated `show' commands
     display the current settings.

     If you specify a height of zero lines, GDB does not pause during
     output no matter how long the output is.  This is useful if output
     is to a file or to an editor buffer.

     Likewise, you can specify `set width 0' to prevent GDB from
     wrapping its output.

`set pagination on'
`set pagination off'
     Turn the output pagination on or off; the default is on.  Turning
     pagination off is the alternative to `set height 0'.  Note that
     running GDB with the `--batch' option (*note -batch: Mode
     Options.) also automatically disables pagination.

`show pagination'
     Show the current pagination mode.


File: gdb.info,  Node: Numbers,  Next: ABI,  Prev: Screen Size,  Up: Controlling GDB

22.5 Numbers
============

You can always enter numbers in octal, decimal, or hexadecimal in GDB
by the usual conventions: octal numbers begin with `0', decimal numbers
end with `.', and hexadecimal numbers begin with `0x'.  Numbers that
neither begin with `0' or `0x', nor end with a `.' are, by default,
entered in base 10; likewise, the default display for numbers--when no
particular format is specified--is base 10.  You can change the default
base for both input and output with the commands described below.

`set input-radix BASE'
     Set the default base for numeric input.  Supported choices for
     BASE are decimal 8, 10, or 16.  BASE must itself be specified
     either unambiguously or using the current input radix; for
     example, any of

          set input-radix 012
          set input-radix 10.
          set input-radix 0xa

     sets the input base to decimal.  On the other hand, `set
     input-radix 10' leaves the input radix unchanged, no matter what
     it was, since `10', being without any leading or trailing signs of
     its base, is interpreted in the current radix.  Thus, if the
     current radix is 16, `10' is interpreted in hex, i.e. as 16
     decimal, which doesn't change the radix.

`set output-radix BASE'
     Set the default base for numeric display.  Supported choices for
     BASE are decimal 8, 10, or 16.  BASE must itself be specified
     either unambiguously or using the current input radix.

`show input-radix'
     Display the current default base for numeric input.

`show output-radix'
     Display the current default base for numeric display.

`set radix [BASE]'
`show radix'
     These commands set and show the default base for both input and
     output of numbers.  `set radix' sets the radix of input and output
     to the same base; without an argument, it resets the radix back to
     its default value of 10.



File: gdb.info,  Node: ABI,  Next: Messages/Warnings,  Prev: Numbers,  Up: Controlling GDB

22.6 Configuring the Current ABI
================================

GDB can determine the "ABI" (Application Binary Interface) of your
application automatically.  However, sometimes you need to override its
conclusions.  Use these commands to manage GDB's view of the current
ABI.

   One GDB configuration can debug binaries for multiple operating
system targets, either via remote debugging or native emulation.  GDB
will autodetect the "OS ABI" (Operating System ABI) in use, but you can
override its conclusion using the `set osabi' command.  One example
where this is useful is in debugging of binaries which use an alternate
C library (e.g. UCLIBC for GNU/Linux) which does not have the same
identifying marks that the standard C library for your platform
provides.

`show osabi'
     Show the OS ABI currently in use.

`set osabi'
     With no argument, show the list of registered available OS ABI's.

`set osabi ABI'
     Set the current OS ABI to ABI.

   Generally, the way that an argument of type `float' is passed to a
function depends on whether the function is prototyped.  For a
prototyped (i.e. ANSI/ISO style) function, `float' arguments are passed
unchanged, according to the architecture's convention for `float'.  For
unprototyped (i.e. K&R style) functions, `float' arguments are first
promoted to type `double' and then passed.

   Unfortunately, some forms of debug information do not reliably
indicate whether a function is prototyped.  If GDB calls a function
that is not marked as prototyped, it consults `set
coerce-float-to-double'.

`set coerce-float-to-double'
`set coerce-float-to-double on'
     Arguments of type `float' will be promoted to `double' when passed
     to an unprototyped function.  This is the default setting.

`set coerce-float-to-double off'
     Arguments of type `float' will be passed directly to unprototyped
     functions.

`show coerce-float-to-double'
     Show the current setting of promoting `float' to `double'.

   GDB needs to know the ABI used for your program's C++ objects.  The
correct C++ ABI depends on which C++ compiler was used to build your
application.  GDB only fully supports programs with a single C++ ABI;
if your program contains code using multiple C++ ABI's or if GDB can
not identify your program's ABI correctly, you can tell GDB which ABI
to use.  Currently supported ABI's include "gnu-v2", for `g++' versions
before 3.0, "gnu-v3", for `g++' versions 3.0 and later, and "hpaCC" for
the HP ANSI C++ compiler.  Other C++ compilers may use the "gnu-v2" or
"gnu-v3" ABI's as well.  The default setting is "auto".

`show cp-abi'
     Show the C++ ABI currently in use.

`set cp-abi'
     With no argument, show the list of supported C++ ABI's.

`set cp-abi ABI'
`set cp-abi auto'
     Set the current C++ ABI to ABI, or return to automatic detection.


File: gdb.info,  Node: Messages/Warnings,  Next: Debugging Output,  Prev: ABI,  Up: Controlling GDB

22.7 Optional Warnings and Messages
===================================

By default, GDB is silent about its inner workings.  If you are running
on a slow machine, you may want to use the `set verbose' command.  This
makes GDB tell you when it does a lengthy internal operation, so you
will not think it has crashed.

   Currently, the messages controlled by `set verbose' are those which
announce that the symbol table for a source file is being read; see
`symbol-file' in *note Commands to Specify Files: Files.

`set verbose on'
     Enables GDB output of certain informational messages.

`set verbose off'
     Disables GDB output of certain informational messages.

`show verbose'
     Displays whether `set verbose' is on or off.

   By default, if GDB encounters bugs in the symbol table of an object
file, it is silent; but if you are debugging a compiler, you may find
this information useful (*note Errors Reading Symbol Files: Symbol
Errors.).

`set complaints LIMIT'
     Permits GDB to output LIMIT complaints about each type of unusual
     symbols before becoming silent about the problem.  Set LIMIT to
     zero to suppress all complaints; set it to a large number to
     prevent complaints from being suppressed.

`show complaints'
     Displays how many symbol complaints GDB is permitted to produce.


   By default, GDB is cautious, and asks what sometimes seems to be a
lot of stupid questions to confirm certain commands.  For example, if
you try to run a program which is already running:

     (gdb) run
     The program being debugged has been started already.
     Start it from the beginning? (y or n)

   If you are willing to unflinchingly face the consequences of your own
commands, you can disable this "feature":

`set confirm off'
     Disables confirmation requests.  Note that running GDB with the
     `--batch' option (*note -batch: Mode Options.) also automatically
     disables confirmation requests.

`set confirm on'
     Enables confirmation requests (the default).

`show confirm'
     Displays state of confirmation requests.


   If you need to debug user-defined commands or sourced files you may
find it useful to enable "command tracing".  In this mode each command
will be printed as it is executed, prefixed with one or more `+'
symbols, the quantity denoting the call depth of each command.

`set trace-commands on'
     Enable command tracing.

`set trace-commands off'
     Disable command tracing.

`show trace-commands'
     Display the current state of command tracing.


File: gdb.info,  Node: Debugging Output,  Next: Other Misc Settings,  Prev: Messages/Warnings,  Up: Controlling GDB

22.8 Optional Messages about Internal Happenings
================================================

GDB has commands that enable optional debugging messages from various
GDB subsystems; normally these commands are of interest to GDB
maintainers, or when reporting a bug.  This section documents those
commands.

`set exec-done-display'
     Turns on or off the notification of asynchronous commands'
     completion.  When on, GDB will print a message when an
     asynchronous command finishes its execution.  The default is off.  

`show exec-done-display'
     Displays the current setting of asynchronous command completion
     notification.  

`set debug arch'
     Turns on or off display of gdbarch debugging info.  The default is
     off 

`show debug arch'
     Displays the current state of displaying gdbarch debugging info.

`set debug aix-thread'
     Display debugging messages about inner workings of the AIX thread
     module.

`show debug aix-thread'
     Show the current state of AIX thread debugging info display.

`set debug check-physname'
     Check the results of the "physname" computation.  When reading
     DWARF debugging information for C++, GDB attempts to compute each
     entity's name.  GDB can do this computation in two different ways,
     depending on exactly what information is present.  When enabled,
     this setting causes GDB to compute the names both ways and display
     any discrepancies.

`show debug check-physname'
     Show the current state of "physname" checking.

`set debug dwarf2-die'
     Dump DWARF2 DIEs after they are read in.  The value is the number
     of nesting levels to print.  A value of zero turns off the display.

`show debug dwarf2-die'
     Show the current state of DWARF2 DIE debugging.

`set debug displaced'
     Turns on or off display of GDB debugging info for the displaced
     stepping support.  The default is off.

`show debug displaced'
     Displays the current state of displaying GDB debugging info
     related to displaced stepping.

`set debug event'
     Turns on or off display of GDB event debugging info.  The default
     is off.

`show debug event'
     Displays the current state of displaying GDB event debugging info.

`set debug expression'
     Turns on or off display of debugging info about GDB expression
     parsing.  The default is off.

`show debug expression'
     Displays the current state of displaying debugging info about GDB
     expression parsing.

`set debug frame'
     Turns on or off display of GDB frame debugging info.  The default
     is off.

`show debug frame'
     Displays the current state of displaying GDB frame debugging info.

`set debug gnu-nat'
     Turns on or off debugging messages from the GNU/Hurd debug support.

`show debug gnu-nat'
     Show the current state of GNU/Hurd debugging messages.

`set debug infrun'
     Turns on or off display of GDB debugging info for running the
     inferior.  The default is off.  `infrun.c' contains GDB's runtime
     state machine used for implementing operations such as
     single-stepping the inferior.

`show debug infrun'
     Displays the current state of GDB inferior debugging.

`set debug jit'
     Turns on or off debugging messages from JIT debug support.

`show debug jit'
     Displays the current state of GDB JIT debugging.

`set debug lin-lwp'
     Turns on or off debugging messages from the Linux LWP debug
     support.

`show debug lin-lwp'
     Show the current state of Linux LWP debugging messages.

`set debug lin-lwp-async'
     Turns on or off debugging messages from the Linux LWP async debug
     support.

`show debug lin-lwp-async'
     Show the current state of Linux LWP async debugging messages.

`set debug observer'
     Turns on or off display of GDB observer debugging.  This includes
     info such as the notification of observable events.

`show debug observer'
     Displays the current state of observer debugging.

`set debug overload'
     Turns on or off display of GDB C++ overload debugging info. This
     includes info such as ranking of functions, etc.  The default is
     off.

`show debug overload'
     Displays the current state of displaying GDB C++ overload
     debugging info.  

`set debug parser'
     Turns on or off the display of expression parser debugging output.
     Internally, this sets the `yydebug' variable in the expression
     parser.  *Note Tracing Your Parser: (bison)Tracing, for details.
     The default is off.

`show debug parser'
     Show the current state of expression parser debugging.  

`set debug remote'
     Turns on or off display of reports on all packets sent back and
     forth across the serial line to the remote machine.  The info is
     printed on the GDB standard output stream. The default is off.

`show debug remote'
     Displays the state of display of remote packets.

`set debug serial'
     Turns on or off display of GDB serial debugging info. The default
     is off.

`show debug serial'
     Displays the current state of displaying GDB serial debugging info.

`set debug solib-frv'
     Turns on or off debugging messages for FR-V shared-library code.

`show debug solib-frv'
     Display the current state of FR-V shared-library code debugging
     messages.

`set debug target'
     Turns on or off display of GDB target debugging info. This info
     includes what is going on at the target level of GDB, as it
     happens. The default is 0.  Set it to 1 to track events, and to 2
     to also track the value of large memory transfers.  Changes to
     this flag do not take effect until the next time you connect to a
     target or use the `run' command.

`show debug target'
     Displays the current state of displaying GDB target debugging info.

`set debug timestamp'
     Turns on or off display of timestamps with GDB debugging info.
     When enabled, seconds and microseconds are displayed before each
     debugging message.

`show debug timestamp'
     Displays the current state of displaying timestamps with GDB
     debugging info.

`set debugvarobj'
     Turns on or off display of GDB variable object debugging info. The
     default is off.

`show debugvarobj'
     Displays the current state of displaying GDB variable object
     debugging info.

`set debug xml'
     Turns on or off debugging messages for built-in XML parsers.

`show debug xml'
     Displays the current state of XML debugging messages.


File: gdb.info,  Node: Other Misc Settings,  Prev: Debugging Output,  Up: Controlling GDB

22.9 Other Miscellaneous Settings
=================================

`set interactive-mode'
     If `on', forces GDB to assume that GDB was started in a terminal.
     In practice, this means that GDB should wait for the user to
     answer queries generated by commands entered at the command
     prompt.  If `off', forces GDB to operate in the opposite mode, and
     it uses the default answers to all queries.  If `auto' (the
     default), GDB tries to determine whether its standard input is a
     terminal, and works in interactive-mode if it is,
     non-interactively otherwise.

     In the vast majority of cases, the debugger should be able to guess
     correctly which mode should be used.  But this setting can be
     useful in certain specific cases, such as running a MinGW GDB
     inside a cygwin window.

`show interactive-mode'
     Displays whether the debugger is operating in interactive mode or
     not.


File: gdb.info,  Node: Extending GDB,  Next: Interpreters,  Prev: Controlling GDB,  Up: Top

23 Extending GDB
****************

GDB provides two mechanisms for extension.  The first is based on
composition of GDB commands, and the second is based on the Python
scripting language.

   To facilitate the use of these extensions, GDB is capable of
evaluating the contents of a file.  When doing so, GDB can recognize
which scripting language is being used by looking at the filename
extension.  Files with an unrecognized filename extension are always
treated as a GDB Command Files.  *Note Command files: Command Files.

   You can control how GDB evaluates these files with the following
setting:

`set script-extension off'
     All scripts are always evaluated as GDB Command Files.

`set script-extension soft'
     The debugger determines the scripting language based on filename
     extension.  If this scripting language is supported, GDB evaluates
     the script using that language.  Otherwise, it evaluates the file
     as a GDB Command File.

`set script-extension strict'
     The debugger determines the scripting language based on filename
     extension, and evaluates the script using that language.  If the
     language is not supported, then the evaluation fails.

`show script-extension'
     Display the current value of the `script-extension' option.


* Menu:

* Sequences::          Canned Sequences of Commands
* Python::             Scripting GDB using Python


File: gdb.info,  Node: Sequences,  Next: Python,  Up: Extending GDB

23.1 Canned Sequences of Commands
=================================

Aside from breakpoint commands (*note Breakpoint Command Lists: Break
Commands.), GDB provides two ways to store sequences of commands for
execution as a unit: user-defined commands and command files.

* Menu:

* Define::             How to define your own commands
* Hooks::              Hooks for user-defined commands
* Command Files::      How to write scripts of commands to be stored in a file
* Output::             Commands for controlled output


File: gdb.info,  Node: Define,  Next: Hooks,  Up: Sequences

23.1.1 User-defined Commands
----------------------------

A "user-defined command" is a sequence of GDB commands to which you
assign a new name as a command.  This is done with the `define'
command.  User commands may accept up to 10 arguments separated by
whitespace.  Arguments are accessed within the user command via
`$arg0...$arg9'.  A trivial example:

     define adder
       print $arg0 + $arg1 + $arg2
     end

To execute the command use:

     adder 1 2 3

This defines the command `adder', which prints the sum of its three
arguments.  Note the arguments are text substitutions, so they may
reference variables, use complex expressions, or even perform inferior
functions calls.

   In addition, `$argc' may be used to find out how many arguments have
been passed.  This expands to a number in the range 0...10.

     define adder
       if $argc == 2
         print $arg0 + $arg1
       end
       if $argc == 3
         print $arg0 + $arg1 + $arg2
       end
     end

`define COMMANDNAME'
     Define a command named COMMANDNAME.  If there is already a command
     by that name, you are asked to confirm that you want to redefine
     it.  COMMANDNAME may be a bare command name consisting of letters,
     numbers, dashes, and underscores.  It may also start with any
     predefined prefix command.  For example, `define target my-target'
     creates a user-defined `target my-target' command.

     The definition of the command is made up of other GDB command
     lines, which are given following the `define' command.  The end of
     these commands is marked by a line containing `end'.

`document COMMANDNAME'
     Document the user-defined command COMMANDNAME, so that it can be
     accessed by `help'.  The command COMMANDNAME must already be
     defined.  This command reads lines of documentation just as
     `define' reads the lines of the command definition, ending with
     `end'.  After the `document' command is finished, `help' on command
     COMMANDNAME displays the documentation you have written.

     You may use the `document' command again to change the
     documentation of a command.  Redefining the command with `define'
     does not change the documentation.

`dont-repeat'
     Used inside a user-defined command, this tells GDB that this
     command should not be repeated when the user hits <RET> (*note
     repeat last command: Command Syntax.).

`help user-defined'
     List all user-defined commands, with the first line of the
     documentation (if any) for each.

`show user'
`show user COMMANDNAME'
     Display the GDB commands used to define COMMANDNAME (but not its
     documentation).  If no COMMANDNAME is given, display the
     definitions for all user-defined commands.

`show max-user-call-depth'
`set max-user-call-depth'
     The value of `max-user-call-depth' controls how many recursion
     levels are allowed in user-defined commands before GDB suspects an
     infinite recursion and aborts the command.

   In addition to the above commands, user-defined commands frequently
use control flow commands, described in *note Command Files::.

   When user-defined commands are executed, the commands of the
definition are not printed.  An error in any command stops execution of
the user-defined command.

   If used interactively, commands that would ask for confirmation
proceed without asking when used inside a user-defined command.  Many
GDB commands that normally print messages to say what they are doing
omit the messages when used in a user-defined command.


File: gdb.info,  Node: Hooks,  Next: Command Files,  Prev: Define,  Up: Sequences

23.1.2 User-defined Command Hooks
---------------------------------

You may define "hooks", which are a special kind of user-defined
command.  Whenever you run the command `foo', if the user-defined
command `hook-foo' exists, it is executed (with no arguments) before
that command.

   A hook may also be defined which is run after the command you
executed.  Whenever you run the command `foo', if the user-defined
command `hookpost-foo' exists, it is executed (with no arguments) after
that command.  Post-execution hooks may exist simultaneously with
pre-execution hooks, for the same command.

   It is valid for a hook to call the command which it hooks.  If this
occurs, the hook is not re-executed, thereby avoiding infinite
recursion.

   In addition, a pseudo-command, `stop' exists.  Defining
(`hook-stop') makes the associated commands execute every time
execution stops in your program: before breakpoint commands are run,
displays are printed, or the stack frame is printed.

   For example, to ignore `SIGALRM' signals while single-stepping, but
treat them normally during normal execution, you could define:

     define hook-stop
     handle SIGALRM nopass
     end

     define hook-run
     handle SIGALRM pass
     end

     define hook-continue
     handle SIGALRM pass
     end

   As a further example, to hook at the beginning and end of the `echo'
command, and to add extra text to the beginning and end of the message,
you could define:

     define hook-echo
     echo <<<---
     end

     define hookpost-echo
     echo --->>>\n
     end

     (gdb) echo Hello World
     <<<---Hello World--->>>
     (gdb)

   You can define a hook for any single-word command in GDB, but not
for command aliases; you should define a hook for the basic command
name, e.g.  `backtrace' rather than `bt'.  You can hook a multi-word
command by adding `hook-' or `hookpost-' to the last word of the
command, e.g.  `define target hook-remote' to add a hook to `target
remote'.

   If an error occurs during the execution of your hook, execution of
GDB commands stops and GDB issues a prompt (before the command that you
actually typed had a chance to run).

   If you try to define a hook which does not match any known command,
you get a warning from the `define' command.


File: gdb.info,  Node: Command Files,  Next: Output,  Prev: Hooks,  Up: Sequences

23.1.3 Command Files
--------------------

A command file for GDB is a text file made of lines that are GDB
commands.  Comments (lines starting with `#') may also be included.  An
empty line in a command file does nothing; it does not mean to repeat
the last command, as it would from the terminal.

   You can request the execution of a command file with the `source'
command.  Note that the `source' command is also used to evaluate
scripts that are not Command Files.  The exact behavior can be
configured using the `script-extension' setting.  *Note Extending GDB:
Extending GDB.

`source [-s] [-v] FILENAME'
     Execute the command file FILENAME.

   The lines in a command file are generally executed sequentially,
unless the order of execution is changed by one of the _flow-control
commands_ described below.  The commands are not printed as they are
executed.  An error in any command terminates execution of the command
file and control is returned to the console.

   GDB first searches for FILENAME in the current directory.  If the
file is not found there, and FILENAME does not specify a directory,
then GDB also looks for the file on the source search path (specified
with the `directory' command); except that `$cdir' is not searched
because the compilation directory is not relevant to scripts.

   If `-s' is specified, then GDB searches for FILENAME on the search
path even if FILENAME specifies a directory.  The search is done by
appending FILENAME to each element of the search path.  So, for
example, if FILENAME is `mylib/myscript' and the search path contains
`/home/user' then GDB will look for the script
`/home/user/mylib/myscript'.  The search is also done if FILENAME is an
absolute path.  For example, if FILENAME is `/tmp/myscript' and the
search path contains `/home/user' then GDB will look for the script
`/home/user/tmp/myscript'.  For DOS-like systems, if FILENAME contains
a drive specification, it is stripped before concatenation.  For
example, if FILENAME is `d:myscript' and the search path contains
`c:/tmp' then GDB will look for the script `c:/tmp/myscript'.

   If `-v', for verbose mode, is given then GDB displays each command
as it is executed.  The option must be given before FILENAME, and is
interpreted as part of the filename anywhere else.

   Commands that would ask for confirmation if used interactively
proceed without asking when used in a command file.  Many GDB commands
that normally print messages to say what they are doing omit the
messages when called from command files.

   GDB also accepts command input from standard input.  In this mode,
normal output goes to standard output and error output goes to standard
error.  Errors in a command file supplied on standard input do not
terminate execution of the command file--execution continues with the
next command.

     gdb < cmds > log 2>&1

   (The syntax above will vary depending on the shell used.) This
example will execute commands from the file `cmds'. All output and
errors would be directed to `log'.

   Since commands stored on command files tend to be more general than
commands typed interactively, they frequently need to deal with
complicated situations, such as different or unexpected values of
variables and symbols, changes in how the program being debugged is
built, etc.  GDB provides a set of flow-control commands to deal with
these complexities.  Using these commands, you can write complex
scripts that loop over data structures, execute commands conditionally,
etc.

`if'
`else'
     This command allows to include in your script conditionally
     executed commands. The `if' command takes a single argument, which
     is an expression to evaluate.  It is followed by a series of
     commands that are executed only if the expression is true (its
     value is nonzero).  There can then optionally be an `else' line,
     followed by a series of commands that are only executed if the
     expression was false.  The end of the list is marked by a line
     containing `end'.

`while'
     This command allows to write loops.  Its syntax is similar to
     `if': the command takes a single argument, which is an expression
     to evaluate, and must be followed by the commands to execute, one
     per line, terminated by an `end'.  These commands are called the
     "body" of the loop.  The commands in the body of `while' are
     executed repeatedly as long as the expression evaluates to true.

`loop_break'
     This command exits the `while' loop in whose body it is included.
     Execution of the script continues after that `while's `end' line.

`loop_continue'
     This command skips the execution of the rest of the body of
     commands in the `while' loop in whose body it is included.
     Execution branches to the beginning of the `while' loop, where it
     evaluates the controlling expression.

`end'
     Terminate the block of commands that are the body of `if', `else',
     or `while' flow-control commands.


File: gdb.info,  Node: Output,  Prev: Command Files,  Up: Sequences

23.1.4 Commands for Controlled Output
-------------------------------------

During the execution of a command file or a user-defined command, normal
GDB output is suppressed; the only output that appears is what is
explicitly printed by the commands in the definition.  This section
describes three commands useful for generating exactly the output you
want.

`echo TEXT'
     Print TEXT.  Nonprinting characters can be included in TEXT using
     C escape sequences, such as `\n' to print a newline.  *No newline
     is printed unless you specify one.* In addition to the standard C
     escape sequences, a backslash followed by a space stands for a
     space.  This is useful for displaying a string with spaces at the
     beginning or the end, since leading and trailing spaces are
     otherwise trimmed from all arguments.  To print ` and foo = ', use
     the command `echo \ and foo = \ '.

     A backslash at the end of TEXT can be used, as in C, to continue
     the command onto subsequent lines.  For example,

          echo This is some text\n\
          which is continued\n\
          onto several lines.\n

     produces the same output as

          echo This is some text\n
          echo which is continued\n
          echo onto several lines.\n

`output EXPRESSION'
     Print the value of EXPRESSION and nothing but that value: no
     newlines, no `$NN = '.  The value is not entered in the value
     history either.  *Note Expressions: Expressions, for more
     information on expressions.

`output/FMT EXPRESSION'
     Print the value of EXPRESSION in format FMT.  You can use the same
     formats as for `print'.  *Note Output Formats: Output Formats, for
     more information.

`printf TEMPLATE, EXPRESSIONS...'
     Print the values of one or more EXPRESSIONS under the control of
     the string TEMPLATE.  To print several values, make EXPRESSIONS be
     a comma-separated list of individual expressions, which may be
     either numbers or pointers.  Their values are printed as specified
     by TEMPLATE, exactly as a C program would do by executing the code
     below:

          printf (TEMPLATE, EXPRESSIONS...);

     As in `C' `printf', ordinary characters in TEMPLATE are printed
     verbatim, while "conversion specification" introduced by the `%'
     character cause subsequent EXPRESSIONS to be evaluated, their
     values converted and formatted according to type and style
     information encoded in the conversion specifications, and then
     printed.

     For example, you can print two values in hex like this:

          printf "foo, bar-foo = 0x%x, 0x%x\n", foo, bar-foo

     `printf' supports all the standard `C' conversion specifications,
     including the flags and modifiers between the `%' character and
     the conversion letter, with the following exceptions:

        * The argument-ordering modifiers, such as `2$', are not
          supported.

        * The modifier `*' is not supported for specifying precision or
          width.

        * The `'' flag (for separation of digits into groups according
          to `LC_NUMERIC'') is not supported.

        * The type modifiers `hh', `j', `t', and `z' are not supported.

        * The conversion letter `n' (as in `%n') is not supported.

        * The conversion letters `a' and `A' are not supported.

     Note that the `ll' type modifier is supported only if the
     underlying `C' implementation used to build GDB supports the `long
     long int' type, and the `L' type modifier is supported only if
     `long double' type is available.

     As in `C', `printf' supports simple backslash-escape sequences,
     such as `\n', `\t', `\\', `\"', `\a', and `\f', that consist of
     backslash followed by a single character.  Octal and hexadecimal
     escape sequences are not supported.

     Additionally, `printf' supports conversion specifications for DFP
     ("Decimal Floating Point") types using the following length
     modifiers together with a floating point specifier.  letters:

        * `H' for printing `Decimal32' types.

        * `D' for printing `Decimal64' types.

        * `DD' for printing `Decimal128' types.

     If the underlying `C' implementation used to build GDB has support
     for the three length modifiers for DFP types, other modifiers such
     as width and precision will also be available for GDB to use.

     In case there is no such `C' support, no additional modifiers will
     be available and the value will be printed in the standard way.

     Here's an example of printing DFP types using the above conversion
     letters:
          printf "D32: %Hf - D64: %Df - D128: %DDf\n",1.2345df,1.2E10dd,1.2E1dl

`eval TEMPLATE, EXPRESSIONS...'
     Convert the values of one or more EXPRESSIONS under the control of
     the string TEMPLATE to a command line, and call it.



File: gdb.info,  Node: Python,  Prev: Sequences,  Up: Extending GDB

23.2 Scripting GDB using Python
===============================

You can script GDB using the Python programming language
(http://www.python.org/).  This feature is available only if GDB was
configured using `--with-python'.

   Python scripts used by GDB should be installed in
`DATA-DIRECTORY/python', where DATA-DIRECTORY is the data directory as
determined at GDB startup (*note Data Files::).  This directory, known
as the "python directory", is automatically added to the Python Search
Path in order to allow the Python interpreter to locate all scripts
installed at this location.

* Menu:

* Python Commands::             Accessing Python from GDB.
* Python API::                  Accessing GDB from Python.
* Auto-loading::                Automatically loading Python code.
* Python modules::              Python modules provided by GDB.


File: gdb.info,  Node: Python Commands,  Next: Python API,  Up: Python

23.2.1 Python Commands
----------------------

GDB provides one command for accessing the Python interpreter, and one
related setting:

`python [CODE]'
     The `python' command can be used to evaluate Python code.

     If given an argument, the `python' command will evaluate the
     argument as a Python command.  For example:

          (gdb) python print 23
          23

     If you do not provide an argument to `python', it will act as a
     multi-line command, like `define'.  In this case, the Python
     script is made up of subsequent command lines, given after the
     `python' command.  This command list is terminated using a line
     containing `end'.  For example:

          (gdb) python
          Type python script
          End with a line saying just "end".
          >print 23
          >end
          23

`maint set python print-stack'
     By default, GDB will print a stack trace when an error occurs in a
     Python script.  This can be controlled using `maint set python
     print-stack': if `on', the default, then Python stack printing is
     enabled; if `off', then Python stack printing is disabled.

   It is also possible to execute a Python script from the GDB
interpreter:

`source `script-name''
     The script name must end with `.py' and GDB must be configured to
     recognize the script language based on filename extension using
     the `script-extension' setting.  *Note Extending GDB: Extending
     GDB.

`python execfile ("script-name")'
     This method is based on the `execfile' Python built-in function,
     and thus is always available.


File: gdb.info,  Node: Python API,  Next: Auto-loading,  Prev: Python Commands,  Up: Python

23.2.2 Python API
-----------------

At startup, GDB overrides Python's `sys.stdout' and `sys.stderr' to
print using GDB's output-paging streams.  A Python program which
outputs to one of these streams may have its output interrupted by the
user (*note Screen Size::).  In this situation, a Python
`KeyboardInterrupt' exception is thrown.

* Menu:

* Basic Python::                Basic Python Functions.
* Exception Handling::          How Python exceptions are translated.
* Values From Inferior::        Python representation of values.
* Types In Python::             Python representation of types.
* Pretty Printing API::         Pretty-printing values.
* Selecting Pretty-Printers::   How GDB chooses a pretty-printer.
* Writing a Pretty-Printer::    Writing a Pretty-Printer.
* Inferiors In Python::         Python representation of inferiors (processes)
* Events In Python::            Listening for events from GDB.
* Threads In Python::           Accessing inferior threads from Python.
* Commands In Python::          Implementing new commands in Python.
* Parameters In Python::        Adding new GDB parameters.
* Functions In Python::         Writing new convenience functions.
* Progspaces In Python::        Program spaces.
* Objfiles In Python::          Object files.
* Frames In Python::            Accessing inferior stack frames from Python.
* Blocks In Python::            Accessing frame blocks from Python.
* Symbols In Python::           Python representation of symbols.
* Symbol Tables In Python::     Python representation of symbol tables.
* Lazy Strings In Python::      Python representation of lazy strings.
* Breakpoints In Python::       Manipulating breakpoints using Python.


File: gdb.info,  Node: Basic Python,  Next: Exception Handling,  Up: Python API

23.2.2.1 Basic Python
.....................

GDB introduces a new Python module, named `gdb'.  All methods and
classes added by GDB are placed in this module.  GDB automatically
`import's the `gdb' module for use in all scripts evaluated by the
`python' command.

 -- Variable: PYTHONDIR
     A string containing the python directory (*note Python::).

 -- Function: execute command [from_tty] [to_string]
     Evaluate COMMAND, a string, as a GDB CLI command.  If a GDB
     exception happens while COMMAND runs, it is translated as
     described in *note Exception Handling: Exception Handling.

     FROM_TTY specifies whether GDB ought to consider this command as
     having originated from the user invoking it interactively.  It
     must be a boolean value.  If omitted, it defaults to `False'.

     By default, any output produced by COMMAND is sent to GDB's
     standard output.  If the TO_STRING parameter is `True', then
     output will be collected by `gdb.execute' and returned as a
     string.  The default is `False', in which case the return value is
     `None'.  If TO_STRING is `True', the GDB virtual terminal will be
     temporarily set to unlimited width and height, and its pagination
     will be disabled; *note Screen Size::.

 -- Function: breakpoints
     Return a sequence holding all of GDB's breakpoints.  *Note
     Breakpoints In Python::, for more information.

 -- Function: parameter parameter
     Return the value of a GDB parameter.  PARAMETER is a string naming
     the parameter to look up; PARAMETER may contain spaces if the
     parameter has a multi-part name.  For example, `print object' is a
     valid parameter name.

     If the named parameter does not exist, this function throws a
     `gdb.error' (*note Exception Handling::).  Otherwise, the
     parameter's value is converted to a Python value of the appropriate
     type, and returned.

 -- Function: history number
     Return a value from GDB's value history (*note Value History::).
     NUMBER indicates which history element to return.  If NUMBER is
     negative, then GDB will take its absolute value and count backward
     from the last element (i.e., the most recent element) to find the
     value to return.  If NUMBER is zero, then GDB will return the most
     recent element.  If the element specified by NUMBER doesn't exist
     in the value history, a `gdb.error' exception will be raised.

     If no exception is raised, the return value is always an instance
     of `gdb.Value' (*note Values From Inferior::).

 -- Function: parse_and_eval expression
     Parse EXPRESSION as an expression in the current language,
     evaluate it, and return the result as a `gdb.Value'.  EXPRESSION
     must be a string.

     This function can be useful when implementing a new command (*note
     Commands In Python::), as it provides a way to parse the command's
     argument as an expression.  It is also useful simply to compute
     values, for example, it is the only way to get the value of a
     convenience variable (*note Convenience Vars::) as a `gdb.Value'.

 -- Function: post_event event
     Put EVENT, a callable object taking no arguments, into GDB's
     internal event queue.  This callable will be invoked at some later
     point, during GDB's event processing.  Events posted using
     `post_event' will be run in the order in which they were posted;
     however, there is no way to know when they will be processed
     relative to other events inside GDB.

     GDB is not thread-safe.  If your Python program uses multiple
     threads, you must be careful to only call GDB-specific functions
     in the main GDB thread.  `post_event' ensures this.  For example:

          (gdb) python
          >import threading
          >
          >class Writer():
          > def __init__(self, message):
          >        self.message = message;
          > def __call__(self):
          >        gdb.write(self.message)
          >
          >class MyThread1 (threading.Thread):
          > def run (self):
          >        gdb.post_event(Writer("Hello "))
          >
          >class MyThread2 (threading.Thread):
          > def run (self):
          >        gdb.post_event(Writer("World\n"))
          >
          >MyThread1().start()
          >MyThread2().start()
          >end
          (gdb) Hello World

 -- Function: write string [stream]
     Print a string to GDB's paginated output stream.  The optional
     STREAM determines the stream to print to.  The default stream is
     GDB's standard output stream.  Possible stream values are:

    `STDOUT'
          GDB's standard output stream.

    `STDERR'
          GDB's standard error stream.

    `STDLOG'
          GDB's log stream (*note Logging Output::).

     Writing to `sys.stdout' or `sys.stderr' will automatically call
     this function and will automatically direct the output to the
     relevant stream.

 -- Function: flush
     Flush the buffer of a GDB paginated stream so that the contents
     are displayed immediately.  GDB will flush the contents of a
     stream automatically when it encounters a newline in the buffer.
     The optional STREAM determines the stream to flush.  The default
     stream is GDB's standard output stream.  Possible stream values
     are:

    `STDOUT'
          GDB's standard output stream.

    `STDERR'
          GDB's standard error stream.

    `STDLOG'
          GDB's log stream (*note Logging Output::).


     Flushing `sys.stdout' or `sys.stderr' will automatically call this
     function for the relevant stream.

 -- Function: target_charset
     Return the name of the current target character set (*note
     Character Sets::).  This differs from
     `gdb.parameter('target-charset')' in that `auto' is never returned.

 -- Function: target_wide_charset
     Return the name of the current target wide character set (*note
     Character Sets::).  This differs from
     `gdb.parameter('target-wide-charset')' in that `auto' is never
     returned.

 -- Function: solib_name address
     Return the name of the shared library holding the given ADDRESS as
     a string, or `None'.

 -- Function: decode_line [expression]
     Return locations of the line specified by EXPRESSION, or of the
     current line if no argument was given.  This function returns a
     Python tuple containing two elements.  The first element contains
     a string holding any unparsed section of EXPRESSION (or `None' if
     the expression has been fully parsed).  The second element contains
     either `None' or another tuple that contains all the locations
     that match the expression represented as `gdb.Symtab_and_line'
     objects (*note Symbol Tables In Python::).  If EXPRESSION is
     provided, it is decoded the way that GDB's inbuilt `break' or
     `edit' commands do (*note Specify Location::).


File: gdb.info,  Node: Exception Handling,  Next: Values From Inferior,  Prev: Basic Python,  Up: Python API

23.2.2.2 Exception Handling
...........................

When executing the `python' command, Python exceptions uncaught within
the Python code are translated to calls to GDB error-reporting
mechanism.  If the command that called `python' does not handle the
error, GDB will terminate it and print an error message containing the
Python exception name, the associated value, and the Python call stack
backtrace at the point where the exception was raised.  Example:

     (gdb) python print foo
     Traceback (most recent call last):
       File "<string>", line 1, in <module>
     NameError: name 'foo' is not defined

   GDB errors that happen in GDB commands invoked by Python code are
converted to Python exceptions.  The type of the Python exception
depends on the error.

`gdb.error'
     This is the base class for most exceptions generated by GDB.  It
     is derived from `RuntimeError', for compatibility with earlier
     versions of GDB.

     If an error occurring in GDB does not fit into some more specific
     category, then the generated exception will have this type.

`gdb.MemoryError'
     This is a subclass of `gdb.error' which is thrown when an
     operation tried to access invalid memory in the inferior.

`KeyboardInterrupt'
     User interrupt (via `C-c' or by typing `q' at a pagination prompt)
     is translated to a Python `KeyboardInterrupt' exception.

   In all cases, your exception handler will see the GDB error message
as its value and the Python call stack backtrace at the Python
statement closest to where the GDB error occured as the traceback.

   When implementing GDB commands in Python via `gdb.Command', it is
useful to be able to throw an exception that doesn't cause a traceback
to be printed.  For example, the user may have invoked the command
incorrectly.  Use the `gdb.GdbError' exception to handle this case.
Example:

     (gdb) python
     >class HelloWorld (gdb.Command):
     >  """Greet the whole world."""
     >  def __init__ (self):
     >    super (HelloWorld, self).__init__ ("hello-world", gdb.COMMAND_OBSCURE)
     >  def invoke (self, args, from_tty):
     >    argv = gdb.string_to_argv (args)
     >    if len (argv) != 0:
     >      raise gdb.GdbError ("hello-world takes no arguments")
     >    print "Hello, World!"
     >HelloWorld ()
     >end
     (gdb) hello-world 42
     hello-world takes no arguments


File: gdb.info,  Node: Values From Inferior,  Next: Types In Python,  Prev: Exception Handling,  Up: Python API

23.2.2.3 Values From Inferior
.............................

GDB provides values it obtains from the inferior program in an object
of type `gdb.Value'.  GDB uses this object for its internal bookkeeping
of the inferior's values, and for fetching values when necessary.

   Inferior values that are simple scalars can be used directly in
Python expressions that are valid for the value's data type.  Here's an
example for an integer or floating-point value `some_val':

     bar = some_val + 2

As result of this, `bar' will also be a `gdb.Value' object whose values
are of the same type as those of `some_val'.

   Inferior values that are structures or instances of some class can
be accessed using the Python "dictionary syntax".  For example, if
`some_val' is a `gdb.Value' instance holding a structure, you can
access its `foo' element with:

     bar = some_val['foo']

   Again, `bar' will also be a `gdb.Value' object.

   A `gdb.Value' that represents a function can be executed via
inferior function call.  Any arguments provided to the call must match
the function's prototype, and must be provided in the order specified
by that prototype.

   For example, `some_val' is a `gdb.Value' instance representing a
function that takes two integers as arguments.  To execute this
function, call it like so:

     result = some_val (10,20)

   Any values returned from a function call will be stored as a
`gdb.Value'.

   The following attributes are provided:

      -- Instance Variable of Value: address
          If this object is addressable, this read-only attribute holds
          a `gdb.Value' object representing the address.  Otherwise,
          this attribute holds `None'.

      -- Instance Variable of Value: is_optimized_out
          This read-only boolean attribute is true if the compiler
          optimized out this value, thus it is not available for
          fetching from the inferior.

      -- Instance Variable of Value: type
          The type of this `gdb.Value'.  The value of this attribute is
          a `gdb.Type' object (*note Types In Python::).

      -- Instance Variable of Value: dynamic_type
          The dynamic type of this `gdb.Value'.  This uses C++ run-time
          type information (RTTI) to determine the dynamic type of the
          value.  If this value is of class type, it will return the
          class in which the value is embedded, if any.  If this value
          is of pointer or reference to a class type, it will compute
          the dynamic type of the referenced object, and return a
          pointer or reference to that type, respectively.  In all
          other cases, it will return the value's static type.

          Note that this feature will only work when debugging a C++
          program that includes RTTI for the object in question.
          Otherwise, it will just return the static type of the value
          as in `ptype foo' (*note ptype: Symbols.).

   The following methods are provided:

      -- Method on Value: __init__ VAL
          Many Python values can be converted directly to a `gdb.Value'
          via this object initializer.  Specifically:

         Python boolean
               A Python boolean is converted to the boolean type from
               the current language.

         Python integer
               A Python integer is converted to the C `long' type for
               the current architecture.

         Python long
               A Python long is converted to the C `long long' type for
               the current architecture.

         Python float
               A Python float is converted to the C `double' type for
               the current architecture.

         Python string
               A Python string is converted to a target string, using
               the current target encoding.

         `gdb.Value'
               If `val' is a `gdb.Value', then a copy of the value is
               made.

         `gdb.LazyString'
               If `val' is a `gdb.LazyString' (*note Lazy Strings In
               Python::), then the lazy string's `value' method is
               called, and its result is used.

      -- Method on Value: cast type
          Return a new instance of `gdb.Value' that is the result of
          casting this instance to the type described by TYPE, which
          must be a `gdb.Type' object.  If the cast cannot be performed
          for some reason, this method throws an exception.

      -- Method on Value: dereference
          For pointer data types, this method returns a new `gdb.Value'
          object whose contents is the object pointed to by the
          pointer.  For example, if `foo' is a C pointer to an `int',
          declared in your C program as

               int *foo;

          then you can use the corresponding `gdb.Value' to access what
          `foo' points to like this:

               bar = foo.dereference ()

          The result `bar' will be a `gdb.Value' object holding the
          value pointed to by `foo'.

      -- Method on Value: dynamic_cast type
          Like `Value.cast', but works as if the C++ `dynamic_cast'
          operator were used.  Consult a C++ reference for details.

      -- Method on Value: reinterpret_cast type
          Like `Value.cast', but works as if the C++ `reinterpret_cast'
          operator were used.  Consult a C++ reference for details.

      -- Method on Value: string [encoding] [errors] [length]
          If this `gdb.Value' represents a string, then this method
          converts the contents to a Python string.  Otherwise, this
          method will throw an exception.

          Strings are recognized in a language-specific way; whether a
          given `gdb.Value' represents a string is determined by the
          current language.

          For C-like languages, a value is a string if it is a pointer
          to or an array of characters or ints.  The string is assumed
          to be terminated by a zero of the appropriate width.  However
          if the optional length argument is given, the string will be
          converted to that given length, ignoring any embedded zeros
          that the string may contain.

          If the optional ENCODING argument is given, it must be a
          string naming the encoding of the string in the `gdb.Value',
          such as `"ascii"', `"iso-8859-6"' or `"utf-8"'.  It accepts
          the same encodings as the corresponding argument to Python's
          `string.decode' method, and the Python codec machinery will
          be used to convert the string.  If ENCODING is not given, or
          if ENCODING is the empty string, then either the
          `target-charset' (*note Character Sets::) will be used, or a
          language-specific encoding will be used, if the current
          language is able to supply one.

          The optional ERRORS argument is the same as the corresponding
          argument to Python's `string.decode' method.

          If the optional LENGTH argument is given, the string will be
          fetched and converted to the given length.

      -- Method on Value: lazy_string [encoding] [length]
          If this `gdb.Value' represents a string, then this method
          converts the contents to a `gdb.LazyString' (*note Lazy
          Strings In Python::).  Otherwise, this method will throw an
          exception.

          If the optional ENCODING argument is given, it must be a
          string naming the encoding of the `gdb.LazyString'.  Some
          examples are: `ascii', `iso-8859-6' or `utf-8'.  If the
          ENCODING argument is an encoding that GDB does recognize, GDB
          will raise an error.

          When a lazy string is printed, the GDB encoding machinery is
          used to convert the string during printing.  If the optional
          ENCODING argument is not provided, or is an empty string, GDB
          will automatically select the encoding most suitable for the
          string type.  For further information on encoding in GDB
          please see *note Character Sets::.

          If the optional LENGTH argument is given, the string will be
          fetched and encoded to the length of characters specified.  If
          the LENGTH argument is not provided, the string will be
          fetched and encoded until a null of appropriate width is
          found.


File: gdb.info,  Node: Types In Python,  Next: Pretty Printing API,  Prev: Values From Inferior,  Up: Python API

23.2.2.4 Types In Python
........................

GDB represents types from the inferior using the class `gdb.Type'.

   The following type-related functions are available in the `gdb'
module:

 -- Function: lookup_type name [block]
     This function looks up a type by name.  NAME is the name of the
     type to look up.  It must be a string.

     If BLOCK is given, then NAME is looked up in that scope.
     Otherwise, it is searched for globally.

     Ordinarily, this function will return an instance of `gdb.Type'.
     If the named type cannot be found, it will throw an exception.

   An instance of `Type' has the following attributes:

      -- Instance Variable of Type: code
          The type code for this type.  The type code will be one of the
          `TYPE_CODE_' constants defined below.

      -- Instance Variable of Type: sizeof
          The size of this type, in target `char' units.  Usually, a
          target's `char' type will be an 8-bit byte.  However, on some
          unusual platforms, this type may have a different size.

      -- Instance Variable of Type: tag
          The tag name for this type.  The tag name is the name after
          `struct', `union', or `enum' in C and C++; not all languages
          have this concept.  If this type has no tag name, then `None'
          is returned.

   The following methods are provided:

      -- Method on Type: fields
          For structure and union types, this method returns the
          fields.  Range types have two fields, the minimum and maximum
          values.  Enum types have one field per enum constant.
          Function and method types have one field per parameter.  The
          base types of C++ classes are also represented as fields.  If
          the type has no fields, or does not fit into one of these
          categories, an empty sequence will be returned.

          Each field is an object, with some pre-defined attributes:
         `bitpos'
               This attribute is not available for `static' fields (as
               in C++ or Java).  For non-`static' fields, the value is
               the bit position of the field.

         `name'
               The name of the field, or `None' for anonymous fields.

         `artificial'
               This is `True' if the field is artificial, usually
               meaning that it was provided by the compiler and not the
               user.  This attribute is always provided, and is `False'
               if the field is not artificial.

         `is_base_class'
               This is `True' if the field represents a base class of a
               C++ structure.  This attribute is always provided, and
               is `False' if the field is not a base class of the type
               that is the argument of `fields', or if that type was
               not a C++ class.

         `bitsize'
               If the field is packed, or is a bitfield, then this will
               have a non-zero value, which is the size of the field in
               bits.  Otherwise, this will be zero; in this case the
               field's size is given by its type.

         `type'
               The type of the field.  This is usually an instance of
               `Type', but it can be `None' in some situations.

      -- Method on Type: array N1 [N2]
          Return a new `gdb.Type' object which represents an array of
          this type.  If one argument is given, it is the inclusive
          upper bound of the array; in this case the lower bound is
          zero.  If two arguments are given, the first argument is the
          lower bound of the array, and the second argument is the
          upper bound of the array.  An array's length must not be
          negative, but the bounds can be.

      -- Method on Type: const
          Return a new `gdb.Type' object which represents a
          `const'-qualified variant of this type.

      -- Method on Type: volatile
          Return a new `gdb.Type' object which represents a
          `volatile'-qualified variant of this type.

      -- Method on Type: unqualified
          Return a new `gdb.Type' object which represents an unqualified
          variant of this type.  That is, the result is neither `const'
          nor `volatile'.

      -- Method on Type: range
          Return a Python `Tuple' object that contains two elements: the
          low bound of the argument type and the high bound of that
          type.  If the type does not have a range, GDB will raise a
          `gdb.error' exception (*note Exception Handling::).

      -- Method on Type: reference
          Return a new `gdb.Type' object which represents a reference
          to this type.

      -- Method on Type: pointer
          Return a new `gdb.Type' object which represents a pointer to
          this type.

      -- Method on Type: strip_typedefs
          Return a new `gdb.Type' that represents the real type, after
          removing all layers of typedefs.

      -- Method on Type: target
          Return a new `gdb.Type' object which represents the target
          type of this type.

          For a pointer type, the target type is the type of the
          pointed-to object.  For an array type (meaning C-like
          arrays), the target type is the type of the elements of the
          array.  For a function or method type, the target type is the
          type of the return value.  For a complex type, the target
          type is the type of the elements.  For a typedef, the target
          type is the aliased type.

          If the type does not have a target, this method will throw an
          exception.

      -- Method on Type: template_argument n [block]
          If this `gdb.Type' is an instantiation of a template, this
          will return a new `gdb.Type' which represents the type of the
          Nth template argument.

          If this `gdb.Type' is not a template type, this will throw an
          exception.  Ordinarily, only C++ code will have template
          types.

          If BLOCK is given, then NAME is looked up in that scope.
          Otherwise, it is searched for globally.

   Each type has a code, which indicates what category this type falls
into.  The available type categories are represented by constants
defined in the `gdb' module:

`TYPE_CODE_PTR'
     The type is a pointer.

`TYPE_CODE_ARRAY'
     The type is an array.

`TYPE_CODE_STRUCT'
     The type is a structure.

`TYPE_CODE_UNION'
     The type is a union.

`TYPE_CODE_ENUM'
     The type is an enum.

`TYPE_CODE_FLAGS'
     A bit flags type, used for things such as status registers.

`TYPE_CODE_FUNC'
     The type is a function.

`TYPE_CODE_INT'
     The type is an integer type.

`TYPE_CODE_FLT'
     A floating point type.

`TYPE_CODE_VOID'
     The special type `void'.

`TYPE_CODE_SET'
     A Pascal set type.

`TYPE_CODE_RANGE'
     A range type, that is, an integer type with bounds.

`TYPE_CODE_STRING'
     A string type.  Note that this is only used for certain languages
     with language-defined string types; C strings are not represented
     this way.

`TYPE_CODE_BITSTRING'
     A string of bits.

`TYPE_CODE_ERROR'
     An unknown or erroneous type.

`TYPE_CODE_METHOD'
     A method type, as found in C++ or Java.

`TYPE_CODE_METHODPTR'
     A pointer-to-member-function.

`TYPE_CODE_MEMBERPTR'
     A pointer-to-member.

`TYPE_CODE_REF'
     A reference type.

`TYPE_CODE_CHAR'
     A character type.

`TYPE_CODE_BOOL'
     A boolean type.

`TYPE_CODE_COMPLEX'
     A complex float type.

`TYPE_CODE_TYPEDEF'
     A typedef to some other type.

`TYPE_CODE_NAMESPACE'
     A C++ namespace.

`TYPE_CODE_DECFLOAT'
     A decimal floating point type.

`TYPE_CODE_INTERNAL_FUNCTION'
     A function internal to GDB.  This is the type used to represent
     convenience functions.

   Further support for types is provided in the `gdb.types' Python
module (*note gdb.types::).


File: gdb.info,  Node: Pretty Printing API,  Next: Selecting Pretty-Printers,  Prev: Types In Python,  Up: Python API

23.2.2.5 Pretty Printing API
............................

An example output is provided (*note Pretty Printing::).

   A pretty-printer is just an object that holds a value and implements
a specific interface, defined here.

 -- Operation on pretty printer: children (self)
     GDB will call this method on a pretty-printer to compute the
     children of the pretty-printer's value.

     This method must return an object conforming to the Python iterator
     protocol.  Each item returned by the iterator must be a tuple
     holding two elements.  The first element is the "name" of the
     child; the second element is the child's value.  The value can be
     any Python object which is convertible to a GDB value.

     This method is optional.  If it does not exist, GDB will act as
     though the value has no children.

 -- Operation on pretty printer: display_hint (self)
     The CLI may call this method and use its result to change the
     formatting of a value.  The result will also be supplied to an MI
     consumer as a `displayhint' attribute of the variable being
     printed.

     This method is optional.  If it does exist, this method must
     return a string.

     Some display hints are predefined by GDB:

    `array'
          Indicate that the object being printed is "array-like".  The
          CLI uses this to respect parameters such as `set print
          elements' and `set print array'.

    `map'
          Indicate that the object being printed is "map-like", and
          that the children of this value can be assumed to alternate
          between keys and values.

    `string'
          Indicate that the object being printed is "string-like".  If
          the printer's `to_string' method returns a Python string of
          some kind, then GDB will call its internal language-specific
          string-printing function to format the string.  For the CLI
          this means adding quotation marks, possibly escaping some
          characters, respecting `set print elements', and the like.

 -- Operation on pretty printer: to_string (self)
     GDB will call this method to display the string representation of
     the value passed to the object's constructor.

     When printing from the CLI, if the `to_string' method exists, then
     GDB will prepend its result to the values returned by `children'.
     Exactly how this formatting is done is dependent on the display
     hint, and may change as more hints are added.  Also, depending on
     the print settings (*note Print Settings::), the CLI may print
     just the result of `to_string' in a stack trace, omitting the
     result of `children'.

     If this method returns a string, it is printed verbatim.

     Otherwise, if this method returns an instance of `gdb.Value', then
     GDB prints this value.  This may result in a call to another
     pretty-printer.

     If instead the method returns a Python value which is convertible
     to a `gdb.Value', then GDB performs the conversion and prints the
     resulting value.  Again, this may result in a call to another
     pretty-printer.  Python scalars (integers, floats, and booleans)
     and strings are convertible to `gdb.Value'; other types are not.

     Finally, if this method returns `None' then no further operations
     are peformed in this method and nothing is printed.

     If the result is not one of these types, an exception is raised.

   GDB provides a function which can be used to look up the default
pretty-printer for a `gdb.Value':

 -- Function: default_visualizer value
     This function takes a `gdb.Value' object as an argument.  If a
     pretty-printer for this value exists, then it is returned.  If no
     such printer exists, then this returns `None'.


File: gdb.info,  Node: Selecting Pretty-Printers,  Next: Writing a Pretty-Printer,  Prev: Pretty Printing API,  Up: Python API

23.2.2.6 Selecting Pretty-Printers
..................................

The Python list `gdb.pretty_printers' contains an array of functions or
callable objects that have been registered via addition as a
pretty-printer.  Printers in this list are called `global' printers,
they're available when debugging all inferiors.  Each `gdb.Progspace'
contains a `pretty_printers' attribute.  Each `gdb.Objfile' also
contains a `pretty_printers' attribute.

   Each function on these lists is passed a single `gdb.Value' argument
and should return a pretty-printer object conforming to the interface
definition above (*note Pretty Printing API::).  If a function cannot
create a pretty-printer for the value, it should return `None'.

   GDB first checks the `pretty_printers' attribute of each
`gdb.Objfile' in the current program space and iteratively calls each
enabled lookup routine in the list for that `gdb.Objfile' until it
receives a pretty-printer object.  If no pretty-printer is found in the
objfile lists, GDB then searches the pretty-printer list of the current
program space, calling each enabled function until an object is
returned.  After these lists have been exhausted, it tries the global
`gdb.pretty_printers' list, again calling each enabled function until an
object is returned.

   The order in which the objfiles are searched is not specified.  For a
given list, functions are always invoked from the head of the list, and
iterated over sequentially until the end of the list, or a printer
object is returned.

   For various reasons a pretty-printer may not work.  For example, the
underlying data structure may have changed and the pretty-printer is
out of date.

   The consequences of a broken pretty-printer are severe enough that
GDB provides support for enabling and disabling individual printers.
For example, if `print frame-arguments' is on, a backtrace can become
highly illegible if any argument is printed with a broken printer.

   Pretty-printers are enabled and disabled by attaching an `enabled'
attribute to the registered function or callable object.  If this
attribute is present and its value is `False', the printer is disabled,
otherwise the printer is enabled.


File: gdb.info,  Node: Writing a Pretty-Printer,  Next: Inferiors In Python,  Prev: Selecting Pretty-Printers,  Up: Python API

23.2.2.7 Writing a Pretty-Printer
.................................

A pretty-printer consists of two parts: a lookup function to detect if
the type is supported, and the printer itself.

   Here is an example showing how a `std::string' printer might be
written.  *Note Pretty Printing API::, for details on the API this class
must provide.

     class StdStringPrinter(object):
         "Print a std::string"

         def __init__(self, val):
             self.val = val

         def to_string(self):
             return self.val['_M_dataplus']['_M_p']

         def display_hint(self):
             return 'string'

   And here is an example showing how a lookup function for the printer
example above might be written.

     def str_lookup_function(val):
         lookup_tag = val.type.tag
         if lookup_tag == None:
             return None
         regex = re.compile("^std::basic_string<char,.*>$")
         if regex.match(lookup_tag):
             return StdStringPrinter(val)
         return None

   The example lookup function extracts the value's type, and attempts
to match it to a type that it can pretty-print.  If it is a type the
printer can pretty-print, it will return a printer object.  If not, it
returns `None'.

   We recommend that you put your core pretty-printers into a Python
package.  If your pretty-printers are for use with a library, we
further recommend embedding a version number into the package name.
This practice will enable GDB to load multiple versions of your
pretty-printers at the same time, because they will have different
names.

   You should write auto-loaded code (*note Auto-loading::) such that it
can be evaluated multiple times without changing its meaning.  An ideal
auto-load file will consist solely of `import's of your printer
modules, followed by a call to a register pretty-printers with the
current objfile.

   Taken as a whole, this approach will scale nicely to multiple
inferiors, each potentially using a different library version.
Embedding a version number in the Python package name will ensure that
GDB is able to load both sets of printers simultaneously.  Then,
because the search for pretty-printers is done by objfile, and because
your auto-loaded code took care to register your library's printers
with a specific objfile, GDB will find the correct printers for the
specific version of the library used by each inferior.

   To continue the `std::string' example (*note Pretty Printing API::),
this code might appear in `gdb.libstdcxx.v6':

     def register_printers(objfile):
         objfile.pretty_printers.add(str_lookup_function)

And then the corresponding contents of the auto-load file would be:

     import gdb.libstdcxx.v6
     gdb.libstdcxx.v6.register_printers(gdb.current_objfile())

   The previous example illustrates a basic pretty-printer.  There are
a few things that can be improved on.  The printer doesn't have a name,
making it hard to identify in a list of installed printers.  The lookup
function has a name, but lookup functions can have arbitrary, even
identical, names.

   Second, the printer only handles one type, whereas a library
typically has several types.  One could install a lookup function for
each desired type in the library, but one could also have a single
lookup function recognize several types.  The latter is the
conventional way this is handled.  If a pretty-printer can handle
multiple data types, then its "subprinters" are the printers for the
individual data types.

   The `gdb.printing' module provides a formal way of solving these
problems (*note gdb.printing::).  Here is another example that handles
multiple types.

   These are the types we are going to pretty-print:

     struct foo { int a, b; };
     struct bar { struct foo x, y; };

   Here are the printers:

     class fooPrinter:
         """Print a foo object."""

         def __init__(self, val):
             self.val = val

         def to_string(self):
             return ("a=<" + str(self.val["a"]) +
                     "> b=<" + str(self.val["b"]) + ">")

     class barPrinter:
         """Print a bar object."""

         def __init__(self, val):
             self.val = val

         def to_string(self):
             return ("x=<" + str(self.val["x"]) +
                     "> y=<" + str(self.val["y"]) + ">")

   This example doesn't need a lookup function, that is handled by the
`gdb.printing' module.  Instead a function is provided to build up the
object that handles the lookup.

     import gdb.printing

     def build_pretty_printer():
         pp = gdb.printing.RegexpCollectionPrettyPrinter(
             "my_library")
         pp.add_printer('foo', '^foo$', fooPrinter)
         pp.add_printer('bar', '^bar$', barPrinter)
         return pp

   And here is the autoload support:

     import gdb.printing
     import my_library
     gdb.printing.register_pretty_printer(
         gdb.current_objfile(),
         my_library.build_pretty_printer())

   Finally, when this printer is loaded into GDB, here is the
corresponding output of `info pretty-printer':

     (gdb) info pretty-printer
     my_library.so:
       my_library
         foo
         bar


File: gdb.info,  Node: Inferiors In Python,  Next: Events In Python,  Prev: Writing a Pretty-Printer,  Up: Python API

23.2.2.8 Inferiors In Python
............................

Programs which are being run under GDB are called inferiors (*note
Inferiors and Programs::).  Python scripts can access information about
and manipulate inferiors controlled by GDB via objects of the
`gdb.Inferior' class.

   The following inferior-related functions are available in the `gdb'
module:

 -- Function: inferiors
     Return a tuple containing all inferior objects.

   A `gdb.Inferior' object has the following attributes:

      -- Instance Variable of Inferior: num
          ID of inferior, as assigned by GDB.

      -- Instance Variable of Inferior: pid
          Process ID of the inferior, as assigned by the underlying
          operating system.

      -- Instance Variable of Inferior: was_attached
          Boolean signaling whether the inferior was created using
          `attach', or started by GDB itself.

   A `gdb.Inferior' object has the following methods:

      -- Method on Inferior: is_valid
          Returns `True' if the `gdb.Inferior' object is valid, `False'
          if not.  A `gdb.Inferior' object will become invalid if the
          inferior no longer exists within GDB.  All other
          `gdb.Inferior' methods will throw an exception if it is
          invalid at the time the method is called.

      -- Method on Inferior: threads
          This method returns a tuple holding all the threads which are
          valid when it is called.  If there are no valid threads, the
          method will return an empty tuple.

      -- Method on Inferior: read_memory address length
          Read LENGTH bytes of memory from the inferior, starting at
          ADDRESS.  Returns a buffer object, which behaves much like an
          array or a string.  It can be modified and given to the
          `gdb.write_memory' function.

      -- Method on Inferior: write_memory address buffer [length]
          Write the contents of BUFFER to the inferior, starting at
          ADDRESS.  The BUFFER parameter must be a Python object which
          supports the buffer protocol, i.e., a string, an array or the
          object returned from `gdb.read_memory'.  If given, LENGTH
          determines the number of bytes from BUFFER to be written.

      -- Method on Inferior: search_memory address length pattern
          Search a region of the inferior memory starting at ADDRESS
          with the given LENGTH using the search pattern supplied in
          PATTERN.  The PATTERN parameter must be a Python object which
          supports the buffer protocol, i.e., a string, an array or the
          object returned from `gdb.read_memory'.  Returns a Python
          `Long' containing the address where the pattern was found, or
          `None' if the pattern could not be found.


File: gdb.info,  Node: Events In Python,  Next: Threads In Python,  Prev: Inferiors In Python,  Up: Python API

23.2.2.9 Events In Python
.........................

GDB provides a general event facility so that Python code can be
notified of various state changes, particularly changes that occur in
the inferior.

   An "event" is just an object that describes some state change.  The
type of the object and its attributes will vary depending on the details
of the change.  All the existing events are described below.

   In order to be notified of an event, you must register an event
handler with an "event registry".  An event registry is an object in the
`gdb.events' module which dispatches particular events.  A registry
provides methods to register and unregister event handlers:

      -- Method on EventRegistry: connect object
          Add the given callable OBJECT to the registry.  This object
          will be called when an event corresponding to this registry
          occurs.

      -- Method on EventRegistry: disconnect object
          Remove the given OBJECT from the registry.  Once removed, the
          object will no longer receive notifications of events.

   Here is an example:

     def exit_handler (event):
         print "event type: exit"
         print "exit code: %d" % (event.exit_code)

     gdb.events.exited.connect (exit_handler)

   In the above example we connect our handler `exit_handler' to the
registry `events.exited'.  Once connected, `exit_handler' gets called
when the inferior exits.  The argument "event" in this example is of
type `gdb.ExitedEvent'.  As you can see in the example the
`ExitedEvent' object has an attribute which indicates the exit code of
the inferior.

   The following is a listing of the event registries that are
available and details of the events they emit:

`events.cont'
     Emits `gdb.ThreadEvent'.

     Some events can be thread specific when GDB is running in non-stop
     mode.  When represented in Python, these events all extend
     `gdb.ThreadEvent'.  Note, this event is not emitted directly;
     instead, events which are emitted by this or other modules might
     extend this event.  Examples of these events are
     `gdb.BreakpointEvent' and `gdb.ContinueEvent'.

           -- Instance Variable of ThreadEvent: inferior_thread
               In non-stop mode this attribute will be set to the
               specific thread which was involved in the emitted event.
               Otherwise, it will be set to `None'.

     Emits `gdb.ContinueEvent' which extends `gdb.ThreadEvent'.

     This event indicates that the inferior has been continued after a
     stop. For inherited attribute refer to `gdb.ThreadEvent' above.

`events.exited'
     Emits `events.ExitedEvent' which indicates that the inferior has
     exited.  `events.ExitedEvent' has one optional attribute.  This
     attribute will exist only in the case that the inferior exited
     with some status.
           -- Instance Variable of ExitedEvent: exit_code
               An integer representing the exit code which the inferior
               has returned.

`events.stop'
     Emits `gdb.StopEvent' which extends `gdb.ThreadEvent'.

     Indicates that the inferior has stopped.  All events emitted by
     this registry extend StopEvent.  As a child of `gdb.ThreadEvent',
     `gdb.StopEvent' will indicate the stopped thread when GDB is
     running in non-stop mode.  Refer to `gdb.ThreadEvent' above for
     more details.

     Emits `gdb.SignalEvent' which extends `gdb.StopEvent'.

     This event indicates that the inferior or one of its threads has
     received as signal.  `gdb.SignalEvent' has the following
     attributes:

           -- Instance Variable of SignalEvent: stop_signal
               A string representing the signal received by the
               inferior.  A list of possible signal values can be
               obtained by running the command `info signals' in the
               GDB command prompt.

     Also emits  `gdb.BreakpointEvent' which extends `gdb.StopEvent'.

     `gdb.BreakpointEvent' event indicates that a breakpoint has been
     hit, and has the following attributes:

           -- Instance Variable of BreakpointEvent: breakpoint
               A reference to the breakpoint that was hit of type
               `gdb.Breakpoint'.  *Note Breakpoints In Python::, for
               details of the `gdb.Breakpoint' object.



File: gdb.info,  Node: Threads In Python,  Next: Commands In Python,  Prev: Events In Python,  Up: Python API

23.2.2.10 Threads In Python
...........................

Python scripts can access information about, and manipulate inferior
threads controlled by GDB, via objects of the `gdb.InferiorThread'
class.

   The following thread-related functions are available in the `gdb'
module:

 -- Function: selected_thread
     This function returns the thread object for the selected thread.
     If there is no selected thread, this will return `None'.

   A `gdb.InferiorThread' object has the following attributes:

      -- Instance Variable of InferiorThread: name
          The name of the thread.  If the user specified a name using
          `thread name', then this returns that name.  Otherwise, if an
          OS-supplied name is available, then it is returned.
          Otherwise, this returns `None'.

          This attribute can be assigned to.  The new value must be a
          string object, which sets the new name, or `None', which
          removes any user-specified thread name.

      -- Instance Variable of InferiorThread: num
          ID of the thread, as assigned by GDB.

      -- Instance Variable of InferiorThread: ptid
          ID of the thread, as assigned by the operating system.  This
          attribute is a tuple containing three integers.  The first is
          the Process ID (PID); the second is the Lightweight Process
          ID (LWPID), and the third is the Thread ID (TID).  Either the
          LWPID or TID may be 0, which indicates that the operating
          system does not  use that identifier.

   A `gdb.InferiorThread' object has the following methods:

      -- Method on InferiorThread: is_valid
          Returns `True' if the `gdb.InferiorThread' object is valid,
          `False' if not.  A `gdb.InferiorThread' object will become
          invalid if the thread exits, or the inferior that the thread
          belongs is deleted.  All other `gdb.InferiorThread' methods
          will throw an exception if it is invalid at the time the
          method is called.

      -- Method on InferiorThread: switch
          This changes GDB's currently selected thread to the one
          represented by this object.

      -- Method on InferiorThread: is_stopped
          Return a Boolean indicating whether the thread is stopped.

      -- Method on InferiorThread: is_running
          Return a Boolean indicating whether the thread is running.

      -- Method on InferiorThread: is_exited
          Return a Boolean indicating whether the thread is exited.


File: gdb.info,  Node: Commands In Python,  Next: Parameters In Python,  Prev: Threads In Python,  Up: Python API

23.2.2.11 Commands In Python
............................

You can implement new GDB CLI commands in Python.  A CLI command is
implemented using an instance of the `gdb.Command' class, most commonly
using a subclass.

 -- Method on Command: __init__ name COMMAND_CLASS [COMPLETER_CLASS]
          [PREFIX]
     The object initializer for `Command' registers the new command
     with GDB.  This initializer is normally invoked from the subclass'
     own `__init__' method.

     NAME is the name of the command.  If NAME consists of multiple
     words, then the initial words are looked for as prefix commands.
     In this case, if one of the prefix commands does not exist, an
     exception is raised.

     There is no support for multi-line commands.

     COMMAND_CLASS should be one of the `COMMAND_' constants defined
     below.  This argument tells GDB how to categorize the new command
     in the help system.

     COMPLETER_CLASS is an optional argument.  If given, it should be
     one of the `COMPLETE_' constants defined below.  This argument
     tells GDB how to perform completion for this command.  If not
     given, GDB will attempt to complete using the object's `complete'
     method (see below); if no such method is found, an error will
     occur when completion is attempted.

     PREFIX is an optional argument.  If `True', then the new command
     is a prefix command; sub-commands of this command may be
     registered.

     The help text for the new command is taken from the Python
     documentation string for the command's class, if there is one.  If
     no documentation string is provided, the default value "This
     command is not documented." is used.

 -- Method on Command: dont_repeat
     By default, a GDB command is repeated when the user enters a blank
     line at the command prompt.  A command can suppress this behavior
     by invoking the `dont_repeat' method.  This is similar to the user
     command `dont-repeat', see *note dont-repeat: Define.

 -- Method on Command: invoke argument from_tty
     This method is called by GDB when this command is invoked.

     ARGUMENT is a string.  It is the argument to the command, after
     leading and trailing whitespace has been stripped.

     FROM_TTY is a boolean argument.  When true, this means that the
     command was entered by the user at the terminal; when false it
     means that the command came from elsewhere.

     If this method throws an exception, it is turned into a GDB
     `error' call.  Otherwise, the return value is ignored.

     To break ARGUMENT up into an argv-like string use
     `gdb.string_to_argv'.  This function behaves identically to GDB's
     internal argument lexer `buildargv'.  It is recommended to use
     this for consistency.  Arguments are separated by spaces and may
     be quoted.  Example:

          print gdb.string_to_argv ("1 2\ \\\"3 '4 \"5' \"6 '7\"")
          ['1', '2 "3', '4 "5', "6 '7"]


 -- Method on Command: complete text word
     This method is called by GDB when the user attempts completion on
     this command.  All forms of completion are handled by this method,
     that is, the <TAB> and <M-?> key bindings (*note Completion::),
     and the `complete' command (*note complete: Help.).

     The arguments TEXT and WORD are both strings.  TEXT holds the
     complete command line up to the cursor's location.  WORD holds the
     last word of the command line; this is computed using a
     word-breaking heuristic.

     The `complete' method can return several values:
        * If the return value is a sequence, the contents of the
          sequence are used as the completions.  It is up to `complete'
          to ensure that the contents actually do complete the word.  A
          zero-length sequence is allowed, it means that there were no
          completions available.  Only string elements of the sequence
          are used; other elements in the sequence are ignored.

        * If the return value is one of the `COMPLETE_' constants
          defined below, then the corresponding GDB-internal completion
          function is invoked, and its result is used.

        * All other results are treated as though there were no
          available completions.

   When a new command is registered, it must be declared as a member of
some general class of commands.  This is used to classify top-level
commands in the on-line help system; note that prefix commands are not
listed under their own category but rather that of their top-level
command.  The available classifications are represented by constants
defined in the `gdb' module:

`COMMAND_NONE'
     The command does not belong to any particular class.  A command in
     this category will not be displayed in any of the help categories.

`COMMAND_RUNNING'
     The command is related to running the inferior.  For example,
     `start', `step', and `continue' are in this category.  Type `help
     running' at the GDB prompt to see a list of commands in this
     category.

`COMMAND_DATA'
     The command is related to data or variables.  For example, `call',
     `find', and `print' are in this category.  Type `help data' at the
     GDB prompt to see a list of commands in this category.

`COMMAND_STACK'
     The command has to do with manipulation of the stack.  For example,
     `backtrace', `frame', and `return' are in this category.  Type
     `help stack' at the GDB prompt to see a list of commands in this
     category.

`COMMAND_FILES'
     This class is used for file-related commands.  For example,
     `file', `list' and `section' are in this category.  Type `help
     files' at the GDB prompt to see a list of commands in this
     category.

`COMMAND_SUPPORT'
     This should be used for "support facilities", generally meaning
     things that are useful to the user when interacting with GDB, but
     not related to the state of the inferior.  For example, `help',
     `make', and `shell' are in this category.  Type `help support' at
     the GDB prompt to see a list of commands in this category.

`COMMAND_STATUS'
     The command is an `info'-related command, that is, related to the
     state of GDB itself.  For example, `info', `macro', and `show' are
     in this category.  Type `help status' at the GDB prompt to see a
     list of commands in this category.

`COMMAND_BREAKPOINTS'
     The command has to do with breakpoints.  For example, `break',
     `clear', and `delete' are in this category.  Type `help
     breakpoints' at the GDB prompt to see a list of commands in this
     category.

`COMMAND_TRACEPOINTS'
     The command has to do with tracepoints.  For example, `trace',
     `actions', and `tfind' are in this category.  Type `help
     tracepoints' at the GDB prompt to see a list of commands in this
     category.

`COMMAND_OBSCURE'
     The command is only used in unusual circumstances, or is not of
     general interest to users.  For example, `checkpoint', `fork', and
     `stop' are in this category.  Type `help obscure' at the GDB
     prompt to see a list of commands in this category.

`COMMAND_MAINTENANCE'
     The command is only useful to GDB maintainers.  The `maintenance'
     and `flushregs' commands are in this category.  Type `help
     internals' at the GDB prompt to see a list of commands in this
     category.

   A new command can use a predefined completion function, either by
specifying it via an argument at initialization, or by returning it
from the `complete' method.  These predefined completion constants are
all defined in the `gdb' module:

`COMPLETE_NONE'
     This constant means that no completion should be done.

`COMPLETE_FILENAME'
     This constant means that filename completion should be performed.

`COMPLETE_LOCATION'
     This constant means that location completion should be done.
     *Note Specify Location::.

`COMPLETE_COMMAND'
     This constant means that completion should examine GDB command
     names.

`COMPLETE_SYMBOL'
     This constant means that completion should be done using symbol
     names as the source.

   The following code snippet shows how a trivial CLI command can be
implemented in Python:

     class HelloWorld (gdb.Command):
       """Greet the whole world."""

       def __init__ (self):
         super (HelloWorld, self).__init__ ("hello-world", gdb.COMMAND_OBSCURE)

       def invoke (self, arg, from_tty):
         print "Hello, World!"

     HelloWorld ()

   The last line instantiates the class, and is necessary to trigger the
registration of the command with GDB.  Depending on how the Python code
is read into GDB, you may need to import the `gdb' module explicitly.


File: gdb.info,  Node: Parameters In Python,  Next: Functions In Python,  Prev: Commands In Python,  Up: Python API

23.2.2.12 Parameters In Python
..............................

You can implement new GDB parameters using Python.  A new parameter is
implemented as an instance of the `gdb.Parameter' class.

   Parameters are exposed to the user via the `set' and `show'
commands.  *Note Help::.

   There are many parameters that already exist and can be set in GDB.
Two examples are: `set follow fork' and `set charset'.  Setting these
parameters influences certain behavior in GDB.  Similarly, you can
define parameters that can be used to influence behavior in custom
Python scripts and commands.

 -- Method on Parameter: __init__ name COMMAND-CLASS PARAMETER-CLASS
          [ENUM-SEQUENCE]
     The object initializer for `Parameter' registers the new parameter
     with GDB.  This initializer is normally invoked from the subclass'
     own `__init__' method.

     NAME is the name of the new parameter.  If NAME consists of
     multiple words, then the initial words are looked for as prefix
     parameters.  An example of this can be illustrated with the `set
     print' set of parameters.  If NAME is `print foo', then `print'
     will be searched as the prefix parameter.  In this case the
     parameter can subsequently be accessed in GDB as `set print foo'.

     If NAME consists of multiple words, and no prefix parameter group
     can be found, an exception is raised.

     COMMAND-CLASS should be one of the `COMMAND_' constants (*note
     Commands In Python::).  This argument tells GDB how to categorize
     the new parameter in the help system.

     PARAMETER-CLASS should be one of the `PARAM_' constants defined
     below.  This argument tells GDB the type of the new parameter;
     this information is used for input validation and completion.

     If PARAMETER-CLASS is `PARAM_ENUM', then ENUM-SEQUENCE must be a
     sequence of strings.  These strings represent the possible values
     for the parameter.

     If PARAMETER-CLASS is not `PARAM_ENUM', then the presence of a
     fourth argument will cause an exception to be thrown.

     The help text for the new parameter is taken from the Python
     documentation string for the parameter's class, if there is one.
     If there is no documentation string, a default value is used.

 -- Instance Variable of Parameter: set_doc
     If this attribute exists, and is a string, then its value is used
     as the help text for this parameter's `set' command.  The value is
     examined when `Parameter.__init__' is invoked; subsequent changes
     have no effect.

 -- Instance Variable of Parameter: show_doc
     If this attribute exists, and is a string, then its value is used
     as the help text for this parameter's `show' command.  The value is
     examined when `Parameter.__init__' is invoked; subsequent changes
     have no effect.

 -- Instance Variable of Parameter: value
     The `value' attribute holds the underlying value of the parameter.
     It can be read and assigned to just as any other attribute.  GDB
     does validation when assignments are made.

   There are two methods that should be implemented in any `Parameter'
class.  These are:

 -- Operation on parameter: get_set_string self
     GDB will call this method when a PARAMETER's value has been
     changed via the `set' API (for example, `set foo off').  The
     `value' attribute has already been populated with the new value
     and may be used in output.  This method must return a string.

 -- Operation on parameter: get_show_string self svalue
     GDB will call this method when a PARAMETER's `show' API has been
     invoked (for example, `show foo').  The argument `svalue' receives
     the string representation of the current value.  This method must
     return a string.

   When a new parameter is defined, its type must be specified.  The
available types are represented by constants defined in the `gdb'
module:

`PARAM_BOOLEAN'
     The value is a plain boolean.  The Python boolean values, `True'
     and `False' are the only valid values.

`PARAM_AUTO_BOOLEAN'
     The value has three possible states: true, false, and `auto'.  In
     Python, true and false are represented using boolean constants, and
     `auto' is represented using `None'.

`PARAM_UINTEGER'
     The value is an unsigned integer.  The value of 0 should be
     interpreted to mean "unlimited".

`PARAM_INTEGER'
     The value is a signed integer.  The value of 0 should be
     interpreted to mean "unlimited".

`PARAM_STRING'
     The value is a string.  When the user modifies the string, any
     escape sequences, such as `\t', `\f', and octal escapes, are
     translated into corresponding characters and encoded into the
     current host charset.

`PARAM_STRING_NOESCAPE'
     The value is a string.  When the user modifies the string, escapes
     are passed through untranslated.

`PARAM_OPTIONAL_FILENAME'
     The value is a either a filename (a string), or `None'.

`PARAM_FILENAME'
     The value is a filename.  This is just like
     `PARAM_STRING_NOESCAPE', but uses file names for completion.

`PARAM_ZINTEGER'
     The value is an integer.  This is like `PARAM_INTEGER', except 0
     is interpreted as itself.

`PARAM_ENUM'
     The value is a string, which must be one of a collection string
     constants provided when the parameter is created.


File: gdb.info,  Node: Functions In Python,  Next: Progspaces In Python,  Prev: Parameters In Python,  Up: Python API

23.2.2.13 Writing new convenience functions
...........................................

You can implement new convenience functions (*note Convenience Vars::)
in Python.  A convenience function is an instance of a subclass of the
class `gdb.Function'.

 -- Method on Function: __init__ name
     The initializer for `Function' registers the new function with
     GDB.  The argument NAME is the name of the function, a string.
     The function will be visible to the user as a convenience variable
     of type `internal function', whose name is the same as the given
     NAME.

     The documentation for the new function is taken from the
     documentation string for the new class.

 -- Method on Function: invoke *ARGS
     When a convenience function is evaluated, its arguments are
     converted to instances of `gdb.Value', and then the function's
     `invoke' method is called.  Note that GDB does not predetermine
     the arity of convenience functions.  Instead, all available
     arguments are passed to `invoke', following the standard Python
     calling convention.  In particular, a convenience function can
     have default values for parameters without ill effect.

     The return value of this method is used as its value in the
     enclosing expression.  If an ordinary Python value is returned, it
     is converted to a `gdb.Value' following the usual rules.

   The following code snippet shows how a trivial convenience function
can be implemented in Python:

     class Greet (gdb.Function):
       """Return string to greet someone.
     Takes a name as argument."""

       def __init__ (self):
         super (Greet, self).__init__ ("greet")

       def invoke (self, name):
         return "Hello, %s!" % name.string ()

     Greet ()

   The last line instantiates the class, and is necessary to trigger the
registration of the function with GDB.  Depending on how the Python
code is read into GDB, you may need to import the `gdb' module
explicitly.


File: gdb.info,  Node: Progspaces In Python,  Next: Objfiles In Python,  Prev: Functions In Python,  Up: Python API

23.2.2.14 Program Spaces In Python
..................................

A program space, or "progspace", represents a symbolic view of an
address space.  It consists of all of the objfiles of the program.
*Note Objfiles In Python::.  *Note program spaces: Inferiors and
Programs, for more details about program spaces.

   The following progspace-related functions are available in the `gdb'
module:

 -- Function: current_progspace
     This function returns the program space of the currently selected
     inferior.  *Note Inferiors and Programs::.

 -- Function: progspaces
     Return a sequence of all the progspaces currently known to GDB.

   Each progspace is represented by an instance of the `gdb.Progspace'
class.

 -- Instance Variable of Progspace: filename
     The file name of the progspace as a string.

 -- Instance Variable of Progspace: pretty_printers
     The `pretty_printers' attribute is a list of functions.  It is
     used to look up pretty-printers.  A `Value' is passed to each
     function in order; if the function returns `None', then the search
     continues.  Otherwise, the return value should be an object which
     is used to format the value.  *Note Pretty Printing API::, for more
     information.


File: gdb.info,  Node: Objfiles In Python,  Next: Frames In Python,  Prev: Progspaces In Python,  Up: Python API

23.2.2.15 Objfiles In Python
............................

GDB loads symbols for an inferior from various symbol-containing files
(*note Files::).  These include the primary executable file, any shared
libraries used by the inferior, and any separate debug info files
(*note Separate Debug Files::).  GDB calls these symbol-containing
files "objfiles".

   The following objfile-related functions are available in the `gdb'
module:

 -- Function: current_objfile
     When auto-loading a Python script (*note Auto-loading::), GDB sets
     the "current objfile" to the corresponding objfile.  This function
     returns the current objfile.  If there is no current objfile, this
     function returns `None'.

 -- Function: objfiles
     Return a sequence of all the objfiles current known to GDB.  *Note
     Objfiles In Python::.

   Each objfile is represented by an instance of the `gdb.Objfile'
class.

 -- Instance Variable of Objfile: filename
     The file name of the objfile as a string.

 -- Instance Variable of Objfile: pretty_printers
     The `pretty_printers' attribute is a list of functions.  It is
     used to look up pretty-printers.  A `Value' is passed to each
     function in order; if the function returns `None', then the search
     continues.  Otherwise, the return value should be an object which
     is used to format the value.  *Note Pretty Printing API::, for more
     information.

   A `gdb.Objfile' object has the following methods:

 -- Method on Objfile: is_valid
     Returns `True' if the `gdb.Objfile' object is valid, `False' if
     not.  A `gdb.Objfile' object can become invalid if the object file
     it refers to is not loaded in GDB any longer.  All other
     `gdb.Objfile' methods will throw an exception if it is invalid at
     the time the method is called.


File: gdb.info,  Node: Frames In Python,  Next: Blocks In Python,  Prev: Objfiles In Python,  Up: Python API

23.2.2.16 Accessing inferior stack frames from Python.
......................................................

When the debugged program stops, GDB is able to analyze its call stack
(*note Stack frames: Frames.).  The `gdb.Frame' class represents a
frame in the stack.  A `gdb.Frame' object is only valid while its
corresponding frame exists in the inferior's stack.  If you try to use
an invalid frame object, GDB will throw a `gdb.error' exception (*note
Exception Handling::).

   Two `gdb.Frame' objects can be compared for equality with the `=='
operator, like:

     (gdb) python print gdb.newest_frame() == gdb.selected_frame ()
     True

   The following frame-related functions are available in the `gdb'
module:

 -- Function: selected_frame
     Return the selected frame object.  (*note Selecting a Frame:
     Selection.).

 -- Function: newest_frame
     Return the newest frame object for the selected thread.

 -- Function: frame_stop_reason_string reason
     Return a string explaining the reason why GDB stopped unwinding
     frames, as expressed by the given REASON code (an integer, see the
     `unwind_stop_reason' method further down in this section).

   A `gdb.Frame' object has the following methods:

      -- Method on Frame: is_valid
          Returns true if the `gdb.Frame' object is valid, false if not.
          A frame object can become invalid if the frame it refers to
          doesn't exist anymore in the inferior.  All `gdb.Frame'
          methods will throw an exception if it is invalid at the time
          the method is called.

      -- Method on Frame: name
          Returns the function name of the frame, or `None' if it can't
          be obtained.

      -- Method on Frame: type
          Returns the type of the frame.  The value can be one of:
         `gdb.NORMAL_FRAME'
               An ordinary stack frame.

         `gdb.DUMMY_FRAME'
               A fake stack frame that was created by GDB when
               performing an inferior function call.

         `gdb.INLINE_FRAME'
               A frame representing an inlined function.  The function
               was inlined into a `gdb.NORMAL_FRAME' that is older than
               this one.

         `gdb.SIGTRAMP_FRAME'
               A signal trampoline frame.  This is the frame created by
               the OS when it calls into a signal handler.

         `gdb.ARCH_FRAME'
               A fake stack frame representing a cross-architecture
               call.

         `gdb.SENTINEL_FRAME'
               This is like `gdb.NORMAL_FRAME', but it is only used for
               the newest frame.

      -- Method on Frame: unwind_stop_reason
          Return an integer representing the reason why it's not
          possible to find more frames toward the outermost frame.  Use
          `gdb.frame_stop_reason_string' to convert the value returned
          by this function to a string.

      -- Method on Frame: pc
          Returns the frame's resume address.

      -- Method on Frame: block
          Return the frame's code block.  *Note Blocks In Python::.

      -- Method on Frame: function
          Return the symbol for the function corresponding to this
          frame.  *Note Symbols In Python::.

      -- Method on Frame: older
          Return the frame that called this frame.

      -- Method on Frame: newer
          Return the frame called by this frame.

      -- Method on Frame: find_sal
          Return the frame's symtab and line object.  *Note Symbol
          Tables In Python::.

      -- Method on Frame: read_var variable [block]
          Return the value of VARIABLE in this frame.  If the optional
          argument BLOCK is provided, search for the variable from that
          block; otherwise start at the frame's current block (which is
          determined by the frame's current program counter).  VARIABLE
          must be a string or a `gdb.Symbol' object.  BLOCK must be a
          `gdb.Block' object.

      -- Method on Frame: select
          Set this frame to be the selected frame.  *Note Examining the
          Stack: Stack.


File: gdb.info,  Node: Blocks In Python,  Next: Symbols In Python,  Prev: Frames In Python,  Up: Python API

23.2.2.17 Accessing frame blocks from Python.
.............................................

Within each frame, GDB maintains information on each block stored in
that frame.  These blocks are organized hierarchically, and are
represented individually in Python as a `gdb.Block'.  Please see *note
Frames In Python::, for a more in-depth discussion on frames.
Furthermore, see *note Examining the Stack: Stack, for more detailed
technical information on GDB's book-keeping of the stack.

   The following block-related functions are available in the `gdb'
module:

 -- Function: block_for_pc pc
     Return the `gdb.Block' containing the given PC value.  If the
     block cannot be found for the PC value specified, the function
     will return `None'.

   A `gdb.Block' object has the following methods:

      -- Method on Block: is_valid
          Returns `True' if the `gdb.Block' object is valid, `False' if
          not.  A block object can become invalid if the block it
          refers to doesn't exist anymore in the inferior.  All other
          `gdb.Block' methods will throw an exception if it is invalid
          at the time the method is called.  This method is also made
          available to the Python iterator object that `gdb.Block'
          provides in an iteration context and via the Python `iter'
          built-in function.

   A `gdb.Block' object has the following attributes:

      -- Instance Variable of Block: start
          The start address of the block.  This attribute is not
          writable.

      -- Instance Variable of Block: end
          The end address of the block.  This attribute is not writable.

      -- Instance Variable of Block: function
          The name of the block represented as a `gdb.Symbol'.  If the
          block is not named, then this attribute holds `None'.  This
          attribute is not writable.

      -- Instance Variable of Block: superblock
          The block containing this block.  If this parent block does
          not exist, this attribute holds `None'.  This attribute is
          not writable.


File: gdb.info,  Node: Symbols In Python,  Next: Symbol Tables In Python,  Prev: Blocks In Python,  Up: Python API

23.2.2.18 Python representation of Symbols.
...........................................

GDB represents every variable, function and type as an entry in a
symbol table.  *Note Examining the Symbol Table: Symbols.  Similarly,
Python represents these symbols in GDB with the `gdb.Symbol' object.

   The following symbol-related functions are available in the `gdb'
module:

 -- Function: lookup_symbol name [block] [domain]
     This function searches for a symbol by name.  The search scope can
     be restricted to the parameters defined in the optional domain and
     block arguments.

     NAME is the name of the symbol.  It must be a string.  The
     optional BLOCK argument restricts the search to symbols visible in
     that BLOCK.  The BLOCK argument must be a `gdb.Block' object.  If
     omitted, the block for the current frame is used.  The optional
     DOMAIN argument restricts the search to the domain type.  The
     DOMAIN argument must be a domain constant defined in the `gdb'
     module and described later in this chapter.

     The result is a tuple of two elements.  The first element is a
     `gdb.Symbol' object or `None' if the symbol is not found.  If the
     symbol is found, the second element is `True' if the symbol is a
     field of a method's object (e.g., `this' in C++), otherwise it is
     `False'.  If the symbol is not found, the second element is
     `False'.

 -- Function: lookup_global_symbol name [domain]
     This function searches for a global symbol by name.  The search
     scope can be restricted to by the domain argument.

     NAME is the name of the symbol.  It must be a string.  The
     optional DOMAIN argument restricts the search to the domain type.
     The DOMAIN argument must be a domain constant defined in the `gdb'
     module and described later in this chapter.

     The result is a `gdb.Symbol' object or `None' if the symbol is not
     found.

   A `gdb.Symbol' object has the following attributes:

      -- Instance Variable of Symbol: symtab
          The symbol table in which the symbol appears.  This attribute
          is represented as a `gdb.Symtab' object.  *Note Symbol Tables
          In Python::.  This attribute is not writable.

      -- Instance Variable of Symbol: name
          The name of the symbol as a string.  This attribute is not
          writable.

      -- Instance Variable of Symbol: linkage_name
          The name of the symbol, as used by the linker (i.e., may be
          mangled).  This attribute is not writable.

      -- Instance Variable of Symbol: print_name
          The name of the symbol in a form suitable for output.  This
          is either `name' or `linkage_name', depending on whether the
          user asked GDB to display demangled or mangled names.

      -- Instance Variable of Symbol: addr_class
          The address class of the symbol.  This classifies how to find
          the value of a symbol.  Each address class is a constant
          defined in the `gdb' module and described later in this
          chapter.

      -- Instance Variable of Symbol: is_argument
          `True' if the symbol is an argument of a function.

      -- Instance Variable of Symbol: is_constant
          `True' if the symbol is a constant.

      -- Instance Variable of Symbol: is_function
          `True' if the symbol is a function or a method.

      -- Instance Variable of Symbol: is_variable
          `True' if the symbol is a variable.

   A `gdb.Symbol' object has the following methods:

      -- Method on Symbol: is_valid
          Returns `True' if the `gdb.Symbol' object is valid, `False'
          if not.  A `gdb.Symbol' object can become invalid if the
          symbol it refers to does not exist in GDB any longer.  All
          other `gdb.Symbol' methods will throw an exception if it is
          invalid at the time the method is called.

   The available domain categories in `gdb.Symbol' are represented as
constants in the `gdb' module:

`SYMBOL_UNDEF_DOMAIN'
     This is used when a domain has not been discovered or none of the
     following domains apply.  This usually indicates an error either
     in the symbol information or in GDB's handling of symbols.  

`SYMBOL_VAR_DOMAIN'
     This domain contains variables, function names, typedef names and
     enum type values.  

`SYMBOL_STRUCT_DOMAIN'
     This domain holds struct, union and enum type names.  

`SYMBOL_LABEL_DOMAIN'
     This domain contains names of labels (for gotos).  

`SYMBOL_VARIABLES_DOMAIN'
     This domain holds a subset of the `SYMBOLS_VAR_DOMAIN'; it
     contains everything minus functions and types.  

`SYMBOL_FUNCTION_DOMAIN'
     This domain contains all functions.  

`SYMBOL_TYPES_DOMAIN'
     This domain contains all types.

   The available address class categories in `gdb.Symbol' are
represented as constants in the `gdb' module:

`SYMBOL_LOC_UNDEF'
     If this is returned by address class, it indicates an error either
     in the symbol information or in GDB's handling of symbols.  

`SYMBOL_LOC_CONST'
     Value is constant int.  

`SYMBOL_LOC_STATIC'
     Value is at a fixed address.  

`SYMBOL_LOC_REGISTER'
     Value is in a register.  

`SYMBOL_LOC_ARG'
     Value is an argument.  This value is at the offset stored within
     the symbol inside the frame's argument list.  

`SYMBOL_LOC_REF_ARG'
     Value address is stored in the frame's argument list.  Just like
     `LOC_ARG' except that the value's address is stored at the offset,
     not the value itself.  

`SYMBOL_LOC_REGPARM_ADDR'
     Value is a specified register.  Just like `LOC_REGISTER' except
     the register holds the address of the argument instead of the
     argument itself.  

`SYMBOL_LOC_LOCAL'
     Value is a local variable.  

`SYMBOL_LOC_TYPEDEF'
     Value not used.  Symbols in the domain `SYMBOL_STRUCT_DOMAIN' all
     have this class.  

`SYMBOL_LOC_BLOCK'
     Value is a block.  

`SYMBOL_LOC_CONST_BYTES'
     Value is a byte-sequence.  

`SYMBOL_LOC_UNRESOLVED'
     Value is at a fixed address, but the address of the variable has
     to be determined from the minimal symbol table whenever the
     variable is referenced.  

`SYMBOL_LOC_OPTIMIZED_OUT'
     The value does not actually exist in the program.  

`SYMBOL_LOC_COMPUTED'
     The value's address is a computed location.


File: gdb.info,  Node: Symbol Tables In Python,  Next: Lazy Strings In Python,  Prev: Symbols In Python,  Up: Python API

23.2.2.19 Symbol table representation in Python.
................................................

Access to symbol table data maintained by GDB on the inferior is
exposed to Python via two objects: `gdb.Symtab_and_line' and
`gdb.Symtab'.  Symbol table and line data for a frame is returned from
the `find_sal' method in `gdb.Frame' object.  *Note Frames In Python::.

   For more information on GDB's symbol table management, see *note
Examining the Symbol Table: Symbols, for more information.

   A `gdb.Symtab_and_line' object has the following attributes:

      -- Instance Variable of Symtab_and_line: symtab
          The symbol table object (`gdb.Symtab') for this frame.  This
          attribute is not writable.

      -- Instance Variable of Symtab_and_line: pc
          Indicates the current program counter address.  This
          attribute is not writable.

      -- Instance Variable of Symtab_and_line: line
          Indicates the current line number for this object.  This
          attribute is not writable.

   A `gdb.Symtab_and_line' object has the following methods:

      -- Method on Symtab_and_line: is_valid
          Returns `True' if the `gdb.Symtab_and_line' object is valid,
          `False' if not.  A `gdb.Symtab_and_line' object can become
          invalid if the Symbol table and line object it refers to does
          not exist in GDB any longer.  All other `gdb.Symtab_and_line'
          methods will throw an exception if it is invalid at the time
          the method is called.

   A `gdb.Symtab' object has the following attributes:

      -- Instance Variable of Symtab: filename
          The symbol table's source filename.  This attribute is not
          writable.

      -- Instance Variable of Symtab: objfile
          The symbol table's backing object file.  *Note Objfiles In
          Python::.  This attribute is not writable.

   A `gdb.Symtab' object has the following methods:

      -- Method on Symtab: is_valid
          Returns `True' if the `gdb.Symtab' object is valid, `False'
          if not.  A `gdb.Symtab' object can become invalid if the
          symbol table it refers to does not exist in GDB any longer.
          All other `gdb.Symtab' methods will throw an exception if it
          is invalid at the time the method is called.

      -- Method on Symtab: fullname
          Return the symbol table's source absolute file name.


File: gdb.info,  Node: Breakpoints In Python,  Prev: Lazy Strings In Python,  Up: Python API

23.2.2.20 Manipulating breakpoints using Python
...............................................

Python code can manipulate breakpoints via the `gdb.Breakpoint' class.

 -- Method on Breakpoint: __init__ spec [type] [wp_class] [internal]
     Create a new breakpoint.  SPEC is a string naming the location of
     the breakpoint, or an expression that defines a watchpoint.  The
     contents can be any location recognized by the `break' command, or
     in the case of a watchpoint, by the `watch' command.  The optional
     TYPE denotes the breakpoint to create from the types defined later
     in this chapter.  This argument can be either: `BP_BREAKPOINT' or
     `BP_WATCHPOINT'.  TYPE defaults to `BP_BREAKPOINT'.  The optional
     INTERNAL argument allows the breakpoint to become invisible to the
     user.  The breakpoint will neither be reported when created, nor
     will it be listed in the output from `info breakpoints' (but will
     be listed with the `maint info breakpoints' command).  The
     optional WP_CLASS argument defines the class of watchpoint to
     create, if TYPE is `BP_WATCHPOINT'.  If a watchpoint class is not
     provided, it is assumed to be a WP_WRITE class.

 -- Operation on gdb.Breakpoint: stop (self)
     The `gdb.Breakpoint' class can be sub-classed and, in particular,
     you may choose to implement the `stop' method.  If this method is
     defined as a sub-class of `gdb.Breakpoint', it will be called when
     the inferior reaches any location of a breakpoint which
     instantiates that sub-class.  If the method returns `True', the
     inferior will be stopped at the location of the breakpoint,
     otherwise the inferior will continue.

     If there are multiple breakpoints at the same location with a
     `stop' method, each one will be called regardless of the return
     status of the previous.  This ensures that all `stop' methods have
     a chance to execute at that location.  In this scenario if one of
     the methods returns `True' but the others return `False', the
     inferior will still be stopped.

     Example `stop' implementation:

          class MyBreakpoint (gdb.Breakpoint):
                def stop (self):
                  inf_val = gdb.parse_and_eval("foo")
                  if inf_val == 3:
                    return True
                  return False

   The available watchpoint types represented by constants are defined
in the `gdb' module:

`WP_READ'
     Read only watchpoint.

`WP_WRITE'
     Write only watchpoint.

`WP_ACCESS'
     Read/Write watchpoint.

 -- Method on Breakpoint: is_valid
     Return `True' if this `Breakpoint' object is valid, `False'
     otherwise.  A `Breakpoint' object can become invalid if the user
     deletes the breakpoint.  In this case, the object still exists,
     but the underlying breakpoint does not.  In the cases of
     watchpoint scope, the watchpoint remains valid even if execution
     of the inferior leaves the scope of that watchpoint.

 -- Method on Breakpoint: delete
     Permanently deletes the GDB breakpoint.  This also invalidates the
     Python `Breakpoint' object.  Any further access to this object's
     attributes or methods will raise an error.

 -- Instance Variable of Breakpoint: enabled
     This attribute is `True' if the breakpoint is enabled, and `False'
     otherwise.  This attribute is writable.

 -- Instance Variable of Breakpoint: silent
     This attribute is `True' if the breakpoint is silent, and `False'
     otherwise.  This attribute is writable.

     Note that a breakpoint can also be silent if it has commands and
     the first command is `silent'.  This is not reported by the
     `silent' attribute.

 -- Instance Variable of Breakpoint: thread
     If the breakpoint is thread-specific, this attribute holds the
     thread id.  If the breakpoint is not thread-specific, this
     attribute is `None'.  This attribute is writable.

 -- Instance Variable of Breakpoint: task
     If the breakpoint is Ada task-specific, this attribute holds the
     Ada task id.  If the breakpoint is not task-specific (or the
     underlying language is not Ada), this attribute is `None'.  This
     attribute is writable.

 -- Instance Variable of Breakpoint: ignore_count
     This attribute holds the ignore count for the breakpoint, an
     integer.  This attribute is writable.

 -- Instance Variable of Breakpoint: number
     This attribute holds the breakpoint's number -- the identifier
     used by the user to manipulate the breakpoint.  This attribute is
     not writable.

 -- Instance Variable of Breakpoint: type
     This attribute holds the breakpoint's type -- the identifier used
     to determine the actual breakpoint type or use-case.  This
     attribute is not writable.

 -- Instance Variable of Breakpoint: visible
     This attribute tells whether the breakpoint is visible to the user
     when set, or when the `info breakpoints' command is run.  This
     attribute is not writable.

   The available types are represented by constants defined in the `gdb'
module:

`BP_BREAKPOINT'
     Normal code breakpoint.

`BP_WATCHPOINT'
     Watchpoint breakpoint.

`BP_HARDWARE_WATCHPOINT'
     Hardware assisted watchpoint.

`BP_READ_WATCHPOINT'
     Hardware assisted read watchpoint.

`BP_ACCESS_WATCHPOINT'
     Hardware assisted access watchpoint.

 -- Instance Variable of Breakpoint: hit_count
     This attribute holds the hit count for the breakpoint, an integer.
     This attribute is writable, but currently it can only be set to
     zero.

 -- Instance Variable of Breakpoint: location
     This attribute holds the location of the breakpoint, as specified
     by the user.  It is a string.  If the breakpoint does not have a
     location (that is, it is a watchpoint) the attribute's value is
     `None'.  This attribute is not writable.

 -- Instance Variable of Breakpoint: expression
     This attribute holds a breakpoint expression, as specified by the
     user.  It is a string.  If the breakpoint does not have an
     expression (the breakpoint is not a watchpoint) the attribute's
     value is `None'.  This attribute is not writable.

 -- Instance Variable of Breakpoint: condition
     This attribute holds the condition of the breakpoint, as specified
     by the user.  It is a string.  If there is no condition, this
     attribute's value is `None'.  This attribute is writable.

 -- Instance Variable of Breakpoint: commands
     This attribute holds the commands attached to the breakpoint.  If
     there are commands, this attribute's value is a string holding all
     the commands, separated by newlines.  If there are no commands,
     this attribute is `None'.  This attribute is not writable.


File: gdb.info,  Node: Lazy Strings In Python,  Next: Breakpoints In Python,  Prev: Symbol Tables In Python,  Up: Python API

23.2.2.21 Python representation of lazy strings.
................................................

A "lazy string" is a string whose contents is not retrieved or encoded
until it is needed.

   A `gdb.LazyString' is represented in GDB as an `address' that points
to a region of memory, an `encoding' that will be used to encode that
region of memory, and a `length' to delimit the region of memory that
represents the string.  The difference between a `gdb.LazyString' and a
string wrapped within a `gdb.Value' is that a `gdb.LazyString' will be
treated differently by GDB when printing.  A `gdb.LazyString' is
retrieved and encoded during printing, while a `gdb.Value' wrapping a
string is immediately retrieved and encoded on creation.

   A `gdb.LazyString' object has the following functions:

 -- Method on LazyString: value
     Convert the `gdb.LazyString' to a `gdb.Value'.  This value will
     point to the string in memory, but will lose all the delayed
     retrieval, encoding and handling that GDB applies to a
     `gdb.LazyString'.

 -- Instance Variable of LazyString: address
     This attribute holds the address of the string.  This attribute is
     not writable.

 -- Instance Variable of LazyString: length
     This attribute holds the length of the string in characters.  If
     the length is -1, then the string will be fetched and encoded up
     to the first null of appropriate width.  This attribute is not
     writable.

 -- Instance Variable of LazyString: encoding
     This attribute holds the encoding that will be applied to the
     string when the string is printed by GDB.  If the encoding is not
     set, or contains an empty string,  then GDB will select the most
     appropriate encoding when the string is printed.  This attribute
     is not writable.

 -- Instance Variable of LazyString: type
     This attribute holds the type that is represented by the lazy
     string's type.  For a lazy string this will always be a pointer
     type.  To resolve this to the lazy string's character type, use
     the type's `target' method.  *Note Types In Python::.  This
     attribute is not writable.


File: gdb.info,  Node: Auto-loading,  Next: Python modules,  Prev: Python API,  Up: Python

23.2.3 Auto-loading
-------------------

When a new object file is read (for example, due to the `file' command,
or because the inferior has loaded a shared library), GDB will look for
Python support scripts in several ways: `OBJFILE-gdb.py' and
`.debug_gdb_scripts' section.

* Menu:

* objfile-gdb.py file::         The `OBJFILE-gdb.py' file
* .debug_gdb_scripts section::  The `.debug_gdb_scripts' section
* Which flavor to choose?::

   The auto-loading feature is useful for supplying application-specific
debugging commands and scripts.

   Auto-loading can be enabled or disabled.

`set auto-load-scripts [yes|no]'
     Enable or disable the auto-loading of Python scripts.

`show auto-load-scripts'
     Show whether auto-loading of Python scripts is enabled or disabled.

   When reading an auto-loaded file, GDB sets the "current objfile".
This is available via the `gdb.current_objfile' function (*note
Objfiles In Python::).  This can be useful for registering
objfile-specific pretty-printers.


File: gdb.info,  Node: objfile-gdb.py file,  Next: .debug_gdb_scripts section,  Up: Auto-loading

23.2.3.1 The `OBJFILE-gdb.py' file
..................................

When a new object file is read, GDB looks for a file named
`OBJFILE-gdb.py', where OBJFILE is the object file's real name, formed
by ensuring that the file name is absolute, following all symlinks, and
resolving `.' and `..' components.  If this file exists and is
readable, GDB will evaluate it as a Python script.

   If this file does not exist, and if the parameter
`debug-file-directory' is set (*note Separate Debug Files::), then GDB
will look for REAL-NAME in all of the directories mentioned in the
value of `debug-file-directory'.

   Finally, if this file does not exist, then GDB will look for a file
named `DATA-DIRECTORY/python/auto-load/REAL-NAME', where DATA-DIRECTORY
is GDB's data directory (available via `show data-directory', *note
Data Files::), and REAL-NAME is the object file's real name, as
described above.

   GDB does not track which files it has already auto-loaded this way.
GDB will load the associated script every time the corresponding
OBJFILE is opened.  So your `-gdb.py' file should be careful to avoid
errors if it is evaluated more than once.


File: gdb.info,  Node: .debug_gdb_scripts section,  Next: Which flavor to choose?,  Prev: objfile-gdb.py file,  Up: Auto-loading

23.2.3.2 The `.debug_gdb_scripts' section
.........................................

For systems using file formats like ELF and COFF, when GDB loads a new
object file it will look for a special section named
`.debug_gdb_scripts'.  If this section exists, its contents is a list
of names of scripts to load.

   GDB will look for each specified script file first in the current
directory and then along the source search path (*note Specifying
Source Directories: Source Path.), except that `$cdir' is not searched,
since the compilation directory is not relevant to scripts.

   Entries can be placed in section `.debug_gdb_scripts' with, for
example, this GCC macro:

     /* Note: The "MS" section flags are to remove duplicates.  */
     #define DEFINE_GDB_SCRIPT(script_name) \
       asm("\
     .pushsection \".debug_gdb_scripts\", \"MS\",@progbits,1\n\
     .byte 1\n\
     .asciz \"" script_name "\"\n\
     .popsection \n\
     ");

Then one can reference the macro in a header or source file like this:

     DEFINE_GDB_SCRIPT ("my-app-scripts.py")

   The script name may include directories if desired.

   If the macro is put in a header, any application or library using
this header will get a reference to the specified script.


File: gdb.info,  Node: Which flavor to choose?,  Prev: .debug_gdb_scripts section,  Up: Auto-loading

23.2.3.3 Which flavor to choose?
................................

Given the multiple ways of auto-loading Python scripts, it might not
always be clear which one to choose.  This section provides some
guidance.

   Benefits of the `-gdb.py' way:

   * Can be used with file formats that don't support multiple sections.

   * Ease of finding scripts for public libraries.

     Scripts specified in the `.debug_gdb_scripts' section are searched
     for in the source search path.  For publicly installed libraries,
     e.g., `libstdc++', there typically isn't a source directory in
     which to find the script.

   * Doesn't require source code additions.

   Benefits of the `.debug_gdb_scripts' way:

   * Works with static linking.

     Scripts for libraries done the `-gdb.py' way require an objfile to
     trigger their loading.  When an application is statically linked
     the only objfile available is the executable, and it is cumbersome
     to attach all the scripts from all the input libraries to the
     executable's `-gdb.py' script.

   * Works with classes that are entirely inlined.

     Some classes can be entirely inlined, and thus there may not be an
     associated shared library to attach a `-gdb.py' script to.

   * Scripts needn't be copied out of the source tree.

     In some circumstances, apps can be built out of large collections
     of internal libraries, and the build infrastructure necessary to
     install the `-gdb.py' scripts in a place where GDB can find them is
     cumbersome.  It may be easier to specify the scripts in the
     `.debug_gdb_scripts' section as relative paths, and add a path to
     the top of the source tree to the source search path.


File: gdb.info,  Node: Python modules,  Prev: Auto-loading,  Up: Python

23.2.4 Python modules
---------------------

GDB comes with a module to assist writing Python code.

* Menu:

* gdb.printing::       Building and registering pretty-printers.
* gdb.types::          Utilities for working with types.


File: gdb.info,  Node: gdb.printing,  Next: gdb.types,  Up: Python modules

23.2.4.1 gdb.printing
.....................

This module provides a collection of utilities for working with
pretty-printers.

`PrettyPrinter (NAME, SUBPRINTERS=None)'
     This class specifies the API that makes `info pretty-printer',
     `enable pretty-printer' and `disable pretty-printer' work.
     Pretty-printers should generally inherit from this class.

`SubPrettyPrinter (NAME)'
     For printers that handle multiple types, this class specifies the
     corresponding API for the subprinters.

`RegexpCollectionPrettyPrinter (NAME)'
     Utility class for handling multiple printers, all recognized via
     regular expressions.  *Note Writing a Pretty-Printer::, for an
     example.

`register_pretty_printer (OBJ, PRINTER)'
     Register PRINTER with the pretty-printer list of OBJ.


File: gdb.info,  Node: gdb.types,  Prev: gdb.printing,  Up: Python modules

23.2.4.2 gdb.types
..................

This module provides a collection of utilities for working with
`gdb.Types' objects.

`get_basic_type (TYPE)'
     Return TYPE with const and volatile qualifiers stripped, and with
     typedefs and C++ references converted to the underlying type.

     C++ example:

          typedef const int const_int;
          const_int foo (3);
          const_int& foo_ref (foo);
          int main () { return 0; }

     Then in gdb:

          (gdb) start
          (gdb) python import gdb.types
          (gdb) python foo_ref = gdb.parse_and_eval("foo_ref")
          (gdb) python print gdb.types.get_basic_type(foo_ref.type)
          int

`has_field (TYPE, FIELD)'
     Return `True' if TYPE, assumed to be a type with fields (e.g., a
     structure or union), has field FIELD.

`make_enum_dict (ENUM_TYPE)'
     Return a Python `dictionary' type produced from ENUM_TYPE.


File: gdb.info,  Node: Interpreters,  Next: TUI,  Prev: Extending GDB,  Up: Top

24 Command Interpreters
***********************

GDB supports multiple command interpreters, and some command
infrastructure to allow users or user interface writers to switch
between interpreters or run commands in other interpreters.

   GDB currently supports two command interpreters, the console
interpreter (sometimes called the command-line interpreter or CLI) and
the machine interface interpreter (or GDB/MI).  This manual describes
both of these interfaces in great detail.

   By default, GDB will start with the console interpreter.  However,
the user may choose to start GDB with another interpreter by specifying
the `-i' or `--interpreter' startup options.  Defined interpreters
include:

`console'
     The traditional console or command-line interpreter.  This is the
     most often used interpreter with GDB. With no interpreter
     specified at runtime, GDB will use this interpreter.

`mi'
     The newest GDB/MI interface (currently `mi2').  Used primarily by
     programs wishing to use GDB as a backend for a debugger GUI or an
     IDE.  For more information, see *note The GDB/MI Interface: GDB/MI.

`mi2'
     The current GDB/MI interface.

`mi1'
     The GDB/MI interface included in GDB 5.1, 5.2, and 5.3.


   The interpreter being used by GDB may not be dynamically switched at
runtime.  Although possible, this could lead to a very precarious
situation.  Consider an IDE using GDB/MI.  If a user enters the command
"interpreter-set console" in a console view, GDB would switch to using
the console interpreter, rendering the IDE inoperable!

   Although you may only choose a single interpreter at startup, you
may execute commands in any interpreter from the current interpreter
using the appropriate command.  If you are running the console
interpreter, simply use the `interpreter-exec' command:

     interpreter-exec mi "-data-list-register-names"

   GDB/MI has a similar command, although it is only available in
versions of GDB which support GDB/MI version 2 (or greater).


File: gdb.info,  Node: TUI,  Next: Emacs,  Prev: Interpreters,  Up: Top

25 GDB Text User Interface
**************************

* Menu:

* TUI Overview::                TUI overview
* TUI Keys::                    TUI key bindings
* TUI Single Key Mode::         TUI single key mode
* TUI Commands::                TUI-specific commands
* TUI Configuration::           TUI configuration variables

   The GDB Text User Interface (TUI) is a terminal interface which uses
the `curses' library to show the source file, the assembly output, the
program registers and GDB commands in separate text windows.  The TUI
mode is supported only on platforms where a suitable version of the
`curses' library is available.

   The TUI mode is enabled by default when you invoke GDB as either
`gdbtui' or `gdb -tui'.  You can also switch in and out of TUI mode
while GDB runs by using various TUI commands and key bindings, such as
`C-x C-a'.  *Note TUI Key Bindings: TUI Keys.


File: gdb.info,  Node: TUI Overview,  Next: TUI Keys,  Up: TUI

25.1 TUI Overview
=================

In TUI mode, GDB can display several text windows:

_command_
     This window is the GDB command window with the GDB prompt and the
     GDB output.  The GDB input is still managed using readline.

_source_
     The source window shows the source file of the program.  The
     current line and active breakpoints are displayed in this window.

_assembly_
     The assembly window shows the disassembly output of the program.

_register_
     This window shows the processor registers.  Registers are
     highlighted when their values change.

   The source and assembly windows show the current program position by
highlighting the current line and marking it with a `>' marker.
Breakpoints are indicated with two markers.  The first marker indicates
the breakpoint type:

`B'
     Breakpoint which was hit at least once.

`b'
     Breakpoint which was never hit.

`H'
     Hardware breakpoint which was hit at least once.

`h'
     Hardware breakpoint which was never hit.

   The second marker indicates whether the breakpoint is enabled or not:

`+'
     Breakpoint is enabled.

`-'
     Breakpoint is disabled.

   The source, assembly and register windows are updated when the
current thread changes, when the frame changes, or when the program
counter changes.

   These windows are not all visible at the same time.  The command
window is always visible.  The others can be arranged in several
layouts:

   * source only,

   * assembly only,

   * source and assembly,

   * source and registers, or

   * assembly and registers.

   A status line above the command window shows the following
information:

_target_
     Indicates the current GDB target.  (*note Specifying a Debugging
     Target: Targets.).

_process_
     Gives the current process or thread number.  When no process is
     being debugged, this field is set to `No process'.

_function_
     Gives the current function name for the selected frame.  The name
     is demangled if demangling is turned on (*note Print Settings::).
     When there is no symbol corresponding to the current program
     counter, the string `??' is displayed.

_line_
     Indicates the current line number for the selected frame.  When
     the current line number is not known, the string `??' is displayed.

_pc_
     Indicates the current program counter address.


File: gdb.info,  Node: TUI Keys,  Next: TUI Single Key Mode,  Prev: TUI Overview,  Up: TUI

25.2 TUI Key Bindings
=====================

The TUI installs several key bindings in the readline keymaps (*note
Command Line Editing::).  The following key bindings are installed for
both TUI mode and the GDB standard mode.

`C-x C-a'
`C-x a'
`C-x A'
     Enter or leave the TUI mode.  When leaving the TUI mode, the
     curses window management stops and GDB operates using its standard
     mode, writing on the terminal directly.  When reentering the TUI
     mode, control is given back to the curses windows.  The screen is
     then refreshed.

`C-x 1'
     Use a TUI layout with only one window.  The layout will either be
     `source' or `assembly'.  When the TUI mode is not active, it will
     switch to the TUI mode.

     Think of this key binding as the Emacs `C-x 1' binding.

`C-x 2'
     Use a TUI layout with at least two windows.  When the current
     layout already has two windows, the next layout with two windows
     is used.  When a new layout is chosen, one window will always be
     common to the previous layout and the new one.

     Think of it as the Emacs `C-x 2' binding.

`C-x o'
     Change the active window.  The TUI associates several key bindings
     (like scrolling and arrow keys) with the active window.  This
     command gives the focus to the next TUI window.

     Think of it as the Emacs `C-x o' binding.

`C-x s'
     Switch in and out of the TUI SingleKey mode that binds single keys
     to GDB commands (*note TUI Single Key Mode::).

   The following key bindings only work in the TUI mode:

<PgUp>
     Scroll the active window one page up.

<PgDn>
     Scroll the active window one page down.

<Up>
     Scroll the active window one line up.

<Down>
     Scroll the active window one line down.

<Left>
     Scroll the active window one column left.

<Right>
     Scroll the active window one column right.

`C-L'
     Refresh the screen.

   Because the arrow keys scroll the active window in the TUI mode, they
are not available for their normal use by readline unless the command
window has the focus.  When another window is active, you must use
other readline key bindings such as `C-p', `C-n', `C-b' and `C-f' to
control the command window.


File: gdb.info,  Node: TUI Single Key Mode,  Next: TUI Commands,  Prev: TUI Keys,  Up: TUI

25.3 TUI Single Key Mode
========================

The TUI also provides a "SingleKey" mode, which binds several
frequently used GDB commands to single keys.  Type `C-x s' to switch
into this mode, where the following key bindings are used:

`c'
     continue

`d'
     down

`f'
     finish

`n'
     next

`q'
     exit the SingleKey mode.

`r'
     run

`s'
     step

`u'
     up

`v'
     info locals

`w'
     where

   Other keys temporarily switch to the GDB command prompt.  The key
that was pressed is inserted in the editing buffer so that it is
possible to type most GDB commands without interaction with the TUI
SingleKey mode.  Once the command is entered the TUI SingleKey mode is
restored.  The only way to permanently leave this mode is by typing `q'
or `C-x s'.


File: gdb.info,  Node: TUI Commands,  Next: TUI Configuration,  Prev: TUI Single Key Mode,  Up: TUI

25.4 TUI-specific Commands
==========================

The TUI has specific commands to control the text windows.  These
commands are always available, even when GDB is not in the TUI mode.
When GDB is in the standard mode, most of these commands will
automatically switch to the TUI mode.

   Note that if GDB's `stdout' is not connected to a terminal, or GDB
has been started with the machine interface interpreter (*note The
GDB/MI Interface: GDB/MI.), most of these commands will fail with an
error, because it would not be possible or desirable to enable curses
window management.

`info win'
     List and give the size of all displayed windows.

`layout next'
     Display the next layout.

`layout prev'
     Display the previous layout.

`layout src'
     Display the source window only.

`layout asm'
     Display the assembly window only.

`layout split'
     Display the source and assembly window.

`layout regs'
     Display the register window together with the source or assembly
     window.

`focus next'
     Make the next window active for scrolling.

`focus prev'
     Make the previous window active for scrolling.

`focus src'
     Make the source window active for scrolling.

`focus asm'
     Make the assembly window active for scrolling.

`focus regs'
     Make the register window active for scrolling.

`focus cmd'
     Make the command window active for scrolling.

`refresh'
     Refresh the screen.  This is similar to typing `C-L'.

`tui reg float'
     Show the floating point registers in the register window.

`tui reg general'
     Show the general registers in the register window.

`tui reg next'
     Show the next register group.  The list of register groups as well
     as their order is target specific.  The predefined register groups
     are the following: `general', `float', `system', `vector', `all',
     `save', `restore'.

`tui reg system'
     Show the system registers in the register window.

`update'
     Update the source window and the current execution point.

`winheight NAME +COUNT'
`winheight NAME -COUNT'
     Change the height of the window NAME by COUNT lines.  Positive
     counts increase the height, while negative counts decrease it.

`tabset NCHARS'
     Set the width of tab stops to be NCHARS characters.


File: gdb.info,  Node: TUI Configuration,  Prev: TUI Commands,  Up: TUI

25.5 TUI Configuration Variables
================================

Several configuration variables control the appearance of TUI windows.

`set tui border-kind KIND'
     Select the border appearance for the source, assembly and register
     windows.  The possible values are the following:
    `space'
          Use a space character to draw the border.

    `ascii'
          Use ASCII characters `+', `-' and `|' to draw the border.

    `acs'
          Use the Alternate Character Set to draw the border.  The
          border is drawn using character line graphics if the terminal
          supports them.

`set tui border-mode MODE'
`set tui active-border-mode MODE'
     Select the display attributes for the borders of the inactive
     windows or the active window.  The MODE can be one of the
     following:
    `normal'
          Use normal attributes to display the border.

    `standout'
          Use standout mode.

    `reverse'
          Use reverse video mode.

    `half'
          Use half bright mode.

    `half-standout'
          Use half bright and standout mode.

    `bold'
          Use extra bright or bold mode.

    `bold-standout'
          Use extra bright or bold and standout mode.


File: gdb.info,  Node: Emacs,  Next: GDB/MI,  Prev: TUI,  Up: Top

26 Using GDB under GNU Emacs
****************************

A special interface allows you to use GNU Emacs to view (and edit) the
source files for the program you are debugging with GDB.

   To use this interface, use the command `M-x gdb' in Emacs.  Give the
executable file you want to debug as an argument.  This command starts
GDB as a subprocess of Emacs, with input and output through a newly
created Emacs buffer.

   Running GDB under Emacs can be just like running GDB normally except
for two things:

   * All "terminal" input and output goes through an Emacs buffer,
     called the GUD buffer.

     This applies both to GDB commands and their output, and to the
     input and output done by the program you are debugging.

     This is useful because it means that you can copy the text of
     previous commands and input them again; you can even use parts of
     the output in this way.

     All the facilities of Emacs' Shell mode are available for
     interacting with your program.  In particular, you can send
     signals the usual way--for example, `C-c C-c' for an interrupt,
     `C-c C-z' for a stop.

   * GDB displays source code through Emacs.

     Each time GDB displays a stack frame, Emacs automatically finds the
     source file for that frame and puts an arrow (`=>') at the left
     margin of the current line.  Emacs uses a separate buffer for
     source display, and splits the screen to show both your GDB session
     and the source.

     Explicit GDB `list' or search commands still produce output as
     usual, but you probably have no reason to use them from Emacs.

   We call this "text command mode".  Emacs 22.1, and later, also uses
a graphical mode, enabled by default, which provides further buffers
that can control the execution and describe the state of your program.
*Note GDB Graphical Interface: (Emacs)GDB Graphical Interface.

   If you specify an absolute file name when prompted for the `M-x gdb'
argument, then Emacs sets your current working directory to where your
program resides.  If you only specify the file name, then Emacs sets
your current working directory to to the directory associated with the
previous buffer.  In this case, GDB may find your program by searching
your environment's `PATH' variable, but on some operating systems it
might not find the source.  So, although the GDB input and output
session proceeds normally, the auxiliary buffer does not display the
current source and line of execution.

   The initial working directory of GDB is printed on the top line of
the GUD buffer and this serves as a default for the commands that
specify files for GDB to operate on.  *Note Commands to Specify Files:
Files.

   By default, `M-x gdb' calls the program called `gdb'.  If you need
to call GDB by a different name (for example, if you keep several
configurations around, with different names) you can customize the
Emacs variable `gud-gdb-command-name' to run the one you want.

   In the GUD buffer, you can use these special Emacs commands in
addition to the standard Shell mode commands:

`C-h m'
     Describe the features of Emacs' GUD Mode.

`C-c C-s'
     Execute to another source line, like the GDB `step' command; also
     update the display window to show the current file and location.

`C-c C-n'
     Execute to next source line in this function, skipping all function
     calls, like the GDB `next' command.  Then update the display window
     to show the current file and location.

`C-c C-i'
     Execute one instruction, like the GDB `stepi' command; update
     display window accordingly.

`C-c C-f'
     Execute until exit from the selected stack frame, like the GDB
     `finish' command.

`C-c C-r'
     Continue execution of your program, like the GDB `continue'
     command.

`C-c <'
     Go up the number of frames indicated by the numeric argument
     (*note Numeric Arguments: (Emacs)Arguments.), like the GDB `up'
     command.

`C-c >'
     Go down the number of frames indicated by the numeric argument,
     like the GDB `down' command.

   In any source file, the Emacs command `C-x <SPC>' (`gud-break')
tells GDB to set a breakpoint on the source line point is on.

   In text command mode, if you type `M-x speedbar', Emacs displays a
separate frame which shows a backtrace when the GUD buffer is current.
Move point to any frame in the stack and type <RET> to make it become
the current frame and display the associated source in the source
buffer.  Alternatively, click `Mouse-2' to make the selected frame
become the current one.  In graphical mode, the speedbar displays watch
expressions.

   If you accidentally delete the source-display buffer, an easy way to
get it back is to type the command `f' in the GDB buffer, to request a
frame display; when you run under Emacs, this recreates the source
buffer if necessary to show you the context of the current frame.

   The source files displayed in Emacs are in ordinary Emacs buffers
which are visiting the source files in the usual way.  You can edit the
files with these buffers if you wish; but keep in mind that GDB
communicates with Emacs in terms of line numbers.  If you add or delete
lines from the text, the line numbers that GDB knows cease to
correspond properly with the code.

   A more detailed description of Emacs' interaction with GDB is given
in the Emacs manual (*note Debuggers: (Emacs)Debuggers.).


File: gdb.info,  Node: GDB/MI,  Next: Annotations,  Prev: Emacs,  Up: Top

27 The GDB/MI Interface
***********************

Function and Purpose
====================

GDB/MI is a line based machine oriented text interface to GDB and is
activated by specifying using the `--interpreter' command line option
(*note Mode Options::).  It is specifically intended to support the
development of systems which use the debugger as just one small
component of a larger system.

   This chapter is a specification of the GDB/MI interface.  It is
written in the form of a reference manual.

   Note that GDB/MI is still under construction, so some of the
features described below are incomplete and subject to change (*note
GDB/MI Development and Front Ends: GDB/MI Development and Front Ends.).

Notation and Terminology
========================

This chapter uses the following notation:

   * `|' separates two alternatives.

   * `[ SOMETHING ]' indicates that SOMETHING is optional: it may or
     may not be given.

   * `( GROUP )*' means that GROUP inside the parentheses may repeat
     zero or more times.

   * `( GROUP )+' means that GROUP inside the parentheses may repeat
     one or more times.

   * `"STRING"' means a literal STRING.

* Menu:

* GDB/MI General Design::
* GDB/MI Command Syntax::
* GDB/MI Compatibility with CLI::
* GDB/MI Development and Front Ends::
* GDB/MI Output Records::
* GDB/MI Simple Examples::
* GDB/MI Command Description Format::
* GDB/MI Breakpoint Commands::
* GDB/MI Program Context::
* GDB/MI Thread Commands::
* GDB/MI Program Execution::
* GDB/MI Stack Manipulation::
* GDB/MI Variable Objects::
* GDB/MI Data Manipulation::
* GDB/MI Tracepoint Commands::
* GDB/MI Symbol Query::
* GDB/MI File Commands::
* GDB/MI Target Manipulation::
* GDB/MI File Transfer Commands::
* GDB/MI Miscellaneous Commands::


File: gdb.info,  Node: GDB/MI General Design,  Next: GDB/MI Command Syntax,  Up: GDB/MI

27.1 GDB/MI General Design
==========================

Interaction of a GDB/MI frontend with GDB involves three
parts--commands sent to GDB, responses to those commands and
notifications.  Each command results in exactly one response,
indicating either successful completion of the command, or an error.
For the commands that do not resume the target, the response contains
the requested information.  For the commands that resume the target, the
response only indicates whether the target was successfully resumed.
Notifications is the mechanism for reporting changes in the state of the
target, or in GDB state, that cannot conveniently be associated with a
command and reported as part of that command response.

   The important examples of notifications are:
   * Exec notifications.  These are used to report changes in target
     state--when a target is resumed, or stopped.  It would not be
     feasible to include this information in response of resuming
     commands, because one resume commands can result in multiple
     events in different threads.  Also, quite some time may pass
     before any event happens in the target, while a frontend needs to
     know whether the resuming command itself was successfully executed.

   * Console output, and status notifications.  Console output
     notifications are used to report output of CLI commands, as well as
     diagnostics for other commands.  Status notifications are used to
     report the progress of a long-running operation.  Naturally,
     including this information in command response would mean no
     output is produced until the command is finished, which is
     undesirable.

   * General notifications.  Commands may have various side effects on
     the GDB or target state beyond their official purpose.  For
     example, a command may change the selected thread.  Although such
     changes can be included in command response, using notification
     allows for more orthogonal frontend design.


   There's no guarantee that whenever an MI command reports an error,
GDB or the target are in any specific state, and especially, the state
is not reverted to the state before the MI command was processed.
Therefore, whenever an MI command results in an error, we recommend
that the frontend refreshes all the information shown in the user
interface.

* Menu:

* Context management::
* Asynchronous and non-stop modes::
* Thread groups::


File: gdb.info,  Node: Context management,  Next: Asynchronous and non-stop modes,  Up: GDB/MI General Design

27.1.1 Context management
-------------------------

In most cases when GDB accesses the target, this access is done in
context of a specific thread and frame (*note Frames::).  Often, even
when accessing global data, the target requires that a thread be
specified.  The CLI interface maintains the selected thread and frame,
and supplies them to target on each command.  This is convenient,
because a command line user would not want to specify that information
explicitly on each command, and because user interacts with GDB via a
single terminal, so no confusion is possible as to what thread and
frame are the current ones.

   In the case of MI, the concept of selected thread and frame is less
useful.  First, a frontend can easily remember this information itself.
Second, a graphical frontend can have more than one window, each one
used for debugging a different thread, and the frontend might want to
access additional threads for internal purposes.  This increases the
risk that by relying on implicitly selected thread, the frontend may be
operating on a wrong one.  Therefore, each MI command should explicitly
specify which thread and frame to operate on.  To make it possible,
each MI command accepts the `--thread' and `--frame' options, the value
to each is GDB identifier for thread and frame to operate on.

   Usually, each top-level window in a frontend allows the user to
select a thread and a frame, and remembers the user selection for
further operations.  However, in some cases GDB may suggest that the
current thread be changed.  For example, when stopping on a breakpoint
it is reasonable to switch to the thread where breakpoint is hit.  For
another example, if the user issues the CLI `thread' command via the
frontend, it is desirable to change the frontend's selected thread to
the one specified by user.  GDB communicates the suggestion to change
current thread using the `=thread-selected' notification.  No such
notification is available for the selected frame at the moment.

   Note that historically, MI shares the selected thread with CLI, so
frontends used the `-thread-select' to execute commands in the right
context.  However, getting this to work right is cumbersome.  The
simplest way is for frontend to emit `-thread-select' command before
every command.  This doubles the number of commands that need to be
sent.  The alternative approach is to suppress `-thread-select' if the
selected thread in GDB is supposed to be identical to the thread the
frontend wants to operate on.  However, getting this optimization right
can be tricky.  In particular, if the frontend sends several commands
to GDB, and one of the commands changes the selected thread, then the
behaviour of subsequent commands will change.  So, a frontend should
either wait for response from such problematic commands, or explicitly
add `-thread-select' for all subsequent commands.  No frontend is known
to do this exactly right, so it is suggested to just always pass the
`--thread' and `--frame' options.


File: gdb.info,  Node: Asynchronous and non-stop modes,  Next: Thread groups,  Prev: Context management,  Up: GDB/MI General Design

27.1.2 Asynchronous command execution and non-stop mode
-------------------------------------------------------

On some targets, GDB is capable of processing MI commands even while
the target is running.  This is called "asynchronous command execution"
(*note Background Execution::).  The frontend may specify a preferrence
for asynchronous execution using the `-gdb-set target-async 1' command,
which should be emitted before either running the executable or
attaching to the target.  After the frontend has started the executable
or attached to the target, it can find if asynchronous execution is
enabled using the `-list-target-features' command.

   Even if GDB can accept a command while target is running, many
commands that access the target do not work when the target is running.
Therefore, asynchronous command execution is most useful when combined
with non-stop mode (*note Non-Stop Mode::).  Then, it is possible to
examine the state of one thread, while other threads are running.

   When a given thread is running, MI commands that try to access the
target in the context of that thread may not work, or may work only on
some targets.  In particular, commands that try to operate on thread's
stack will not work, on any target.  Commands that read memory, or
modify breakpoints, may work or not work, depending on the target.  Note
that even commands that operate on global state, such as `print',
`set', and breakpoint commands, still access the target in the context
of a specific thread,  so frontend should try to find a stopped thread
and perform the operation on that thread (using the `--thread' option).

   Which commands will work in the context of a running thread is
highly target dependent.  However, the two commands `-exec-interrupt',
to stop a thread, and `-thread-info', to find the state of a thread,
will always work.


File: gdb.info,  Node: Thread groups,  Prev: Asynchronous and non-stop modes,  Up: GDB/MI General Design

27.1.3 Thread groups
--------------------

GDB may be used to debug several processes at the same time.  On some
platfroms, GDB may support debugging of several hardware systems, each
one having several cores with several different processes running on
each core.  This section describes the MI mechanism to support such
debugging scenarios.

   The key observation is that regardless of the structure of the
target, MI can have a global list of threads, because most commands that
accept the `--thread' option do not need to know what process that
thread belongs to.  Therefore, it is not necessary to introduce neither
additional `--process' option, nor an notion of the current process in
the MI interface.  The only strictly new feature that is required is
the ability to find how the threads are grouped into processes.

   To allow the user to discover such grouping, and to support arbitrary
hierarchy of machines/cores/processes, MI introduces the concept of a
"thread group".  Thread group is a collection of threads and other
thread groups.  A thread group always has a string identifier, a type,
and may have additional attributes specific to the type.  A new
command, `-list-thread-groups', returns the list of top-level thread
groups, which correspond to processes that GDB is debugging at the
moment.  By passing an identifier of a thread group to the
`-list-thread-groups' command, it is possible to obtain the members of
specific thread group.

   To allow the user to easily discover processes, and other objects, he
wishes to debug, a concept of "available thread group" is introduced.
Available thread group is an thread group that GDB is not debugging,
but that can be attached to, using the `-target-attach' command.  The
list of available top-level thread groups can be obtained using
`-list-thread-groups --available'.  In general, the content of a thread
group may be only retrieved only after attaching to that thread group.

   Thread groups are related to inferiors (*note Inferiors and
Programs::).  Each inferior corresponds to a thread group of a special
type `process', and some additional operations are permitted on such
thread groups.


File: gdb.info,  Node: GDB/MI Command Syntax,  Next: GDB/MI Compatibility with CLI,  Prev: GDB/MI General Design,  Up: GDB/MI

27.2 GDB/MI Command Syntax
==========================

* Menu:

* GDB/MI Input Syntax::
* GDB/MI Output Syntax::


File: gdb.info,  Node: GDB/MI Input Syntax,  Next: GDB/MI Output Syntax,  Up: GDB/MI Command Syntax

27.2.1 GDB/MI Input Syntax
--------------------------

`COMMAND ==>'
     `CLI-COMMAND | MI-COMMAND'

`CLI-COMMAND ==>'
     `[ TOKEN ] CLI-COMMAND NL', where CLI-COMMAND is any existing GDB
     CLI command.

`MI-COMMAND ==>'
     `[ TOKEN ] "-" OPERATION ( " " OPTION )* `[' " --" `]' ( " "
     PARAMETER )* NL'

`TOKEN ==>'
     "any sequence of digits"

`OPTION ==>'
     `"-" PARAMETER [ " " PARAMETER ]'

`PARAMETER ==>'
     `NON-BLANK-SEQUENCE | C-STRING'

`OPERATION ==>'
     _any of the operations described in this chapter_

`NON-BLANK-SEQUENCE ==>'
     _anything, provided it doesn't contain special characters such as
     "-", NL, """ and of course " "_

`C-STRING ==>'
     `""" SEVEN-BIT-ISO-C-STRING-CONTENT """'

`NL ==>'
     `CR | CR-LF'

Notes:

   * The CLI commands are still handled by the MI interpreter; their
     output is described below.

   * The `TOKEN', when present, is passed back when the command
     finishes.

   * Some MI commands accept optional arguments as part of the parameter
     list.  Each option is identified by a leading `-' (dash) and may be
     followed by an optional argument parameter.  Options occur first
     in the parameter list and can be delimited from normal parameters
     using `--' (this is useful when some parameters begin with a dash).

   Pragmatics:

   * We want easy access to the existing CLI syntax (for debugging).

   * We want it to be easy to spot a MI operation.


File: gdb.info,  Node: GDB/MI Output Syntax,  Prev: GDB/MI Input Syntax,  Up: GDB/MI Command Syntax

27.2.2 GDB/MI Output Syntax
---------------------------

The output from GDB/MI consists of zero or more out-of-band records
followed, optionally, by a single result record.  This result record is
for the most recent command.  The sequence of output records is
terminated by `(gdb)'.

   If an input command was prefixed with a `TOKEN' then the
corresponding output for that command will also be prefixed by that same
TOKEN.

`OUTPUT ==>'
     `( OUT-OF-BAND-RECORD )* [ RESULT-RECORD ] "(gdb)" NL'

`RESULT-RECORD ==>'
     ` [ TOKEN ] "^" RESULT-CLASS ( "," RESULT )* NL'

`OUT-OF-BAND-RECORD ==>'
     `ASYNC-RECORD | STREAM-RECORD'

`ASYNC-RECORD ==>'
     `EXEC-ASYNC-OUTPUT | STATUS-ASYNC-OUTPUT | NOTIFY-ASYNC-OUTPUT'

`EXEC-ASYNC-OUTPUT ==>'
     `[ TOKEN ] "*" ASYNC-OUTPUT'

`STATUS-ASYNC-OUTPUT ==>'
     `[ TOKEN ] "+" ASYNC-OUTPUT'

`NOTIFY-ASYNC-OUTPUT ==>'
     `[ TOKEN ] "=" ASYNC-OUTPUT'

`ASYNC-OUTPUT ==>'
     `ASYNC-CLASS ( "," RESULT )* NL'

`RESULT-CLASS ==>'
     `"done" | "running" | "connected" | "error" | "exit"'

`ASYNC-CLASS ==>'
     `"stopped" | OTHERS' (where OTHERS will be added depending on the
     needs--this is still in development).

`RESULT ==>'
     ` VARIABLE "=" VALUE'

`VARIABLE ==>'
     ` STRING '

`VALUE ==>'
     ` CONST | TUPLE | LIST '

`CONST ==>'
     `C-STRING'

`TUPLE ==>'
     ` "{}" | "{" RESULT ( "," RESULT )* "}" '

`LIST ==>'
     ` "[]" | "[" VALUE ( "," VALUE )* "]" | "[" RESULT ( "," RESULT )*
     "]" '

`STREAM-RECORD ==>'
     `CONSOLE-STREAM-OUTPUT | TARGET-STREAM-OUTPUT | LOG-STREAM-OUTPUT'

`CONSOLE-STREAM-OUTPUT ==>'
     `"~" C-STRING'

`TARGET-STREAM-OUTPUT ==>'
     `"@" C-STRING'

`LOG-STREAM-OUTPUT ==>'
     `"&" C-STRING'

`NL ==>'
     `CR | CR-LF'

`TOKEN ==>'
     _any sequence of digits_.

Notes:

   * All output sequences end in a single line containing a period.

   * The `TOKEN' is from the corresponding request.  Note that for all
     async output, while the token is allowed by the grammar and may be
     output by future versions of GDB for select async output messages,
     it is generally omitted.  Frontends should treat all async output
     as reporting general changes in the state of the target and there
     should be no need to associate async output to any prior command.

   * STATUS-ASYNC-OUTPUT contains on-going status information about the
     progress of a slow operation.  It can be discarded.  All status
     output is prefixed by `+'.

   * EXEC-ASYNC-OUTPUT contains asynchronous state change on the target
     (stopped, started, disappeared).  All async output is prefixed by
     `*'.

   * NOTIFY-ASYNC-OUTPUT contains supplementary information that the
     client should handle (e.g., a new breakpoint information).  All
     notify output is prefixed by `='.

   * CONSOLE-STREAM-OUTPUT is output that should be displayed as is in
     the console.  It is the textual response to a CLI command.  All
     the console output is prefixed by `~'.

   * TARGET-STREAM-OUTPUT is the output produced by the target program.
     All the target output is prefixed by `@'.

   * LOG-STREAM-OUTPUT is output text coming from GDB's internals, for
     instance messages that should be displayed as part of an error
     log.  All the log output is prefixed by `&'.

   * New GDB/MI commands should only output LISTS containing VALUES.


   *Note GDB/MI Stream Records: GDB/MI Stream Records, for more details
about the various output records.


File: gdb.info,  Node: GDB/MI Compatibility with CLI,  Next: GDB/MI Development and Front Ends,  Prev: GDB/MI Command Syntax,  Up: GDB/MI

27.3 GDB/MI Compatibility with CLI
==================================

For the developers convenience CLI commands can be entered directly,
but there may be some unexpected behaviour.  For example, commands that
query the user will behave as if the user replied yes, breakpoint
command lists are not executed and some CLI commands, such as `if',
`when' and `define', prompt for further input with `>', which is not
valid MI output.

   This feature may be removed at some stage in the future and it is
recommended that front ends use the `-interpreter-exec' command (*note
-interpreter-exec::).


File: gdb.info,  Node: GDB/MI Development and Front Ends,  Next: GDB/MI Output Records,  Prev: GDB/MI Compatibility with CLI,  Up: GDB/MI

27.4 GDB/MI Development and Front Ends
======================================

The application which takes the MI output and presents the state of the
program being debugged to the user is called a "front end".

   Although GDB/MI is still incomplete, it is currently being used by a
variety of front ends to GDB.  This makes it difficult to introduce new
functionality without breaking existing usage.  This section tries to
minimize the problems by describing how the protocol might change.

   Some changes in MI need not break a carefully designed front end, and
for these the MI version will remain unchanged.  The following is a
list of changes that may occur within one level, so front ends should
parse MI output in a way that can handle them:

   * New MI commands may be added.

   * New fields may be added to the output of any MI command.

   * The range of values for fields with specified values, e.g.,
     `in_scope' (*note -var-update::) may be extended.


   If the changes are likely to break front ends, the MI version level
will be increased by one.  This will allow the front end to parse the
output according to the MI version.  Apart from mi0, new versions of
GDB will not support old versions of MI and it will be the
responsibility of the front end to work with the new one.

   The best way to avoid unexpected changes in MI that might break your
front end is to make your project known to GDB developers and follow
development on <gdb@sourceware.org> and <gdb-patches@sourceware.org>.  


File: gdb.info,  Node: GDB/MI Output Records,  Next: GDB/MI Simple Examples,  Prev: GDB/MI Development and Front Ends,  Up: GDB/MI

27.5 GDB/MI Output Records
==========================

* Menu:

* GDB/MI Result Records::
* GDB/MI Stream Records::
* GDB/MI Async Records::
* GDB/MI Frame Information::
* GDB/MI Thread Information::
* GDB/MI Ada Exception Information::


File: gdb.info,  Node: GDB/MI Result Records,  Next: GDB/MI Stream Records,  Up: GDB/MI Output Records

27.5.1 GDB/MI Result Records
----------------------------

In addition to a number of out-of-band notifications, the response to a
GDB/MI command includes one of the following result indications:

`"^done" [ "," RESULTS ]'
     The synchronous operation was successful, `RESULTS' are the return
     values.

`"^running"'
     This result record is equivalent to `^done'.  Historically, it was
     output instead of `^done' if the command has resumed the target.
     This behaviour is maintained for backward compatibility, but all
     frontends should treat `^done' and `^running' identically and rely
     on the `*running' output record to determine which threads are
     resumed.

`"^connected"'
     GDB has connected to a remote target.

`"^error" "," C-STRING'
     The operation failed.  The `C-STRING' contains the corresponding
     error message.

`"^exit"'
     GDB has terminated.



File: gdb.info,  Node: GDB/MI Stream Records,  Next: GDB/MI Async Records,  Prev: GDB/MI Result Records,  Up: GDB/MI Output Records

27.5.2 GDB/MI Stream Records
----------------------------

GDB internally maintains a number of output streams: the console, the
target, and the log.  The output intended for each of these streams is
funneled through the GDB/MI interface using "stream records".

   Each stream record begins with a unique "prefix character" which
identifies its stream (*note GDB/MI Output Syntax: GDB/MI Output
Syntax.).  In addition to the prefix, each stream record contains a
`STRING-OUTPUT'.  This is either raw text (with an implicit new line)
or a quoted C string (which does not contain an implicit newline).

`"~" STRING-OUTPUT'
     The console output stream contains text that should be displayed
     in the CLI console window.  It contains the textual responses to
     CLI commands.

`"@" STRING-OUTPUT'
     The target output stream contains any textual output from the
     running target.  This is only present when GDB's event loop is
     truly asynchronous, which is currently only the case for remote
     targets.

`"&" STRING-OUTPUT'
     The log stream contains debugging messages being produced by GDB's
     internals.


File: gdb.info,  Node: GDB/MI Async Records,  Next: GDB/MI Frame Information,  Prev: GDB/MI Stream Records,  Up: GDB/MI Output Records

27.5.3 GDB/MI Async Records
---------------------------

"Async" records are used to notify the GDB/MI client of additional
changes that have occurred.  Those changes can either be a consequence
of GDB/MI commands (e.g., a breakpoint modified) or a result of target
activity (e.g., target stopped).

   The following is the list of possible async records:

`*running,thread-id="THREAD"'
     The target is now running.  The THREAD field tells which specific
     thread is now running, and can be `all' if all threads are
     running.  The frontend should assume that no interaction with a
     running thread is possible after this notification is produced.
     The frontend should not assume that this notification is output
     only once for any command.  GDB may emit this notification several
     times, either for different threads, because it cannot resume all
     threads together, or even for a single thread, if the thread must
     be stepped though some code before letting it run freely.

`*stopped,reason="REASON",thread-id="ID",stopped-threads="STOPPED",core="CORE"'
     The target has stopped.  The REASON field can have one of the
     following values:

    `breakpoint-hit'
          A breakpoint was reached.

    `watchpoint-trigger'
          A watchpoint was triggered.

    `read-watchpoint-trigger'
          A read watchpoint was triggered.

    `access-watchpoint-trigger'
          An access watchpoint was triggered.

    `function-finished'
          An -exec-finish or similar CLI command was accomplished.

    `location-reached'
          An -exec-until or similar CLI command was accomplished.

    `watchpoint-scope'
          A watchpoint has gone out of scope.

    `end-stepping-range'
          An -exec-next, -exec-next-instruction, -exec-step,
          -exec-step-instruction or similar CLI command was
          accomplished.

    `exited-signalled'
          The inferior exited because of a signal.

    `exited'
          The inferior exited.

    `exited-normally'
          The inferior exited normally.

    `signal-received'
          A signal was received by the inferior.

     The ID field identifies the thread that directly caused the stop -
     for example by hitting a breakpoint.  Depending on whether all-stop
     mode is in effect (*note All-Stop Mode::), GDB may either stop all
     threads, or only the thread that directly triggered the stop.  If
     all threads are stopped, the STOPPED field will have the value of
     `"all"'.  Otherwise, the value of the STOPPED field will be a list
     of thread identifiers.  Presently, this list will always include a
     single thread, but frontend should be prepared to see several
     threads in the list.  The CORE field reports the processor core on
     which the stop event has happened.  This field may be absent if
     such information is not available.

`=thread-group-added,id="ID"'
`=thread-group-removed,id="ID"'
     A thread group was either added or removed.  The ID field contains
     the GDB identifier of the thread group.  When a thread group is
     added, it generally might not be associated with a running
     process.  When a thread group is removed, its id becomes invalid
     and cannot be used in any way.

`=thread-group-started,id="ID",pid="PID"'
     A thread group became associated with a running program, either
     because the program was just started or the thread group was
     attached to a program.  The ID field contains the GDB identifier
     of the thread group.  The PID field contains process identifier,
     specific to the operating system.

`=thread-group-exited,id="ID"[,exit-code="CODE"]'
     A thread group is no longer associated with a running program,
     either because the program has exited, or because it was detached
     from.  The ID field contains the GDB identifier of the thread
     group.  CODE is the exit code of the inferior; it exists only when
     the inferior exited with some code.

`=thread-created,id="ID",group-id="GID"'
`=thread-exited,id="ID",group-id="GID"'
     A thread either was created, or has exited.  The ID field contains
     the GDB identifier of the thread.  The GID field identifies the
     thread group this thread belongs to.

`=thread-selected,id="ID"'
     Informs that the selected thread was changed as result of the last
     command.  This notification is not emitted as result of
     `-thread-select' command but is emitted whenever an MI command
     that is not documented to change the selected thread actually
     changes it.  In particular, invoking, directly or indirectly (via
     user-defined command), the CLI `thread' command, will generate
     this notification.

     We suggest that in response to this notification, front ends
     highlight the selected thread and cause subsequent commands to
     apply to that thread.

`=library-loaded,...'
     Reports that a new library file was loaded by the program.  This
     notification has 4 fields--ID, TARGET-NAME, HOST-NAME, and
     SYMBOLS-LOADED.  The ID field is an opaque identifier of the
     library.  For remote debugging case, TARGET-NAME and HOST-NAME
     fields give the name of the library file on the target, and on the
     host respectively.  For native debugging, both those fields have
     the same value.  The SYMBOLS-LOADED field is emitted only for
     backward compatibility and should not be relied on to convey any
     useful information.  The THREAD-GROUP field, if present, specifies
     the id of the thread group in whose context the library was
     loaded.  If the field is absent, it means the library was loaded
     in the context of all present thread groups.

`=library-unloaded,...'
     Reports that a library was unloaded by the program.  This
     notification has 3 fields--ID, TARGET-NAME and HOST-NAME with the
     same meaning as for the `=library-loaded' notification.  The
     THREAD-GROUP field, if present, specifies the id of the thread
     group in whose context the library was unloaded.  If the field is
     absent, it means the library was unloaded in the context of all
     present thread groups.



File: gdb.info,  Node: GDB/MI Frame Information,  Next: GDB/MI Thread Information,  Prev: GDB/MI Async Records,  Up: GDB/MI Output Records

27.5.4 GDB/MI Frame Information
-------------------------------

Response from many MI commands includes an information about stack
frame.  This information is a tuple that may have the following fields:

`level'
     The level of the stack frame.  The innermost frame has the level of
     zero.  This field is always present.

`func'
     The name of the function corresponding to the frame.  This field
     may be absent if GDB is unable to determine the function name.

`addr'
     The code address for the frame.  This field is always present.

`file'
     The name of the source files that correspond to the frame's code
     address.  This field may be absent.

`line'
     The source line corresponding to the frames' code address.  This
     field may be absent.

`from'
     The name of the binary file (either executable or shared library)
     the corresponds to the frame's code address.  This field may be
     absent.



File: gdb.info,  Node: GDB/MI Thread Information,  Next: GDB/MI Ada Exception Information,  Prev: GDB/MI Frame Information,  Up: GDB/MI Output Records

27.5.5 GDB/MI Thread Information
--------------------------------

Whenever GDB has to report an information about a thread, it uses a
tuple with the following fields:

`id'
     The numeric id assigned to the thread by GDB.  This field is
     always present.

`target-id'
     Target-specific string identifying the thread.  This field is
     always present.

`details'
     Additional information about the thread provided by the target.
     It is supposed to be human-readable and not interpreted by the
     frontend.  This field is optional.

`state'
     Either `stopped' or `running', depending on whether the thread is
     presently running.  This field is always present.

`core'
     The value of this field is an integer number of the processor core
     the thread was last seen on.  This field is optional.


File: gdb.info,  Node: GDB/MI Ada Exception Information,  Prev: GDB/MI Thread Information,  Up: GDB/MI Output Records

27.5.6 GDB/MI Ada Exception Information
---------------------------------------

Whenever a `*stopped' record is emitted because the program stopped
after hitting an exception catchpoint (*note Set Catchpoints::), GDB
provides the name of the exception that was raised via the
`exception-name' field.


File: gdb.info,  Node: GDB/MI Simple Examples,  Next: GDB/MI Command Description Format,  Prev: GDB/MI Output Records,  Up: GDB/MI

27.6 Simple Examples of GDB/MI Interaction
==========================================

This subsection presents several simple examples of interaction using
the GDB/MI interface.  In these examples, `->' means that the following
line is passed to GDB/MI as input, while `<-' means the output received
from GDB/MI.

   Note the line breaks shown in the examples are here only for
readability, they don't appear in the real output.

Setting a Breakpoint
--------------------

Setting a breakpoint generates synchronous output which contains
detailed information of the breakpoint.

     -> -break-insert main
     <- ^done,bkpt={number="1",type="breakpoint",disp="keep",
         enabled="y",addr="0x08048564",func="main",file="myprog.c",
         fullname="/home/nickrob/myprog.c",line="68",times="0"}
     <- (gdb)

Program Execution
-----------------

Program execution generates asynchronous records and MI gives the
reason that execution stopped.

     -> -exec-run
     <- ^running
     <- (gdb)
     <- *stopped,reason="breakpoint-hit",disp="keep",bkptno="1",thread-id="0",
        frame={addr="0x08048564",func="main",
        args=[{name="argc",value="1"},{name="argv",value="0xbfc4d4d4"}],
        file="myprog.c",fullname="/home/nickrob/myprog.c",line="68"}
     <- (gdb)
     -> -exec-continue
     <- ^running
     <- (gdb)
     <- *stopped,reason="exited-normally"
     <- (gdb)

Quitting GDB
------------

Quitting GDB just prints the result class `^exit'.

     -> (gdb)
     <- -gdb-exit
     <- ^exit

   Please note that `^exit' is printed immediately, but it might take
some time for GDB to actually exit.  During that time, GDB performs
necessary cleanups, including killing programs being debugged or
disconnecting from debug hardware, so the frontend should wait till GDB
exits and should only forcibly kill GDB if it fails to exit in
reasonable time.

A Bad Command
-------------

Here's what happens if you pass a non-existent command:

     -> -rubbish
     <- ^error,msg="Undefined MI command: rubbish"
     <- (gdb)


File: gdb.info,  Node: GDB/MI Command Description Format,  Next: GDB/MI Breakpoint Commands,  Prev: GDB/MI Simple Examples,  Up: GDB/MI

27.7 GDB/MI Command Description Format
======================================

The remaining sections describe blocks of commands.  Each block of
commands is laid out in a fashion similar to this section.

Motivation
----------

The motivation for this collection of commands.

Introduction
------------

A brief introduction to this collection of commands as a whole.

Commands
--------

For each command in the block, the following is described:

Synopsis
........

      -command ARGS...

Result
......

GDB Command
...........

The corresponding GDB CLI command(s), if any.

Example
.......

Example(s) formatted for readability.  Some of the described commands
have not been implemented yet and these are labeled N.A. (not
available).


File: gdb.info,  Node: GDB/MI Breakpoint Commands,  Next: GDB/MI Program Context,  Prev: GDB/MI Command Description Format,  Up: GDB/MI

27.8 GDB/MI Breakpoint Commands
===============================

This section documents GDB/MI commands for manipulating breakpoints.

The `-break-after' Command
--------------------------

Synopsis
........

      -break-after NUMBER COUNT

   The breakpoint number NUMBER is not in effect until it has been hit
COUNT times.  To see how this is reflected in the output of the
`-break-list' command, see the description of the `-break-list' command
below.

GDB Command
...........

The corresponding GDB command is `ignore'.

Example
.......

     (gdb)
     -break-insert main
     ^done,bkpt={number="1",type="breakpoint",disp="keep",
     enabled="y",addr="0x000100d0",func="main",file="hello.c",
     fullname="/home/foo/hello.c",line="5",times="0"}
     (gdb)
     -break-after 1 3
     ~
     ^done
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="1",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
     addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",
     line="5",times="0",ignore="3"}]}
     (gdb)

The `-break-commands' Command
-----------------------------

Synopsis
........

      -break-commands NUMBER [ COMMAND1 ... COMMANDN ]

   Specifies the CLI commands that should be executed when breakpoint
NUMBER is hit.  The parameters COMMAND1 to COMMANDN are the commands.
If no command is specified, any previously-set commands are cleared.
*Note Break Commands::.  Typical use of this functionality is tracing a
program, that is, printing of values of some variables whenever
breakpoint is hit and then continuing.

GDB Command
...........

The corresponding GDB command is `commands'.

Example
.......

     (gdb)
     -break-insert main
     ^done,bkpt={number="1",type="breakpoint",disp="keep",
     enabled="y",addr="0x000100d0",func="main",file="hello.c",
     fullname="/home/foo/hello.c",line="5",times="0"}
     (gdb)
     -break-commands 1 "print v" "continue"
     ^done
     (gdb)

The `-break-condition' Command
------------------------------

Synopsis
........

      -break-condition NUMBER EXPR

   Breakpoint NUMBER will stop the program only if the condition in
EXPR is true.  The condition becomes part of the `-break-list' output
(see the description of the `-break-list' command below).

GDB Command
...........

The corresponding GDB command is `condition'.

Example
.......

     (gdb)
     -break-condition 1 1
     ^done
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="1",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
     addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",
     line="5",cond="1",times="0",ignore="3"}]}
     (gdb)

The `-break-delete' Command
---------------------------

Synopsis
........

      -break-delete ( BREAKPOINT )+

   Delete the breakpoint(s) whose number(s) are specified in the
argument list.  This is obviously reflected in the breakpoint list.

GDB Command
...........

The corresponding GDB command is `delete'.

Example
.......

     (gdb)
     -break-delete 1
     ^done
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="0",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[]}
     (gdb)

The `-break-disable' Command
----------------------------

Synopsis
........

      -break-disable ( BREAKPOINT )+

   Disable the named BREAKPOINT(s).  The field `enabled' in the break
list is now set to `n' for the named BREAKPOINT(s).

GDB Command
...........

The corresponding GDB command is `disable'.

Example
.......

     (gdb)
     -break-disable 2
     ^done
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="1",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="2",type="breakpoint",disp="keep",enabled="n",
     addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",
     line="5",times="0"}]}
     (gdb)

The `-break-enable' Command
---------------------------

Synopsis
........

      -break-enable ( BREAKPOINT )+

   Enable (previously disabled) BREAKPOINT(s).

GDB Command
...........

The corresponding GDB command is `enable'.

Example
.......

     (gdb)
     -break-enable 2
     ^done
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="1",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="2",type="breakpoint",disp="keep",enabled="y",
     addr="0x000100d0",func="main",file="hello.c",fullname="/home/foo/hello.c",
     line="5",times="0"}]}
     (gdb)

The `-break-info' Command
-------------------------

Synopsis
........

      -break-info BREAKPOINT

   Get information about a single breakpoint.

GDB Command
...........

The corresponding GDB command is `info break BREAKPOINT'.

Example
.......

N.A.

The `-break-insert' Command
---------------------------

Synopsis
........

      -break-insert [ -t ] [ -h ] [ -f ] [ -d ] [ -a ]
         [ -c CONDITION ] [ -i IGNORE-COUNT ]
         [ -p THREAD ] [ LOCATION ]

If specified, LOCATION, can be one of:

   * function

   * filename:linenum

   * filename:function

   * *address

   The possible optional parameters of this command are:

`-t'
     Insert a temporary breakpoint.

`-h'
     Insert a hardware breakpoint.

`-c CONDITION'
     Make the breakpoint conditional on CONDITION.

`-i IGNORE-COUNT'
     Initialize the IGNORE-COUNT.

`-f'
     If LOCATION cannot be parsed (for example if it refers to unknown
     files or functions), create a pending breakpoint. Without this
     flag, GDB will report an error, and won't create a breakpoint, if
     LOCATION cannot be parsed.

`-d'
     Create a disabled breakpoint.

`-a'
     Create a tracepoint.  *Note Tracepoints::.  When this parameter is
     used together with `-h', a fast tracepoint is created.

Result
......

The result is in the form:

     ^done,bkpt={number="NUMBER",type="TYPE",disp="del"|"keep",
     enabled="y"|"n",addr="HEX",func="FUNCNAME",file="FILENAME",
     fullname="FULL_FILENAME",line="LINENO",[thread="THREADNO,]
     times="TIMES"}

where NUMBER is the GDB number for this breakpoint, FUNCNAME is the
name of the function where the breakpoint was inserted, FILENAME is the
name of the source file which contains this function, LINENO is the
source line number within that file and TIMES the number of times that
the breakpoint has been hit (always 0 for -break-insert but may be
greater for -break-info or -break-list which use the same output).

   Note: this format is open to change.

GDB Command
...........

The corresponding GDB commands are `break', `tbreak', `hbreak',
`thbreak', and `rbreak'.

Example
.......

     (gdb)
     -break-insert main
     ^done,bkpt={number="1",addr="0x0001072c",file="recursive2.c",
     fullname="/home/foo/recursive2.c,line="4",times="0"}
     (gdb)
     -break-insert -t foo
     ^done,bkpt={number="2",addr="0x00010774",file="recursive2.c",
     fullname="/home/foo/recursive2.c,line="11",times="0"}
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="2",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
     addr="0x0001072c", func="main",file="recursive2.c",
     fullname="/home/foo/recursive2.c,"line="4",times="0"},
     bkpt={number="2",type="breakpoint",disp="del",enabled="y",
     addr="0x00010774",func="foo",file="recursive2.c",
     fullname="/home/foo/recursive2.c",line="11",times="0"}]}
     (gdb)
     -break-insert -r foo.*
     ~int foo(int, int);
     ^done,bkpt={number="3",addr="0x00010774",file="recursive2.c,
     "fullname="/home/foo/recursive2.c",line="11",times="0"}
     (gdb)

The `-break-list' Command
-------------------------

Synopsis
........

      -break-list

   Displays the list of inserted breakpoints, showing the following
fields:

`Number'
     number of the breakpoint

`Type'
     type of the breakpoint: `breakpoint' or `watchpoint'

`Disposition'
     should the breakpoint be deleted or disabled when it is hit: `keep'
     or `nokeep'

`Enabled'
     is the breakpoint enabled or no: `y' or `n'

`Address'
     memory location at which the breakpoint is set

`What'
     logical location of the breakpoint, expressed by function name,
     file name, line number

`Times'
     number of times the breakpoint has been hit

   If there are no breakpoints or watchpoints, the `BreakpointTable'
`body' field is an empty list.

GDB Command
...........

The corresponding GDB command is `info break'.

Example
.......

     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="2",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
     addr="0x000100d0",func="main",file="hello.c",line="5",times="0"},
     bkpt={number="2",type="breakpoint",disp="keep",enabled="y",
     addr="0x00010114",func="foo",file="hello.c",fullname="/home/foo/hello.c",
     line="13",times="0"}]}
     (gdb)

   Here's an example of the result when there are no breakpoints:

     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="0",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[]}
     (gdb)

The `-break-passcount' Command
------------------------------

Synopsis
........

      -break-passcount TRACEPOINT-NUMBER PASSCOUNT

   Set the passcount for tracepoint TRACEPOINT-NUMBER to PASSCOUNT.  If
the breakpoint referred to by TRACEPOINT-NUMBER is not a tracepoint,
error is emitted.  This corresponds to CLI command `passcount'.

The `-break-watch' Command
--------------------------

Synopsis
........

      -break-watch [ -a | -r ]

   Create a watchpoint.  With the `-a' option it will create an
"access" watchpoint, i.e., a watchpoint that triggers either on a read
from or on a write to the memory location.  With the `-r' option, the
watchpoint created is a "read" watchpoint, i.e., it will trigger only
when the memory location is accessed for reading.  Without either of
the options, the watchpoint created is a regular watchpoint, i.e., it
will trigger when the memory location is accessed for writing.  *Note
Setting Watchpoints: Set Watchpoints.

   Note that `-break-list' will report a single list of watchpoints and
breakpoints inserted.

GDB Command
...........

The corresponding GDB commands are `watch', `awatch', and `rwatch'.

Example
.......

Setting a watchpoint on a variable in the `main' function:

     (gdb)
     -break-watch x
     ^done,wpt={number="2",exp="x"}
     (gdb)
     -exec-continue
     ^running
     (gdb)
     *stopped,reason="watchpoint-trigger",wpt={number="2",exp="x"},
     value={old="-268439212",new="55"},
     frame={func="main",args=[],file="recursive2.c",
     fullname="/home/foo/bar/recursive2.c",line="5"}
     (gdb)

   Setting a watchpoint on a variable local to a function.  GDB will
stop the program execution twice: first for the variable changing
value, then for the watchpoint going out of scope.

     (gdb)
     -break-watch C
     ^done,wpt={number="5",exp="C"}
     (gdb)
     -exec-continue
     ^running
     (gdb)
     *stopped,reason="watchpoint-trigger",
     wpt={number="5",exp="C"},value={old="-276895068",new="3"},
     frame={func="callee4",args=[],
     file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
     fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="13"}
     (gdb)
     -exec-continue
     ^running
     (gdb)
     *stopped,reason="watchpoint-scope",wpnum="5",
     frame={func="callee3",args=[{name="strarg",
     value="0x11940 \"A string argument.\""}],
     file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
     fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="18"}
     (gdb)

   Listing breakpoints and watchpoints, at different points in the
program execution.  Note that once the watchpoint goes out of scope, it
is deleted.

     (gdb)
     -break-watch C
     ^done,wpt={number="2",exp="C"}
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="2",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
     addr="0x00010734",func="callee4",
     file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
     fullname="/home/foo/devo/gdb/testsuite/gdb.mi/basics.c"line="8",times="1"},
     bkpt={number="2",type="watchpoint",disp="keep",
     enabled="y",addr="",what="C",times="0"}]}
     (gdb)
     -exec-continue
     ^running
     (gdb)
     *stopped,reason="watchpoint-trigger",wpt={number="2",exp="C"},
     value={old="-276895068",new="3"},
     frame={func="callee4",args=[],
     file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
     fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="13"}
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="2",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
     addr="0x00010734",func="callee4",
     file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
     fullname="/home/foo/devo/gdb/testsuite/gdb.mi/basics.c",line="8",times="1"},
     bkpt={number="2",type="watchpoint",disp="keep",
     enabled="y",addr="",what="C",times="-5"}]}
     (gdb)
     -exec-continue
     ^running
     ^done,reason="watchpoint-scope",wpnum="2",
     frame={func="callee3",args=[{name="strarg",
     value="0x11940 \"A string argument.\""}],
     file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
     fullname="/home/foo/bar/devo/gdb/testsuite/gdb.mi/basics.c",line="18"}
     (gdb)
     -break-list
     ^done,BreakpointTable={nr_rows="1",nr_cols="6",
     hdr=[{width="3",alignment="-1",col_name="number",colhdr="Num"},
     {width="14",alignment="-1",col_name="type",colhdr="Type"},
     {width="4",alignment="-1",col_name="disp",colhdr="Disp"},
     {width="3",alignment="-1",col_name="enabled",colhdr="Enb"},
     {width="10",alignment="-1",col_name="addr",colhdr="Address"},
     {width="40",alignment="2",col_name="what",colhdr="What"}],
     body=[bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
     addr="0x00010734",func="callee4",
     file="../../../devo/gdb/testsuite/gdb.mi/basics.c",
     fullname="/home/foo/devo/gdb/testsuite/gdb.mi/basics.c",line="8",
     times="1"}]}
     (gdb)


File: gdb.info,  Node: GDB/MI Program Context,  Next: GDB/MI Thread Commands,  Prev: GDB/MI Breakpoint Commands,  Up: GDB/MI

27.9 GDB/MI  Program Context
============================

The `-exec-arguments' Command
-----------------------------

Synopsis
........

      -exec-arguments ARGS

   Set the inferior program arguments, to be used in the next
`-exec-run'.

GDB Command
...........

The corresponding GDB command is `set args'.

Example
.......

     (gdb)
     -exec-arguments -v word
     ^done
     (gdb)

The `-environment-cd' Command
-----------------------------

Synopsis
........

      -environment-cd PATHDIR

   Set GDB's working directory.

GDB Command
...........

The corresponding GDB command is `cd'.

Example
.......

     (gdb)
     -environment-cd /kwikemart/marge/ezannoni/flathead-dev/devo/gdb
     ^done
     (gdb)

The `-environment-directory' Command
------------------------------------

Synopsis
........

      -environment-directory [ -r ] [ PATHDIR ]+

   Add directories PATHDIR to beginning of search path for source files.
If the `-r' option is used, the search path is reset to the default
search path.  If directories PATHDIR are supplied in addition to the
`-r' option, the search path is first reset and then addition occurs as
normal.  Multiple directories may be specified, separated by blanks.
Specifying multiple directories in a single command results in the
directories added to the beginning of the search path in the same order
they were presented in the command.  If blanks are needed as part of a
directory name, double-quotes should be used around the name.  In the
command output, the path will show up separated by the system
directory-separator character.  The directory-separator character must
not be used in any directory name.  If no directories are specified,
the current search path is displayed.

GDB Command
...........

The corresponding GDB command is `dir'.

Example
.......

     (gdb)
     -environment-directory /kwikemart/marge/ezannoni/flathead-dev/devo/gdb
     ^done,source-path="/kwikemart/marge/ezannoni/flathead-dev/devo/gdb:$cdir:$cwd"
     (gdb)
     -environment-directory ""
     ^done,source-path="/kwikemart/marge/ezannoni/flathead-dev/devo/gdb:$cdir:$cwd"
     (gdb)
     -environment-directory -r /home/jjohnstn/src/gdb /usr/src
     ^done,source-path="/home/jjohnstn/src/gdb:/usr/src:$cdir:$cwd"
     (gdb)
     -environment-directory -r
     ^done,source-path="$cdir:$cwd"
     (gdb)

The `-environment-path' Command
-------------------------------

Synopsis
........

      -environment-path [ -r ] [ PATHDIR ]+

   Add directories PATHDIR to beginning of search path for object files.
If the `-r' option is used, the search path is reset to the original
search path that existed at gdb start-up.  If directories PATHDIR are
supplied in addition to the `-r' option, the search path is first reset
and then addition occurs as normal.  Multiple directories may be
specified, separated by blanks.  Specifying multiple directories in a
single command results in the directories added to the beginning of the
search path in the same order they were presented in the command.  If
blanks are needed as part of a directory name, double-quotes should be
used around the name.  In the command output, the path will show up
separated by the system directory-separator character.  The
directory-separator character must not be used in any directory name.
If no directories are specified, the current path is displayed.

GDB Command
...........

The corresponding GDB command is `path'.

Example
.......

     (gdb)
     -environment-path
     ^done,path="/usr/bin"
     (gdb)
     -environment-path /kwikemart/marge/ezannoni/flathead-dev/ppc-eabi/gdb /bin
     ^done,path="/kwikemart/marge/ezannoni/flathead-dev/ppc-eabi/gdb:/bin:/usr/bin"
     (gdb)
     -environment-path -r /usr/local/bin
     ^done,path="/usr/local/bin:/usr/bin"
     (gdb)

The `-environment-pwd' Command
------------------------------

Synopsis
........

      -environment-pwd

   Show the current working directory.

GDB Command
...........

The corresponding GDB command is `pwd'.

Example
.......

     (gdb)
     -environment-pwd
     ^done,cwd="/kwikemart/marge/ezannoni/flathead-dev/devo/gdb"
     (gdb)


File: gdb.info,  Node: GDB/MI Thread Commands,  Next: GDB/MI Program Execution,  Prev: GDB/MI Program Context,  Up: GDB/MI

27.10 GDB/MI Thread Commands
============================

The `-thread-info' Command
--------------------------

Synopsis
........

      -thread-info [ THREAD-ID ]

   Reports information about either a specific thread, if the THREAD-ID
parameter is present, or about all threads.  When printing information
about all threads, also reports the current thread.

GDB Command
...........

The `info thread' command prints the same information about all threads.

Result
......

The result is a list of threads.  The following attributes are defined
for a given thread:

`current'
     This field exists only for the current thread.  It has the value
     `*'.

`id'
     The identifier that GDB uses to refer to the thread.

`target-id'
     The identifier that the target uses to refer to the thread.

`details'
     Extra information about the thread, in a target-specific format.
     This field is optional.

`name'
     The name of the thread.  If the user specified a name using the
     `thread name' command, then this name is given.  Otherwise, if GDB
     can extract the thread name from the target, then that name is
     given.  If GDB cannot find the thread name, then this field is
     omitted.

`frame'
     The stack frame currently executing in the thread.

`state'
     The thread's state.  The `state' field may have the following
     values:

    `stopped'
          The thread is stopped.  Frame information is available for
          stopped threads.

    `running'
          The thread is running.  There's no frame information for
          running threads.


`core'
     If GDB can find the CPU core on which this thread is running, then
     this field is the core identifier.  This field is optional.


Example
.......

     -thread-info
     ^done,threads=[
     {id="2",target-id="Thread 0xb7e14b90 (LWP 21257)",
        frame={level="0",addr="0xffffe410",func="__kernel_vsyscall",
                args=[]},state="running"},
     {id="1",target-id="Thread 0xb7e156b0 (LWP 21254)",
        frame={level="0",addr="0x0804891f",func="foo",
                args=[{name="i",value="10"}],
                file="/tmp/a.c",fullname="/tmp/a.c",line="158"},
                state="running"}],
     current-thread-id="1"
     (gdb)

The `-thread-list-ids' Command
------------------------------

Synopsis
........

      -thread-list-ids

   Produces a list of the currently known GDB thread ids.  At the end
of the list it also prints the total number of such threads.

   This command is retained for historical reasons, the `-thread-info'
command should be used instead.

GDB Command
...........

Part of `info threads' supplies the same information.

Example
.......

     (gdb)
     -thread-list-ids
     ^done,thread-ids={thread-id="3",thread-id="2",thread-id="1"},
     current-thread-id="1",number-of-threads="3"
     (gdb)

The `-thread-select' Command
----------------------------

Synopsis
........

      -thread-select THREADNUM

   Make THREADNUM the current thread.  It prints the number of the new
current thread, and the topmost frame for that thread.

   This command is deprecated in favor of explicitly using the
`--thread' option to each command.

GDB Command
...........

The corresponding GDB command is `thread'.

Example
.......

     (gdb)
     -exec-next
     ^running
     (gdb)
     *stopped,reason="end-stepping-range",thread-id="2",line="187",
     file="../../../devo/gdb/testsuite/gdb.threads/linux-dp.c"
     (gdb)
     -thread-list-ids
     ^done,
     thread-ids={thread-id="3",thread-id="2",thread-id="1"},
     number-of-threads="3"
     (gdb)
     -thread-select 3
     ^done,new-thread-id="3",
     frame={level="0",func="vprintf",
     args=[{name="format",value="0x8048e9c \"%*s%c %d %c\\n\""},
     {name="arg",value="0x2"}],file="vprintf.c",line="31"}
     (gdb)

