In gdb, symbols are stored in blocks. A block corresponds
roughly to a scope in the source code. Blocks are organized
hierarchically, and are represented individually in Guile as an object
of type <gdb:block>. Blocks rely on debugging information being
available.
A frame has a block. Please see Frames In Guile, for a more in-depth discussion of frames.
The outermost block is known as the global block. The global block typically holds public global variables and functions.
The block nested just inside the global block is the static block. The static block typically holds file-scoped variables and functions.
gdb provides a method to get a block's superblock, but there is currently no way to examine the sub-blocks of a block, or to iterate over all the blocks in a symbol table (see Symbol Tables In Guile).
Here is a short example that should help explain blocks:
/* This is in the global block. */
int global;
/* This is in the static block. */
static int file_scope;
/* 'function' is in the global block, and 'argument' is
in a block nested inside of 'function'. */
int function (int argument)
{
/* 'local' is in a block inside 'function'. It may or may
not be in the same block as 'argument'. */
int local;
{
/* 'inner' is in a block whose superblock is the one holding
'local'. */
int inner;
/* If this call is expanded by the compiler, you may see
a nested block here whose function is 'inline_function'
and whose superblock is the one holding 'inner'. */
inline_function ();
}
}
The following block-related procedures are provided by the
(gdb) module:
Returns
#tif<gdb:block>block is valid,#fif not. A block object can become invalid if the block it refers to doesn't exist anymore in the inferior. All other<gdb:block>methods will throw an exception if it is invalid at the time the procedure is called. The block's validity is also checked during iteration over symbols of the block.
Return the name of
<gdb:block>block represented as a<gdb:symbol>object. If the block is not named, then#fis returned.For ordinary function blocks, the superblock is the static block. However, you should note that it is possible for a function block to have a superblock that is not the static block – for instance this happens for an inlined function.
Return the block containing
<gdb:block>block. If the parent block does not exist, then#fis returned.
Return the global block associated with
<gdb:block>block.
Return the static block associated with
<gdb:block>block.
Return
#tif<gdb:block>block is a global block. Otherwise return#f.
Return
#tif<gdb:block>block is a static block. Otherwise return#f.
Return a list of all symbols (as <gdb:symbol> objects) in
<gdb:block>block.
Return an object of type
<gdb:iterator>that will iterate over all symbols of the block. Guile programs should not assume that a specific block object will always contain a given symbol, since changes in gdb features and infrastructure may cause symbols move across blocks in a symbol table. See Iterators In Guile.