Data - Debugging with GDB
Description: Debugging with GDB

Next: Optimized Code, Previous: Source, Up: Top

## 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 (see Using gdb with Different Languages). It may also print the expression using a Python-based pretty-printer (see 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.
`print`
`print /`f
  If you omit expr, gdb displays the last value again (from the value history; see 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. 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` 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.