926 lines
32 KiB
Text
Executable file
926 lines
32 KiB
Text
Executable file
_dnl__ Copyright (c) 1988 1989 1990 1991 Free Software Foundation, Inc.
|
|
_dnl__ This file is part of the source for the GDB manual.
|
|
@c M4 FRAGMENT: $Id$
|
|
@node Data, Symbols, Source, Top
|
|
@chapter Examining Data
|
|
|
|
@cindex printing data
|
|
@cindex examining data
|
|
@kindex print
|
|
@kindex inspect
|
|
@c "inspect" isn't quite a synonym if you're using Epoch, which we don't
|
|
@c document because it's nonstandard... Under Epoch it displays in a
|
|
@c different window or something like that.
|
|
The usual way to examine data in your program is with the @code{print}
|
|
command (abbreviated @code{p}), or its synonym @code{inspect}. It
|
|
evaluates and prints the value of any valid expression of the language
|
|
the program is written in (for now, C or C++). You type
|
|
|
|
@example
|
|
print @var{exp}
|
|
@end example
|
|
|
|
@noindent
|
|
where @var{exp} is any valid expression (in the source language), and
|
|
the value of @var{exp} is printed in a format appropriate to its data
|
|
type.
|
|
|
|
A more low-level way of examining data is with the @code{x} command.
|
|
It examines data in memory at a specified address and prints it in a
|
|
specified format. @xref{Memory}.
|
|
|
|
@menu
|
|
* Expressions:: Expressions
|
|
* Variables:: Program Variables
|
|
* Arrays:: Artificial Arrays
|
|
* Output formats:: Output formats
|
|
* Memory:: Examining Memory
|
|
* Auto Display:: Automatic Display
|
|
* Print Settings:: Print Settings
|
|
* Value History:: Value History
|
|
* Convenience Vars:: Convenience Variables
|
|
* Registers:: Registers
|
|
* Floating Point Hardware:: Floating Point Hardware
|
|
@end menu
|
|
|
|
@node Expressions, Variables, Data, Data
|
|
@section Expressions
|
|
|
|
@cindex expressions
|
|
@code{print} and many other _GDBN__ commands accept an expression and
|
|
compute its value. Any kind of constant, variable or operator defined
|
|
by the programming language you are using is legal in an expression in
|
|
_GDBN__. This includes conditional expressions, function calls, casts
|
|
and string constants. It unfortunately does not include symbols defined
|
|
by preprocessor @code{#define} commands, or C++ expressions involving
|
|
@samp{::}, the name resolution operator.
|
|
@c FIXME: actually C++ a::b works except in obscure circumstances where it
|
|
@c FIXME...can conflict with GDB's own name scope resolution.
|
|
|
|
Casts are supported in all languages, not just in C, because it is so
|
|
useful to cast a number into a pointer so as to examine a structure
|
|
at that address in memory.
|
|
|
|
_GDBN__ supports three kinds of operator in addition to those of programming
|
|
languages:
|
|
|
|
@table @code
|
|
@item @@
|
|
@samp{@@} is a binary operator for treating parts of memory as arrays.
|
|
@xref{Arrays}, for more information.
|
|
|
|
@item ::
|
|
@samp{::} allows you to specify a variable in terms of the file or
|
|
function where it is defined. @xref{Variables}.
|
|
|
|
@item @{@var{type}@} @var{addr}
|
|
Refers to an object of type @var{type} stored at address @var{addr} in
|
|
memory. @var{addr} may be any expression whose value is an integer or
|
|
pointer (but parentheses are required around binary operators, just as in
|
|
a cast). This construct is allowed regardless of what kind of data is
|
|
normally supposed to reside at @var{addr}.@refill
|
|
@end table
|
|
|
|
@node Variables, Arrays, Expressions, Data
|
|
@section Program Variables
|
|
|
|
The most common kind of expression to use is the name of a variable
|
|
in your program.
|
|
|
|
Variables in expressions are understood in the selected stack frame
|
|
(@pxref{Selection}); they must either be global (or static) or be visible
|
|
according to the scope rules of the programming language from the point of
|
|
execution in that frame. This means that in the function
|
|
|
|
@example
|
|
foo (a)
|
|
int a;
|
|
@{
|
|
bar (a);
|
|
@{
|
|
int b = test ();
|
|
bar (b);
|
|
@}
|
|
@}
|
|
@end example
|
|
|
|
@noindent
|
|
the variable @code{a} is usable whenever the program is executing
|
|
within the function @code{foo}, but the variable @code{b} is visible
|
|
only while the program is executing inside the block in which @code{b}
|
|
is declared.
|
|
|
|
@cindex variable name conflict
|
|
There is an exception: you can refer to a variable or function whose
|
|
scope is a single source file even if the current execution point is not
|
|
in this file. But it is possible to have more than one such variable or
|
|
function with the same name (in different source files). If that happens,
|
|
referring to that name has unpredictable effects. If you wish, you can
|
|
specify a variable in a particular file, using the colon-colon notation:
|
|
|
|
@cindex colon-colon
|
|
@kindex ::
|
|
@example
|
|
@var{file}::@var{variable}
|
|
@end example
|
|
|
|
@noindent
|
|
Here @var{file} is the name of the source file whose variable you want.
|
|
|
|
@cindex C++ name resolution
|
|
This use of @samp{::} is very rarely in conflict with the very similar
|
|
use of the same notation in C++. _GDBN__ also supports use of the C++
|
|
name resolution operator in _GDBN__ expressions.
|
|
|
|
@node Arrays, Output formats, Variables, Data
|
|
@section Artificial Arrays
|
|
|
|
@cindex artificial array
|
|
@kindex @@
|
|
It is often useful to print out several successive objects of the
|
|
same type in memory; a section of an array, or an array of
|
|
dynamically determined size for which only a pointer exists in the
|
|
program.
|
|
|
|
This can be done by constructing an @dfn{artificial array} with the
|
|
binary operator @samp{@@}. The left operand of @samp{@@} should be
|
|
the first element of the desired array, as an individual object.
|
|
The right operand should be the desired length of the array. The result is
|
|
an array value whose elements are all of the type of the left argument.
|
|
The first element is actually the left argument; the second element
|
|
comes from bytes of memory immediately following those that hold the
|
|
first element, and so on. Here is an example. If a program says
|
|
|
|
@example
|
|
int *array = (int *) malloc (len * sizeof (int));
|
|
@end example
|
|
|
|
@noindent
|
|
you can print the contents of @code{array} with
|
|
|
|
@example
|
|
p *array@@len
|
|
@end example
|
|
|
|
The left operand of @samp{@@} must reside in memory. Array values made
|
|
with @samp{@@} in this way behave just like other arrays in terms of
|
|
subscripting, and are coerced to pointers when used in expressions.
|
|
Artificial arrays most often appear in expressions via the value history
|
|
(@pxref{Value History}), after printing one out.)
|
|
|
|
@node Output formats, Memory, Arrays, Data
|
|
@section Output formats
|
|
|
|
@cindex formatted output
|
|
@cindex output formats
|
|
By default, _GDBN__ prints a value according to its data type. Sometimes
|
|
this is not what you want. For example, you might want to print a number
|
|
in hex, or a pointer in decimal. Or you might want to view data in memory
|
|
at a certain address as a character string or as an instruction. To do
|
|
these things, specify an @dfn{output format} when you print a value.
|
|
|
|
The simplest use of output formats is to say how to print a value
|
|
already computed. This is done by starting the arguments of the
|
|
@code{print} command with a slash and a format letter. The format
|
|
letters supported are:
|
|
|
|
@table @code
|
|
@item x
|
|
Regard the bits of the value as an integer, and print the integer in
|
|
hexadecimal.
|
|
|
|
@item d
|
|
Print as integer in signed decimal.
|
|
|
|
@item u
|
|
Print as integer in unsigned decimal.
|
|
|
|
@item o
|
|
Print as integer in octal.
|
|
|
|
@item t
|
|
Print as integer in binary. The letter @samp{t} stands for ``two''.
|
|
|
|
@item a
|
|
Print as an address, both absolute in hex and as an offset from the
|
|
nearest preceding symbol. This format can be used to discover where (in
|
|
what function) an unknown address is located:
|
|
@example
|
|
(_GDBP__) p/a 0x54320
|
|
_0__$3 = 0x54320 <_initialize_vx+396>_1__
|
|
@end example
|
|
|
|
|
|
@item c
|
|
Regard as an integer and print it as a character constant.
|
|
|
|
@item f
|
|
Regard the bits of the value as a floating point number and print
|
|
using typical floating point syntax.
|
|
@end table
|
|
|
|
For example, to print the program counter in hex (@pxref{Registers}), type
|
|
|
|
@example
|
|
p/x $pc
|
|
@end example
|
|
|
|
@noindent
|
|
Note that no space is required before the slash; this is because command
|
|
names in _GDBN__ cannot contain a slash.
|
|
|
|
To reprint the last value in the value history with a different format,
|
|
you can use the @code{print} command with just a format and no
|
|
expression. For example, @samp{p/x} reprints the last value in hex.
|
|
|
|
@node Memory, Auto Display, Output formats, Data
|
|
@section Examining Memory
|
|
|
|
@cindex examining memory
|
|
@table @code
|
|
@kindex x
|
|
@item x/@var{nfu} @var{expr}
|
|
The command @code{x} (for `examine') can be used to examine memory
|
|
without being constrained by your program's data types. You can specify
|
|
the unit size @var{u} of memory to inspect, and a repeat count @var{n} of how
|
|
many of those units to display. @code{x} understands the formats
|
|
@var{f} used by @code{print}; two additional formats, @samp{s} (string)
|
|
and @samp{i} (machine instruction) can be used without specifying a unit
|
|
size.
|
|
@end table
|
|
|
|
For example, @samp{x/3uh 0x54320} is a request to display three halfwords
|
|
(@code{h}) of memory, formatted as unsigned decimal integers (@samp{u}),
|
|
starting at address @code{0x54320}. @samp{x/4xw $sp} prints the four
|
|
words (@samp{w}) of memory above the stack pointer (here, @samp{$sp};
|
|
@pxref{Registers}) in hexadecimal (@samp{x}).
|
|
|
|
Since the letters indicating unit sizes are all distinct from the
|
|
letters specifying output formats, you don't have to remember whether
|
|
unit size or format comes first; either order will work. The output
|
|
specifications @samp{4xw} and @samp{4wx} mean exactly the same thing.
|
|
|
|
After the format specification, you supply an expression for the address
|
|
where _GDBN__ is to begin reading from memory. The expression need not
|
|
have a pointer value (though it may); it is always interpreted as an
|
|
integer address of a byte of memory. @xref{Expressions} for more
|
|
information on expressions.
|
|
|
|
These are the memory units @var{u} you can specify with the @code{x}
|
|
command:
|
|
|
|
@table @code
|
|
@item b
|
|
Examine individual bytes.
|
|
|
|
@item h
|
|
Examine halfwords (two bytes each).
|
|
|
|
@item w
|
|
Examine words (four bytes each).
|
|
|
|
@cindex word
|
|
Many assemblers and cpu designers still use `word' for a 16-bit quantity,
|
|
as a holdover from specific predecessor machines of the 1970's that really
|
|
did use two-byte words. But more generally the term `word' has always
|
|
referred to the size of quantity that a machine normally operates on and
|
|
stores in its registers. This is 32 bits for all the machines that _GDBN__
|
|
runs on.
|
|
|
|
@item g
|
|
Examine giant words (8 bytes).
|
|
@end table
|
|
|
|
You can combine these unit specifications with any of the formats
|
|
described for @code{print}. @xref{Output formats}.
|
|
|
|
@code{x} has two additional output specifications which derive the unit
|
|
size from the data inspected:
|
|
|
|
@table @code
|
|
@item s
|
|
Print a null-terminated string of characters. Any explicitly specified
|
|
unit size is ignored; instead, the unit is however many bytes it takes
|
|
to reach a null character (including the null character).
|
|
|
|
@item i
|
|
Print a machine instruction in assembler syntax (or nearly). Any
|
|
specified unit size is ignored; the number of bytes in an instruction
|
|
varies depending on the type of machine, the opcode and the addressing
|
|
modes used. The command @code{disassemble} gives an alternative way of
|
|
inspecting machine instructions. @xref{Machine Code}.
|
|
@end table
|
|
|
|
If you omit either the format @var{f} or the unit size @var{u}, @code{x}
|
|
will use the same one that was used last. If you don't use any letters
|
|
or digits after the slash, you can omit the slash as well.
|
|
|
|
You can also omit the address to examine. Then the address used is just
|
|
after the last unit examined. This is why string and instruction
|
|
formats actually compute a unit-size based on the data: so that the next
|
|
string or instruction examined will start in the right place.
|
|
|
|
When the @code{print} command shows a value that resides in memory,
|
|
@code{print} also sets the default address for the @code{x} command.
|
|
@code{info line} also sets the default for @code{x}, to the address of
|
|
the start of the machine code for the specified line (@pxref{Machine
|
|
Code}), and @code{info breakpoints} sets it to the address of the last
|
|
breakpoint listed (@pxref{Set Breaks}).
|
|
|
|
When you use @key{RET} to repeat an @code{x} command, the address
|
|
specified previously (if any) is ignored, so that the repeated command
|
|
examines the successive locations in memory rather than the same ones.
|
|
|
|
You can examine several consecutive units of memory with one command by
|
|
writing a repeat-count after the slash (before the format letters, if
|
|
any). Omitting the repeat count @var{n} displays one unit of the
|
|
appropriate size. The repeat count must be a decimal integer. It has
|
|
the same effect as repeating the @code{x} command @var{n} times except
|
|
that the output may be more compact, with several units per line. For
|
|
example,
|
|
|
|
@example
|
|
x/10i $pc
|
|
@end example
|
|
|
|
@noindent
|
|
prints ten instructions starting with the one to be executed next in the
|
|
selected frame. After doing this, you could print a further seven
|
|
instructions with
|
|
|
|
@example
|
|
x/7
|
|
@end example
|
|
|
|
@noindent
|
|
---where the format and address are allowed to default.
|
|
|
|
@kindex $_
|
|
@kindex $__
|
|
The addresses and contents printed by the @code{x} command are not put
|
|
in the value history because there is often too much of them and they
|
|
would get in the way. Instead, _GDBN__ makes these values available for
|
|
subsequent use in expressions as values of the convenience variables
|
|
@code{$_} and @code{$__}. After an @code{x} command, the last address
|
|
examined is available for use in expressions in the convenience variable
|
|
@code{$_}. The contents of that address, as examined, are available in
|
|
the convenience variable @code{$__}.
|
|
|
|
If the @code{x} command has a repeat count, the address and contents saved
|
|
are from the last memory unit printed; this is not the same as the last
|
|
address printed if several units were printed on the last line of output.
|
|
|
|
@node Auto Display, Print Settings, Memory, Data
|
|
@section Automatic Display
|
|
@cindex automatic display
|
|
@cindex display of expressions
|
|
|
|
If you find that you want to print the value of an expression frequently
|
|
(to see how it changes), you might want to add it to the @dfn{automatic
|
|
display list} so that _GDBN__ will print its value each time the program stops.
|
|
Each expression added to the list is given a number to identify it;
|
|
to remove an expression from the list, you specify that number.
|
|
The automatic display looks like this:
|
|
|
|
@example
|
|
2: foo = 38
|
|
3: bar[5] = (struct hack *) 0x3804
|
|
@end example
|
|
|
|
@noindent
|
|
showing item numbers, expressions and their current values. As with
|
|
displays you request manually using @code{x} or @code{print}, you can
|
|
specify the output format you prefer; in fact, @code{display} decides
|
|
whether to use @code{print} or @code{x} depending on how elaborate your
|
|
format specification is---it uses @code{x} if you specify a unit size,
|
|
or one of the two formats (@samp{i} and @samp{s}) that are only
|
|
supported by @code{x}; otherwise it uses @code{print}.
|
|
|
|
@table @code
|
|
@item display @var{exp}
|
|
@kindex display
|
|
Add the expression @var{exp} to the list of expressions to display
|
|
each time the program stops. @xref{Expressions}.
|
|
|
|
@code{display} will not repeat if you press @key{RET} again after using it.
|
|
|
|
@item display/@var{fmt} @var{exp}
|
|
For @var{fmt} specifying only a display format and not a size or
|
|
count, add the expression @var{exp} to the auto-display list but
|
|
arranges to display it each time in the specified format @var{fmt}.
|
|
@xref{Output formats}.
|
|
|
|
@item display/@var{fmt} @var{addr}
|
|
For @var{fmt} @samp{i} or @samp{s}, or including a unit-size or a
|
|
number of units, add the expression @var{addr} as a memory address to
|
|
be examined each time the program stops. Examining means in effect
|
|
doing @samp{x/@var{fmt} @var{addr}}. @xref{Memory}.
|
|
@end table
|
|
|
|
For example, @samp{display/i $pc} can be helpful, to see the machine
|
|
instruction about to be executed each time execution stops (@samp{$pc}
|
|
is a common name for the program counter; @pxref{Registers}).
|
|
|
|
@table @code
|
|
@item undisplay @var{dnums}@dots{}
|
|
@itemx delete display @var{dnums}@dots{}
|
|
@kindex delete display
|
|
@kindex undisplay
|
|
Remove item numbers @var{dnums} from the list of expressions to display.
|
|
|
|
@code{undisplay} will not repeat if you press @key{RET} after using it.
|
|
(Otherwise you would just get the error @samp{No display number @dots{}}.)
|
|
|
|
@item disable display @var{dnums}@dots{}
|
|
@kindex disable display
|
|
Disable the display of item numbers @var{dnums}. A disabled display
|
|
item is not printed automatically, but is not forgotten. It may be
|
|
enabled again later.
|
|
|
|
@item enable display @var{dnums}@dots{}
|
|
@kindex enable display
|
|
Enable display of item numbers @var{dnums}. It becomes effective once
|
|
again in auto display of its expression, until you specify otherwise.
|
|
|
|
@item display
|
|
Display the current values of the expressions on the list, just as is
|
|
done when the program stops.
|
|
|
|
@item info display
|
|
@kindex info display
|
|
Print the list of expressions previously set up to display
|
|
automatically, each one with its item number, but without showing the
|
|
values. This includes disabled expressions, which are marked as such.
|
|
It also includes expressions which would not be displayed right now
|
|
because they refer to automatic variables not currently available.
|
|
@end table
|
|
|
|
If a display expression refers to local variables, then it does not make
|
|
sense outside the lexical context for which it was set up. Such an
|
|
expression is disabled when execution enters a context where one of its
|
|
variables is not defined. For example, if you give the command
|
|
@code{display last_char} while inside a function with an argument
|
|
@code{last_char}, then this argument will be displayed while the program
|
|
continues to stop inside that function. When it stops elsewhere---where
|
|
there is no variable @code{last_char}---display is disabled. The next time
|
|
your program stops where @code{last_char} is meaningful, you can enable the
|
|
display expression once again.
|
|
|
|
@node Print Settings, Value History, Auto Display, Data
|
|
@section Print Settings
|
|
|
|
@cindex format options
|
|
@cindex print settings
|
|
_GDBN__ provides the following ways to control how arrays, structures,
|
|
and symbols are printed.
|
|
|
|
@noindent
|
|
These settings are useful for debugging programs in any language:
|
|
|
|
@table @code
|
|
@item set print address
|
|
@item set print address on
|
|
@kindex set print address
|
|
_GDBN__ will print memory addresses showing the location of stack
|
|
traces, structure values, pointer values, breakpoints, and so forth,
|
|
even when it also displays the contents of those addresses. The default
|
|
is on. For example, this is what a stack frame display looks like, with
|
|
@code{set print address on}:
|
|
@smallexample
|
|
(_GDBP__) f
|
|
#0 set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>")
|
|
at input.c:530
|
|
530 if (lquote != def_lquote)
|
|
@end smallexample
|
|
|
|
@item set print address off
|
|
Do not print addresses when displaying their contents. For example,
|
|
this is the same stack frame displayed with @code{set print address off}:
|
|
@example
|
|
(_GDBP__) set print addr off
|
|
(_GDBP__) f
|
|
#0 set_quotes (lq="<<", rq=">>") at input.c:530
|
|
530 if (lquote != def_lquote)
|
|
@end example
|
|
|
|
@item show print address
|
|
@kindex show print address
|
|
Show whether or not addresses are to be printed.
|
|
|
|
@item set print array
|
|
@itemx set print array on
|
|
@kindex set print array
|
|
_GDBN__ will pretty print arrays. This format is more convenient to read,
|
|
but uses more space. The default is off.
|
|
|
|
@item set print array off.
|
|
Return to compressed format for arrays.
|
|
|
|
@item show print array
|
|
@kindex show print array
|
|
Show whether compressed or pretty format is selected for displaying
|
|
arrays.
|
|
|
|
@item set print elements @var{number-of-elements}
|
|
@kindex set print elements
|
|
If _GDBN__ is printing a large array, it will stop printing after it has
|
|
printed the number of elements set by the @code{set print elements} command.
|
|
This limit also applies to the display of strings.
|
|
|
|
@item show print elements
|
|
@kindex show print elements
|
|
Display the number of elements of a large array that _GDBN__ will print
|
|
before losing patience.
|
|
|
|
@item set print pretty on
|
|
@kindex set print pretty
|
|
Cause _GDBN__ to print structures in an indented format with one member per
|
|
line, like this:
|
|
|
|
@example
|
|
$1 = @{
|
|
next = 0x0,
|
|
flags = @{
|
|
sweet = 1,
|
|
sour = 1
|
|
@},
|
|
meat = 0x54 "Pork"
|
|
@}
|
|
@end example
|
|
|
|
@item set print pretty off
|
|
Cause _GDBN__ to print structures in a compact format, like this:
|
|
|
|
@smallexample
|
|
$1 = @{next = 0x0, flags = @{sweet = 1, sour = 1@}, meat \
|
|
= 0x54 "Pork"@}
|
|
@end smallexample
|
|
|
|
@noindent
|
|
This is the default format.
|
|
|
|
@item show print pretty
|
|
@kindex show print pretty
|
|
Show which format _GDBN__ will use to print structures.
|
|
|
|
@item set print sevenbit-strings on
|
|
Print using only seven-bit characters; if this option is set,
|
|
_GDBN__ will display any eight-bit characters (in strings or character
|
|
values) using the notation @code{\}@var{nnn}. For example, @kbd{M-a} is
|
|
displayed as @code{\341}.
|
|
|
|
@item set print sevenbit-strings off
|
|
Print using either seven-bit or eight-bit characters, as required. This
|
|
is the default.
|
|
|
|
@item show print sevenbit-strings
|
|
Show whether or not _GDBN__ will print only seven-bit characters.
|
|
|
|
@item set print union on
|
|
@kindex set print union
|
|
Tell _GDBN__ to print unions which are contained in structures. This is the
|
|
default setting.
|
|
|
|
@item set print union off
|
|
Tell _GDBN__ not to print unions which are contained in structures.
|
|
|
|
@item show print union
|
|
@kindex show print union
|
|
Ask _GDBN__ whether or not it will print unions which are contained in
|
|
structures.
|
|
|
|
For example, given the declarations
|
|
|
|
@smallexample
|
|
typedef enum @{Tree, Bug@} Species;
|
|
typedef enum @{Big_tree, Acorn, Seedling@} Tree_forms;
|
|
typedef enum @{Caterpillar, Cocoon, Butterfly@} Bug_forms;
|
|
|
|
struct thing @{
|
|
Species it;
|
|
union @{
|
|
Tree_forms tree;
|
|
Bug_forms bug;
|
|
@} form;
|
|
@};
|
|
|
|
struct thing foo = @{Tree, @{Acorn@}@};
|
|
@end smallexample
|
|
|
|
@noindent
|
|
with @code{set print union on} in effect @samp{p foo} would print
|
|
|
|
@smallexample
|
|
$1 = @{it = Tree, form = @{tree = Acorn, bug = Cocoon@}@}
|
|
@end smallexample
|
|
|
|
@noindent
|
|
and with @code{set print union off} in effect it would print
|
|
|
|
@smallexample
|
|
$1 = @{it = Tree, form = @{...@}@}
|
|
@end smallexample
|
|
@end table
|
|
|
|
@noindent
|
|
These settings are of interest when debugging C++ programs:
|
|
|
|
@table @code
|
|
@item set print demangle
|
|
@itemx set print demangle on
|
|
@kindex set print demangle
|
|
Print C++ names in their source form rather than in the mangled form
|
|
in which they are passed to the assembler and linker for type-safe linkage.
|
|
The default is on.
|
|
|
|
@item show print demangle
|
|
@kindex show print demangle
|
|
Show whether C++ names will be printed in mangled or demangled form.
|
|
|
|
@item set print asm-demangle
|
|
@itemx set print asm-demangle on
|
|
@kindex set print asm-demangle
|
|
Print C++ names in their source form rather than their mangled form, even
|
|
in assembler code printouts such as instruction disassemblies.
|
|
The default is off.
|
|
|
|
@item show print asm-demangle
|
|
@kindex show print asm-demangle
|
|
Show whether C++ names in assembly listings will be printed in mangled
|
|
or demangled form.
|
|
|
|
@item set print object
|
|
@itemx set print object on
|
|
@kindex set print object
|
|
When displaying a pointer to an object, identify the @emph{actual}
|
|
(derived) type of the object rather than the @emph{declared} type, using
|
|
the virtual function table.
|
|
|
|
@item set print object off
|
|
Display only the declared type of objects, without reference to the
|
|
virtual function table. This is the default setting.
|
|
|
|
@item show print object
|
|
@kindex show print object
|
|
Show whether actual, or declared, object types will be displayed.
|
|
|
|
@item set print vtbl
|
|
@itemx set print vtbl on
|
|
@kindex set print vtbl
|
|
Pretty print C++ virtual function tables. The default is off.
|
|
|
|
@item set print vtbl off
|
|
Do not pretty print C++ virtual function tables.
|
|
|
|
@item show print vtbl
|
|
@kindex show print vtbl
|
|
Show whether C++ virtual function tables are pretty printed, or not.
|
|
|
|
@end table
|
|
|
|
@node Value History, Convenience Vars, Print Settings, Data
|
|
@section Value History
|
|
|
|
@cindex value history
|
|
Values printed by the @code{print} command are saved in _GDBN__'s @dfn{value
|
|
history} so that you can refer to them in other expressions. Values are
|
|
kept until the symbol table is re-read or discarded (for example with
|
|
the @code{file} or @code{symbol-file} commands). When the symbol table
|
|
changes, the value history is discarded, since the values may contain
|
|
pointers back to the types defined in the symbol table.
|
|
|
|
@cindex @code{$}
|
|
@cindex @code{$$}
|
|
@cindex history number
|
|
The values printed are given @dfn{history numbers} for you to refer to them
|
|
by. These are successive integers starting with one. @code{print} shows you
|
|
the history number assigned to a value by printing @samp{$@var{num} = }
|
|
before the value; here @var{num} is the history number.
|
|
|
|
To refer to any previous value, use @samp{$} followed by the value's
|
|
history number. The way @code{print} labels its output is designed to
|
|
remind you of this. Just @code{$} refers to the most recent value in
|
|
the history, and @code{$$} refers to the value before that.
|
|
@code{$$@var{n}} refers to the @var{n}th value from the end; @code{$$2}
|
|
is the value just prior to @code{$$}, @code{$$1} is equivalent to
|
|
@code{$$}, and @code{$$0} is equivalent to @code{$}.
|
|
|
|
For example, suppose you have just printed a pointer to a structure and
|
|
want to see the contents of the structure. It suffices to type
|
|
|
|
@example
|
|
p *$
|
|
@end example
|
|
|
|
If you have a chain of structures where the component @code{next} points
|
|
to the next one, you can print the contents of the next one with this:
|
|
|
|
@example
|
|
p *$.next
|
|
@end example
|
|
|
|
@noindent
|
|
You can print successive links in the chain by repeating this
|
|
command---which you can do by just typing @key{RET}.
|
|
|
|
Note that the history records values, not expressions. If the value of
|
|
@code{x} is 4 and you type these commands:
|
|
|
|
@example
|
|
print x
|
|
set x=5
|
|
@end example
|
|
|
|
@noindent
|
|
then the value recorded in the value history by the @code{print} command
|
|
remains 4 even though the value of @code{x} has changed.
|
|
|
|
@table @code
|
|
@kindex show values
|
|
@item show values
|
|
Print the last ten values in the value history, with their item numbers.
|
|
This is like @samp{p@ $$9} repeated ten times, except that @code{show
|
|
values} does not change the history.
|
|
|
|
@item show values @var{n}
|
|
Print ten history values centered on history item number @var{n}.
|
|
|
|
@item show values +
|
|
Print ten history values just after the values last printed. If no more
|
|
values are available, produces no display.
|
|
@end table
|
|
|
|
Pressing @key{RET} to repeat @code{show values @var{n}} has exactly the
|
|
same effect as @samp{show values +}.
|
|
|
|
@node Convenience Vars, Registers, Value History, Data
|
|
@section Convenience Variables
|
|
|
|
@cindex convenience variables
|
|
_GDBN__ provides @dfn{convenience variables} that you can use within
|
|
_GDBN__ to hold on to a value and refer to it later. These variables
|
|
exist entirely within _GDBN__; they are not part of your program, and
|
|
setting a convenience variable has no direct effect on further execution
|
|
of your program. That's why you can use them freely.
|
|
|
|
Convenience variables are prefixed with @samp{$}. Any name preceded by
|
|
@samp{$} can be used for a convenience variable, unless it is one of
|
|
the predefined machine-specific register names (@pxref{Registers}).
|
|
(Value history references, in contrast, are @emph{numbers} preceded
|
|
by @samp{$}. @xref{Value History}.)
|
|
|
|
You can save a value in a convenience variable with an assignment
|
|
expression, just as you would set a variable in your program. Example:
|
|
|
|
@example
|
|
set $foo = *object_ptr
|
|
@end example
|
|
|
|
@noindent
|
|
would save in @code{$foo} the value contained in the object pointed to by
|
|
@code{object_ptr}.
|
|
|
|
Using a convenience variable for the first time creates it; but its value
|
|
is @code{void} until you assign a new value. You can alter the value with
|
|
another assignment at any time.
|
|
|
|
Convenience variables have no fixed types. You can assign a convenience
|
|
variable any type of value, including structures and arrays, even if
|
|
that variable already has a value of a different type. The convenience
|
|
variable, when used as an expression, has the type of its current value.
|
|
|
|
@table @code
|
|
@item show convenience
|
|
@kindex show convenience
|
|
Print a list of convenience variables used so far, and their values.
|
|
Abbreviated @code{show con}.
|
|
@end table
|
|
|
|
One of the ways to use a convenience variable is as a counter to be
|
|
incremented or a pointer to be advanced. For example, to print
|
|
a field from successive elements of an array of structures:
|
|
|
|
_0__@example
|
|
set $i = 0
|
|
print bar[$i++]->contents
|
|
@i{@dots{} repeat that command by typing @key{RET}.}
|
|
_1__@end example
|
|
|
|
Some convenience variables are created automatically by _GDBN__ and given
|
|
values likely to be useful.
|
|
|
|
@table @code
|
|
@item $_
|
|
The variable @code{$_} is automatically set by the @code{x} command to
|
|
the last address examined (@pxref{Memory}). Other commands which
|
|
provide a default address for @code{x} to examine also set @code{$_}
|
|
to that address; these commands include @code{info line} and @code{info
|
|
breakpoint}.
|
|
|
|
@item $__
|
|
The variable @code{$__} is automatically set by the @code{x} command
|
|
to the value found in the last address examined.
|
|
@end table
|
|
|
|
@node Registers, Floating Point Hardware, Convenience Vars, Data
|
|
@section Registers
|
|
|
|
@cindex registers
|
|
Machine register contents can be referred to in expressions as variables
|
|
with names starting with @samp{$}. The names of registers are different
|
|
for each machine; use @code{info registers} to see the names used on
|
|
your machine.
|
|
|
|
@table @code
|
|
@item info registers
|
|
@kindex info registers
|
|
Print the names and values of all registers (in the selected stack frame).
|
|
|
|
@item info registers @var{regname}
|
|
Print the relativized value of register @var{regname}. @var{regname}
|
|
may be any register name valid on the machine you are using, with
|
|
or without the initial @samp{$}.
|
|
@end table
|
|
|
|
The register names @code{$pc} and @code{$sp} are used on most machines
|
|
for the program counter register and the stack pointer. For example,
|
|
you could print the program counter in hex with
|
|
@example
|
|
p/x $pc
|
|
@end example
|
|
|
|
@noindent
|
|
or print the instruction to be executed next with
|
|
@example
|
|
x/i $pc
|
|
@end example
|
|
|
|
@noindent
|
|
or add four to the stack pointer with
|
|
@example
|
|
set $sp += 4
|
|
@end example
|
|
|
|
@noindent
|
|
The last is a way of removing one word from the stack, on machines where
|
|
stacks grow downward in memory (most machines, nowadays). This assumes
|
|
that the innermost stack frame is selected; setting @code{$sp} is
|
|
not allowed when other stack frames are selected. (To pop entire frames
|
|
off the stack, regardless of machine architecture, use @code{return};
|
|
@pxref{Returning}.)
|
|
|
|
Often @code{$fp} is used for a register that contains a pointer to the
|
|
current stack frame, and @code{$ps} is sometimes used for a register
|
|
that contains the processor status. These standard register names may
|
|
be available on your machine even though the @code{info registers}
|
|
command shows other names. For example, on the SPARC, @code{info
|
|
registers} displays the processor status register as @code{$psr} but you
|
|
can also refer to it as @code{$ps}.
|
|
|
|
_GDBN__ always considers the contents of an ordinary register as an
|
|
integer when the register is examined in this way. Some machines have
|
|
special registers which can hold nothing but floating point; these
|
|
registers are considered to have floating point values. There is no way
|
|
to refer to the contents of an ordinary register as floating point value
|
|
(although you can @emph{print} it as a floating point value with
|
|
@samp{print/f $@var{regname}}).
|
|
|
|
Some registers have distinct ``raw'' and ``virtual'' data formats. This
|
|
means that the data format in which the register contents are saved by
|
|
the operating system is not the same one that your program normally
|
|
sees. For example, the registers of the 68881 floating point
|
|
coprocessor are always saved in ``extended'' (raw) format, but all C
|
|
programs expect to work with ``double'' (virtual) format. In such
|
|
cases, _GDBN__ normally works with the virtual format only (the format that
|
|
makes sense for your program), but the @code{info registers} command
|
|
prints the data in both formats.
|
|
|
|
Normally, register values are relative to the selected stack frame
|
|
(@pxref{Selection}). This means that you get the value that the
|
|
register would contain if all stack frames farther in were exited and
|
|
their saved registers restored. In order to see the true contents of
|
|
hardware registers, you must select the innermost frame (with
|
|
@samp{frame 0}).
|
|
|
|
However, _GDBN__ must deduce where registers are saved, from the machine
|
|
code generated by your compiler. If some registers are not saved, or if
|
|
_GDBN__ is unable to locate the saved registers, the selected stack
|
|
frame will make no difference.
|
|
|
|
@node Floating Point Hardware, , Registers, Data
|
|
@section Floating Point Hardware
|
|
@cindex floating point
|
|
Depending on the host machine architecture, _GDBN__ may be able to give
|
|
you more information about the status of the floating point hardware.
|
|
|
|
@table @code
|
|
@item info float
|
|
@kindex info float
|
|
If available, provides hardware-dependent information about the floating
|
|
point unit. The exact contents and layout vary depending on the
|
|
floating point chip.
|
|
@end table
|
|
@c FIXME: this is a cop-out. Try to get examples, explanations. Only
|
|
@c FIXME...supported currently on arm's and 386's. Mark properly with
|
|
@c FIXME... m4 macros to isolate general statements from hardware-dep,
|
|
@c FIXME... at that point.
|