17.4. GDB Expressions

GDB can be thought of as a specialized programming language. It has variables and operators similar to those of C, and special features for debugging. This section looks at the different kinds of expressions that GDB understands.

17.4.1. The Value History

Every time you print a value with print, GDB saves the value in the value history . You can reference these saved values by their numeric place in the history, preceded with a $. GDB reminds you of this by printing $n = val. For example:

     $ gdb whizprog     ...     (gdb) print stopped_early     $1 = 0     (gdb) print whiny_users     $2 = TRUE     (gdb)

A plain $ refers to the most recent value in the value history. This can save considerable typing. If you've just looked at a pointer variable, you can use:

     (gdb) print *$

to print the contents of whatever the pointer is pointing to. $$ refers to the next most recent value in the history, and $$n refers to the value n places from the end. (Thus, $n counts from the beginning, while $$n counts from the end.)

You can use show values to see the values in the history. Whenever GDB reloads the executable (rereads the symbol table), it clears the value history. This is because the value history may have contained pointers into the symbol table and such pointers become invalid when the symbol table is reloaded.

17.4.2. Convenience Variables and Machine Registers

GDB lets you create convenience variables . These are variables you can use to store values as you need them. Their names begin with a $ and consist of alphanumeric characters and underscores. They should start with a letter or underscore. (Note that values in the value history have names that are numeric.) You might want to use a convenience variable as an array index:

     (gdb) set $j = 0     (gdb) print data[$j++]

After these two commands, simply hitting the ENTER key repeats the last command, stepping through the array one element at a time.

GDB predefines several convenience variables. It also enables you to access the machine registers using predefined register names. Register names vary with machine architecture, of course, but there are four predefined registers available on every architecture. The following list summarizes the convenience variables and predefined registers. The last four entries in the list are the registers that are always available.

$	The most recent value in the value history.
$n	Item n in the value history.
$$	The next to last item in the value history.
$$n	Item n in the value history, counting from the end.
$_	The address last printed by the x command.
$_ _	The contents of the address last printed by the x command.
$_exitcode	The exit status that the debuggee returned when it exited.
$bpnum	The breakpoint number of the most recently set breakpoint.
$cdir	The compilation directory for the current source file, if one is recorded in the object file.
$cwd	The current working directory.
$fp	The frame pointer register.
$pc	The program counter register.
$ps	The processor status register.
$sp	The stack pointer register.

17.4.3. Special Expressions

GDB understands the syntax (types, operators, operator precedence) of the language being debugged. You can use the same syntax to enter expressions as you do to modify GDB convenience variables (such $i++). GDB also understands several special syntaxes that let you do things that are not in the target language, as follows:

Array constants

You can create an array constant in the debuggee's memory by enclosing a list of element values in braces. For example, { 1, 2, 3, 42, 57 }.

Array operator

The @ array operator prints all the elements of an array up to a given subscript. For example, if your program uses malloc( ) to allocate memory:

     double *vals = malloc(count * sizeof(double));

you can print a single element using regular subscripting:

     (gdb) print vals[3]     $1 = 9

However, you can access vals[0] through vals[2] with:

     (gdb) print *vals@3     $2 = {0, 1, 4}

File resolution

If you use the same variable name in several source files (for example, each one is static), you can specify which one you mean using file::variable. For example:

     (gdb) print 'main.c'::errcount     $2 = 0

It is necessary to put main.c in single quotes to avoid ambiguity with the C++ :: operator.