Next: Optimized Code, Previous: Source, Up: Top
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 (see Using gdb with Different Languages). It may also print the expression using a
Python-based pretty-printer (see Pretty Printing).
print
exprprint /
f exprprint
print /
fA 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. See Examining 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
. See Examining the Symbol Table.
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
argThe 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
exprexplore
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
argexplore
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.