The commands described in this section allow you to inquire about the symbols (names of variables, functions and types) defined in your program. This information is inherent in the text of your program and does not change as your program executes. The debugger finds it in your program's symbol table, in the file indicated when you started the debugger (see Section 8.1.1.), or by one of the file-management commands (see Section 18.1: Files.).
Occasionally, you may need to refer to symbols that contain unusual characters, which the debugger ordinarily treats as word delimiters. The most frequent case is in referring to static variables in other source files (see Section 14.2: Variables.). File names are recorded in object files as debugging symbols, but the debugger would ordinarily parse a typical file name, like foo.c, as the three words “foo” “.” “c”. To allow the debugger to recognize “foo.c” as a single symbol, enclose it in single quotes; for example,
p 'foo.c'::x
looks up the value of x in the scope of the file foo.c.
Describe where the data for symbol is stored. For a register variable, this says which register it is kept in. For a non-register local variable, this prints the stack-frame offset at which the variable is always stored.
Note the contrast with print &symbol, which does not work at all for a register variable, and for a stack local variable prints the exact address of the current instantiation of the variable.
Print the data type of expression exp. exp is not actually evaluated, and any side-effecting operations (such as assignments or function calls) inside it do not take place. See Section 14.1.
Print the data type of $, the last value in the value history.
Print a description of data type typename. typename may be the name of a type, or for C code it may have the form class class-name, struct struct-tag, union union-tag or enum enum-tag.
Print a description of the type of expression exp. ptype differs from whatis by printing a detailed description, instead of just the name of the type.
For example, for this variable declaration:
struct complex {double real; double imag;} v;
the two commands give this output:
(gdb) whatis v
type = struct complex
(gdb) ptype v
type = struct complex {
double real;
double imag;
}
As with whatis, using ptype without an argument refers to the type of $, the last value in the value history.
Print a brief description of all types whose name matches regexp (or all types in your program, if you supply no argument). Each complete typename is matched as though it were a complete line; thus, i type value gives information on all types in your program whose name includes the string value, but i type ^value$ gives information only on types whose complete name is value.
This command differs from ptype in two ways: first, like whatis, it does not print a detailed description; second, it lists all source files where a type is defined.
Show the name of the current source file — that is, the source file for the function containing the current point of execution — and the language it was written in.
Print the names of all source files in your program for which there is debugging information, organized into two lists: files whose symbols have already been read, and files whose symbols will be read when needed.
Print the names and data types of all defined functions.
Print the names and data types of all defined functions whose names contain a match for regular expression regexp. Thus, info fun step finds all functions whose names include step; info fun ^step finds those whose names start with step.
Print the names and data types of all variables that are declared outside of functions (i.e., excluding local variables).
Print the names and data types of all variables (except for local variables) whose names contain a match for regular expression regexp.
Some systems allow individual object files that make up your program to be replaced without stopping and restarting your program. If you are running on one of these systems, you can allow the debugger to reload the symbols for automatically relinked modules:
Replace symbol definitions for the corresponding source file when an object file with a particular name is seen again.
Do not replace symbol definitions when re-encountering object files of the same name. This is the default state; if you are not running on a system that permits automatically relinking modules, you should leave symbol-reloading off, since otherwise the debugger may discard symbols when linking large programs, that may contain several modules (from different directories or libraries) with the same name.
Show the current on or off setting.
Write a dump of debugging symbol data into the file filename. These commands are used to debug the the debugger symbol-reading code. Only symbols with debugging data are included. If you use maint print symbols, the debugger includes all the symbols for which it has already collected full details: that is, filename reflects symbols for only those files whose symbols the debugger has read. You can use the command info sources to find out which files these are. If you use maint print psymbols instead, the dump shows information about symbols that the debugger only knows partially — that is, symbols defined in files that the debugger has skimmed, but not yet read completely. Finally, maint print msymbols dumps just the minimal symbol information required for each object file from which the debugger has read some symbols. See Section 18.1, for a discussion of how the debugger reads symbols (in the description of symbol-file).