gdb: Data
10 Examining Data
*****************
The usual way to examine data in your program is with the 'print'
command (abbreviated 'p'), or its synonym 'inspect'. It evaluates and
prints the value of an expression of the language your program is
written in (
Using GDB with Different Languages Languages.). It
may also print the expression using a Python-based pretty-printer (
Pretty Printing).
'print EXPR'
'print /F EXPR'
EXPR is an expression (in the source language). By default the
value of EXPR is printed in a format appropriate to its data type;
you can choose a different format by specifying '/F', where F is a
letter specifying the format; see Output Formats Output
Formats.
'print'
'print /F'
If you omit EXPR, GDB displays the last value again (from the
"value history"; Value History Value History.). This allows
you to conveniently inspect the same value in an alternative
format.
A more low-level way of examining data is with the 'x' command. It
examines data in memory at a specified address and prints it in a
specified format. Examining Memory Memory.
If you are interested in information about types, or about how the
fields of a struct or a class are declared, use the 'ptype EXP' command
rather than 'print'. Examining the Symbol Table Symbols.
Another way of examining values of expressions and type information
is through the Python extension command 'explore' (available only if the
GDB build is configured with '--with-python'). It offers an interactive
way to start at the highest level (or, the most abstract level) of the
data type of an expression (or, the data type itself) and explore all
the way down to leaf scalar values/fields embedded in the higher level
data types.
'explore ARG'
ARG is either an expression (in the source language), or a type
visible in the current context of the program being debugged.
The working of the 'explore' command can be illustrated with an
example. If a data type 'struct ComplexStruct' is defined in your C
program as
struct SimpleStruct
{
int i;
double d;
};
struct ComplexStruct
{
struct SimpleStruct *ss_p;
int arr[10];
};
followed by variable declarations as
struct SimpleStruct ss = { 10, 1.11 };
struct ComplexStruct cs = { &ss, { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
then, the value of the variable 'cs' can be explored using the 'explore'
command as follows.
(gdb) explore cs
The value of `cs' is a struct/class of type `struct ComplexStruct' with
the following fields:
ss_p = <Enter 0 to explore this field of type `struct SimpleStruct *'>
arr = <Enter 1 to explore this field of type `int [10]'>
Enter the field number of choice:
Since the fields of 'cs' are not scalar values, you are being prompted
to chose the field you want to explore. Let's say you choose the field
'ss_p' by entering '0'. Then, since this field is a pointer, you will
be asked if it is pointing to a single value. From the declaration of
'cs' above, it is indeed pointing to a single value, hence you enter
'y'. If you enter 'n', then you will be asked if it were pointing to an
array of values, in which case this field will be explored as if it were
an array.
`cs.ss_p' is a pointer to a value of type `struct SimpleStruct'
Continue exploring it as a pointer to a single value [y/n]: y
The value of `*(cs.ss_p)' is a struct/class of type `struct
SimpleStruct' with the following fields:
i = 10 .. (Value of type `int')
d = 1.1100000000000001 .. (Value of type `double')
Press enter to return to parent value:
If the field 'arr' of 'cs' was chosen for exploration by entering '1'
earlier, then since it is as array, you will be prompted to enter the
index of the element in the array that you want to explore.
`cs.arr' is an array of `int'.
Enter the index of the element you want to explore in `cs.arr': 5
`(cs.arr)[5]' is a scalar value of type `int'.
(cs.arr)[5] = 4
Press enter to return to parent value:
In general, at any stage of exploration, you can go deeper towards
the leaf values by responding to the prompts appropriately, or hit the
return key to return to the enclosing data structure (the higher level
data structure).
Similar to exploring values, you can use the 'explore' command to
explore types. Instead of specifying a value (which is typically a
variable name or an expression valid in the current context of the
program being debugged), you specify a type name. If you consider the
same example as above, your can explore the type 'struct ComplexStruct'
by passing the argument 'struct ComplexStruct' to the 'explore' command.
(gdb) explore struct ComplexStruct
By responding to the prompts appropriately in the subsequent interactive
session, you can explore the type 'struct ComplexStruct' in a manner
similar to how the value 'cs' was explored in the above example.
The 'explore' command also has two sub-commands, 'explore value' and
'explore type'. The former sub-command is a way to explicitly specify
that value exploration of the argument is being invoked, while the
latter is a way to explicitly specify that type exploration of the
argument is being invoked.
'explore value EXPR'
This sub-command of 'explore' explores the value of the expression
EXPR (if EXPR is an expression valid in the current context of the
program being debugged). The behavior of this command is identical
to that of the behavior of the 'explore' command being passed the
argument EXPR.
'explore type ARG'
This sub-command of 'explore' explores the type of ARG (if ARG is a
type visible in the current context of program being debugged), or
the type of the value/expression ARG (if ARG is an expression valid
in the current context of the program being debugged). If ARG is a
type, then the behavior of this command is identical to that of the
'explore' command being passed the argument ARG. If ARG is an
expression, then the behavior of this command will be identical to
that of the 'explore' command being passed the type of ARG as the
argument.
Menu
Info Catalog
gdb: Source
gdb: Top
gdb: Optimized Code