blob: 616057d323778ec959acfe253d70cf4edaec17ab [file] [log] [blame]
This is gdb.info, produced by makeinfo version 4.8 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 Ninth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (GDB) Version 7.2.
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: 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 whenever GDB detects
such pattern in a condition expression. This feature is available in
native GDB running on a Linux kernel version 2.6.34 or newer.
GDB provides the following PowerPC-specific commands:
`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.
`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 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 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 operate interactively. If `off', forces
GDB to operate non-interactively, If `auto' (the default), GDB
guesses which mode to use, based on whether the debugger was
started in a terminal or not.
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.

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::
* Values From Inferior::
* Types In Python:: Python representation of types.
* Pretty Printing API:: Pretty-printing values.
* Selecting Pretty-Printers:: How GDB chooses a pretty-printer.
* Disabling Pretty-Printers:: Disabling broken printers.
* Inferiors In Python:: Python representation of inferiors (processes)
* 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
`RuntimeError'. 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 `RuntimeError' 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: write string
Print a string to GDB's paginated standard output stream. Writing
to `sys.stdout' or `sys.stderr' will automatically call this
function.
-- Function: flush
Flush GDB's paginated standard output stream. Flushing
`sys.stdout' or `sys.stderr' will automatically call this function.
-- 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.

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 `RuntimeError' exceptions. User interrupt (via
`C-c' or by typing `q' at a pagination prompt) is translated to a
Python `KeyboardInterrupt' exception. If you catch these exceptions in
your Python code, your exception handler will see `RuntimeError' or
`KeyboardInterrupt' as the exception type, 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.
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.
The following methods are provided:
-- 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: 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: 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
`RuntimeError' exception.
-- 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.

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: Disabling Pretty-Printers, 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. Each `gdb.Progspace' contains a `pretty_printers'
attribute. Each `gdb.Objfile' also contains a `pretty_printers'
attribute.
A function on one of 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 function (*note Disabling Pretty-Printers::) 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.
Here is an example showing how a `std::string' printer might be
written:
class StdStringPrinter:
"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
regex = re.compile ("^std::basic_string<char,.*>$")
if lookup_tag == None:
return None
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 ())

File: gdb.info, Node: Disabling Pretty-Printers, Next: Inferiors In Python, Prev: Selecting Pretty-Printers, Up: Python API
23.2.2.7 Disabling Pretty-Printers