Contents|Index|Previous|Next
Examining
the symbol table
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. GDB finds it in your program’s symbol table,
in the file indicated when you started GDB (see Choosing
files), or by one of the file-management commands (see Commands
to specify files).
Occasionally, you may need
to refer to symbols that contain unusual characters, which GDB ordinarily
treats as word delimiters. The most frequent case is in referring to static
variables in other source files (see Program
variables). File names are recorded in object files as debugging
symbols, but GDB would ordinarily parse a typical file name, like ‘foo.c’,
as three words, ‘foo’
and ‘.’
and ‘c’.
To allow GDB 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 ’foo.c’
file.
info address
symbol
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’
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.
whatis
exp
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 Expressions.
whatis
Print the data type of $,
the last value in the value history.
ptype
typename
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’.
ptype
exp
ptype
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 instance, consider the following variable declaration example.
struct complex {double real;
double imag;} v;
Such declarations give output
as the following example shows.
(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.
info types
regexp
info types
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.
info source
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.
info sources
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.
info functions
Print the names and data
types of all defined functions.
info functions
regexp
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.
info variables
Print the names and data
types of all variables that are declared outside of functions (i.e., excluding
local variables).
info variables
regexp
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. For example, in VxWorks you can simply recompile
a defective object file and keep on running. If you are running on one
of these systems, you can allow GDB to reload the symbols for the following
automatically relinked modules:
set symbol-reloading on
Replace symbol definitions
for the corresponding source file when an object file with a particular
name is seen again.
set symbol-reloading off
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 GDB may discard symbols when linking large programs,
that may contain several modules (from different directories or libraries)
with the same name.
show symbol-reloading
Show the current on
or off
setting.
maint print symbols
filename
maint print psymbols
filename
maint print msymbols
filename
Write a dump of debugging
symbol data into the file, filename.
These commands are used to debug the GDB symbol-reading code. Only symbols
with debugging data are included.
If you use ‘maint
print symbols’,
GDB includes all the symbols for which it has already collected full details:
that is, filename
reflects symbols for only those files whose symbols GDB 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 GDB only knows partially—that
is, symbols defined in files that GDB has skimmed, but not yet read completely.
Finally, ‘maint
print msymbols’
dumps just the minimal symbol information required for each object file
from which GDB has read some symbols. See Commands
to specify files for a discussion of how GDB reads symbols (in
the description of symbol-file).
Top|Contents|Index|Previous|Next