| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Although programming languages generally have common aspects, they are
rarely expressed in the same manner. For instance, in ANSI C,
dereferencing a pointer p is accomplished by *p, but in
Modula-2, it is accomplished by p^. Values can also be
represented (and displayed) differently. Hex numbers in C appear as
`0x1ae', while in Modula-2 they appear as `1AEH'.
Language-specific information is built into GDB for some languages, allowing you to express operations like the above in your program's native language, and allowing GDB to output values in a manner consistent with the syntax of your program's native language. The language you use to build expressions is called the working language.
12.1 Switching between source languages 12.2 Displaying the language 12.3 Type and range checking Type and range checks 12.4 Supported languages 12.5 Unsupported languages
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
There are two ways to control the working language--either have GDB
set it automatically, or select it manually yourself. You can use the
set language command for either purpose. On startup, GDB
defaults to setting the language automatically. The working language is
used to determine how expressions you type are interpreted, how values
are printed, etc.
In addition to the working language, every source file that
GDB knows about has its own working language. For some object
file formats, the compiler might indicate which language a particular
source file is in. However, most of the time GDB infers the
language from the name of the file. The language of a source file
controls whether C++ names are demangled--this way backtrace can
show each frame appropriately for its own language. There is no way to
set the language of a source file from within GDB, but you can
set the language associated with a filename extension. See section Displaying the language.
This is most commonly a problem when you use a program, such
as cfront or f2c, that generates C but is written in
another language. In that case, make the
program use #line directives in its C output; that way
GDB will know the correct language of the source code of the original
program, and will display that source code, not the generated C code.
12.1.1 List of filename extensions and languages Filename extensions and languages. 12.1.2 Setting the working language Setting the working language manually 12.1.3 Having GDB infer the source language
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
If a source file name ends in one of the following extensions, then GDB infers that its language is the one indicated.
In addition, you may set the language associated with a filename extension. See section Displaying the language.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
If you allow GDB to set the language automatically, expressions are interpreted the same way in your debugging session and your program.
If you wish, you may set the language manually. To do this, issue the
command `set language lang', where lang is the name of
a language, such as
c or modula-2.
For a list of the supported languages, type `set language'.
Setting the language manually prevents GDB from updating the working language automatically. This can lead to confusion if you try to debug a program when the working language is not the same as the source language, when an expression is acceptable to both languages--but means different things. For instance, if the current source file were written in C, and GDB was parsing Modula-2, a command such as:
print a = b + c |
might not have the effect you intended. In C, this means to add
b and c and place the result in a. The result
printed would be the value of a. In Modula-2, this means to compare
a to the result of b+c, yielding a BOOLEAN value.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
To have GDB set the working language automatically, use `set language local' or `set language auto'. GDB then infers the working language. That is, when your program stops in a frame (usually by encountering a breakpoint), GDB sets the working language to the language recorded for the function in that frame. If the language for a frame is unknown (that is, if the function or block corresponding to the frame was defined in a source file that does not have a recognized extension), the current working language is not changed, and GDB issues a warning.
This may not seem necessary for most programs, which are written entirely in one source language. However, program modules and libraries written in one source language can be used by a main program written in a different source language. Using `set language auto' in this case frees you from having to set the working language manually.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The following commands help you find out which language is the working language, and also what language source files were written in.
show language
print to
build and compute expressions that may involve variables in your program.
info frame
info source
In unusual circumstances, you may have source files with extensions not in the standard list. You can then set the extension associated with a language explicitly:
set extension-language .ext language
info extensions
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Warning: In this release, the GDB commands for type and range checking are included, but they do not yet have any effect. This section documents the intended facilities.
Some languages are designed to guard you against making seemingly common errors through a series of compile- and run-time checks. These include checking the type of arguments to functions and operators, and making sure mathematical overflows are caught at run time. Checks such as these help to ensure a program's correctness once it has been compiled by eliminating type mismatches, and providing active checks for range errors when your program is running.
GDB can check for conditions like the above if you wish.
Although GDB does not check the statements in your program, it
can check expressions entered directly into GDB for evaluation via
the print command, for example. As with the working language,
GDB can also decide whether or not to check automatically based on
your program's source language. See section Supported languages,
for the default settings of supported languages.
12.3.1 An overview of type checking 12.3.2 An overview of range checking
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Some languages, such as Modula-2, are strongly typed, meaning that the arguments to operators and functions have to be of the correct type, otherwise an error occurs. These checks prevent type mismatch errors from ever causing any run-time problems. For example,
1 + 2 => 3 but error--> 1 + 2.3 |
The second example fails because the CARDINAL 1 is not
type-compatible with the REAL 2.3.
For the expressions you use in GDB commands, you can tell the GDB type checker to skip checking; to treat any mismatches as errors and abandon the expression; or to only issue warnings when type mismatches occur, but evaluate the expression anyway. When you choose the last of these, GDB evaluates expressions like the second example above, but also issues a warning.
Even if you turn type checking off, there may be other reasons
related to type that prevent GDB from evaluating an expression.
For instance, GDB does not know how to add an int and
a struct foo. These particular type errors have nothing to do
with the language in use, and usually arise from expressions, such as
the one described above, which make little sense to evaluate anyway.
Each language defines to what degree it is strict about type. For instance, both Modula-2 and C require the arguments to arithmetical operators to be numbers. In C, enumerated types and pointers can be represented as numbers, so that they are valid arguments to mathematical operators. See section Supported languages, for further details on specific languages.
GDB provides some additional commands for controlling the type checker:
set check type auto
set check type on
set check type off
set check type warn
show type
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In some languages (such as Modula-2), it is an error to exceed the bounds of a type; this is enforced with run-time checks. Such range checking is meant to ensure program correctness by making sure computations do not overflow, or indices on an array element access do not exceed the bounds of the array.
For expressions you use in GDB commands, you can tell GDB to treat range errors in one of three ways: ignore them, always treat them as errors and abandon the expression, or issue warnings but evaluate the expression anyway.
A range error can result from numerical overflow, from exceeding an array index bound, or when you type a constant that is not a member of any type. Some languages, however, do not treat overflows as an error. In many implementations of C, mathematical overflow causes the result to "wrap around" to lower values--for example, if m is the largest integer value, and s is the smallest, then
m + 1 => s |
This, too, is specific to individual languages, and in some cases specific to individual compilers or machines. See section Supported languages, for further details on specific languages.
GDB provides some additional commands for controlling the range checker:
set check range auto
set check range on
set check range off
set check range warn
show range
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GDB supports C, C++, Objective-C, Fortran, Java, assembly, Modula-2, and Ada.
Some GDB features may be used in expressions regardless of the
language you use: the GDB @ and :: operators,
and the `{type}addr' construct (see section Expressions) can be used with the constructs of any supported
language.
The following sections detail to what degree each source language is supported by GDB. These sections are not meant to be language tutorials or references, but serve only as a reference guide to what the GDB expression parser accepts, and what input and output formats should look like for different languages. There are many good books written on each of these languages; please look to these for a language reference or tutorial.
12.4.1 C and C++ 12.4.2 Objective-C 12.4.3 Modula-2 12.4.4 Ada
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Since C and C++ are so closely related, many features of GDB apply to both languages. Whenever this is the case, we discuss those languages together.
The C++ debugging facilities are jointly implemented by the C++
compiler and GDB. Therefore, to debug your C++ code
effectively, you must compile your C++ programs with a supported
C++ compiler, such as GNU g++, or the HP ANSI C++
compiler (aCC).
For best results when using GNU C++, use the DWARF 2 debugging
format; if it doesn't work on your system, try the stabs+ debugging
format. You can select those formats explicitly with the g++
command-line options `-gdwarf-2' and `-gstabs+'.
See section `Options for Debugging Your Program or GNU CC' in Using GNU CC.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Operators must be defined on values of specific types. For instance,
+ is defined on numbers, but not on structures. Operators are
often defined on groups of types.
For the purposes of C and C++, the following definitions hold:
int with any of its storage-class
specifiers; char; enum; and, for C++, bool.
float, double, and
long double (if supported by the target platform).
(type *).
The following operators are supported. They are listed here in order of increasing precedence:
,
=
op=
a op= b,
and translated to a = a op b.
op= and = have the same precedence.
op is any one of the operators |, ^, &,
<<, >>, +, -, *, /, %.
?:
a ? b : c can be thought
of as: if a then b else c. a should be of an
integral type.
||
&&
|
^
&
==, !=
<, >, <=, >=
<<, >>
@
+, -
*, /, %
++, --
*
++.
&
++.
For debugging C++, GDB implements a use of `&' beyond what is allowed in the C++ language itself: you can use `&(&ref)' (or, if you prefer, simply `&&ref') to examine the address where a C++ reference variable (declared with `&ref') is stored.
-
++.
!
++.
~
++.
., ->
struct and union data.
.*, ->*
[]
a[i] is defined as
*(a+i). Same precedence as ->.
()
->.
::
struct, union,
and class types.
::
::,
above.
If an operator is redefined in the user code, GDB usually attempts to invoke the redefined version instead of using the operator's predefined meaning.
12.4.1.2 C and C++ constants
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GDB allows you to express the constants of C and C++ in the following ways:
long value.
float (as opposed to the default double) type; or with
a letter `l' or `L', which specifies a long double
constant.
'), or a number--the ordinal value of the corresponding character
(usually its ASCII value). Within quotes, the single character may
be represented by a letter or by escape sequences, which are of
the form `\nnn', where nnn is the octal representation
of the character's ordinal value; or of the form `\x', where
`x' is a predefined special character--for example,
`\n' for newline.
"). Any valid character constant (as described
above) may appear. Double quotes within the string must be preceded by
a backslash, so for instance `"a\"b'c"' is a string of five
characters.
12.4.1.3 C++ expressions 12.4.1.4 C and C++ defaults 12.4.1.5 C and C++ type and range checks
12.4.1.6 GDB and C
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GDB expression handling can interpret most C++ expressions.
Warning: GDB can only debug C++ code if you use the proper compiler and the proper debug format. Currently, GDB works best when debugging C++ code that is compiled with GCC 2.95.3 or with GCC 3.1 or newer, using the options `-gdwarf-2' or `-gstabs+'. DWARF 2 is preferred over stabs+. Most configurations of GCC emit either DWARF 2 or stabs+ as their default debug format, so you usually don't need to specify a debug format explicitly. Other compilers and/or debug formats are likely to work badly or not at all when using GDB to debug C++ code.
count = aml->GetOriginal(x, y) |
this following the same rules as C++.
It does perform integral conversions and promotions, floating-point promotions, arithmetic conversions, pointer conversions, conversions of class objects to base classes, and standard conversions such as those of functions or arrays to pointers; it requires an exact match on the number of function arguments.
Overload resolution is always performed, unless you have specified
set overload-resolution off. See section GDB features for C++.
You must specify set overload-resolution off in order to use an
explicit function signature to call an overloaded function, as in
p 'foo(char,int)'('x', 13)
|
The GDB command-completion facility can simplify this; see Command completion.
In the parameter list shown when GDB displays a frame, the values of reference variables are not displayed (unlike other variables); this avoids clutter, since references are often used for large structures. The address of a reference variable is always shown, unless you have specified `set print address off'.
::---your
expressions can use it just as expressions in your program do. Since
one scope may be defined in another, you can use :: repeatedly if
necessary, for example in an expression like
`scope1::scope2::name'. GDB also allows
resolving name scope by reference to source files, in both C and C++
debugging (see section Program variables).
In addition, when used with HP's C++ compiler, GDB supports calling virtual functions correctly, printing out virtual bases of objects, calling functions in a base subobject, casting objects, and invoking user-defined operators.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
If you allow GDB to set type and range checking automatically, they
both default to off whenever the working language changes to
C or C++. This happens regardless of whether you or GDB
selects the working language.
If you allow GDB to set the language automatically, it recognizes source files whose names end with `.c', `.C', or `.cc', etc, and when GDB enters code compiled from one of these files, it sets the working language to C or C++. See section Having GDB infer the source language, for further details.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
By default, when GDB parses C or C++ expressions, type checking is not used. However, if you turn type checking on, GDB considers two variables type equivalent if:
typedef.
Range checking, if turned on, is done on mathematical operations. Array indices are not checked, since they are often used to index a pointer that is not itself an array.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The set print union and show print union commands apply to
the union type. When set to `on', any union that is
inside a struct or class is also printed. Otherwise, it
appears as `{...}'.
The @ operator aids in the debugging of dynamic arrays, formed
with pointers and a memory allocation function. See section Expressions.
12.4.1.7 GDB features for C++
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Some GDB commands are particularly useful with C++, and some are designed specifically for use with C++. Here is a summary:
breakpoint menus
rbreak regex
catch throw
catch catch
ptype typename
set print demangle
show print demangle
set print asm-demangle
show print asm-demangle
set print object
show print object
set print vtbl
show print vtbl
vtbl commands do not work on programs compiled with the HP
ANSI C++ compiler (aCC).)
set overload-resolution on
set overload-resolution off
Overloaded symbol names
symbol(types) rather than just symbol. You can
also use the GDB command-line word completion facilities to list the
available choices, or to finish the type list for you.
See section Command completion, for details on how to do this.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This section provides information about some commands and command options that are useful for debugging Objective-C code.
12.4.2.1 Method Names in Commands 12.4.2.2 The Print Command With Objective-C
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The following commands have been extended to accept Objective-C method names as line specifications:
clear
break
info line
jump
list
A fully qualified Objective-C method name is specified as
-[Class methodName] |
where the minus sign is used to indicate an instance method and a
plus sign (not shown) is used to indicate a class method. The class
name Class and method name methodName are enclosed in
brackets, similar to the way messages are specified in Objective-C
source code. For example, to set a breakpoint at the create
instance method of class Fruit in the program currently being
debugged, enter:
break -[Fruit create] |
To list ten program lines around the initialize class method,
enter:
list +[NSText initialize] |
In the current version of GDB, the plus or minus sign is required. In future versions of GDB, the plus or minus sign will be optional, but you can use it to narrow the search. It is also possible to specify just a method name:
break create |
You must specify the complete method name, including any colons. If
your program's source files contain more than one create method,
you'll be presented with a numbered list of classes that implement that
method. Indicate your choice by number, or type `0' to exit if
none apply.
As another example, to clear a breakpoint established at the
makeKeyAndOrderFront: method of the NSWindow class, enter:
clear -[NSWindow makeKeyAndOrderFront:] |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The print command has also been extended to accept methods. For example:
print -[object hash] |
will tell GDB to send the hash message to object
and print the result. Also, an additional command has been added,
print-object or po for short, which is meant to print
the description of an object. However, this command may only work
with certain Objective-C libraries that have a particular hook
function, _NSPrintForDebugger, defined.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The extensions made to GDB to support Modula-2 only support output from the GNU Modula-2 compiler (which is currently being developed). Other Modula-2 compilers are not currently supported, and attempting to debug executables produced by them is most likely to give an error as GDB reads in the executable's symbol table.
12.4.3.1 Operators Built-in operators 12.4.3.2 Built-in functions and procedures 12.4.3.3 Constants Modula-2 constants 12.4.3.4 Modula-2 defaults Default settings for Modula-2 12.4.3.5 Deviations from standard Modula-2 12.4.3.6 Modula-2 type and range checks 12.4.3.7 The scope operators ::and.12.4.3.8 GDB and Modula-2
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Operators must be defined on values of specific types. For instance,
+ is defined on numbers, but not on structures. Operators are
often defined on groups of types. For the purposes of Modula-2, the
following definitions hold:
INTEGER, CARDINAL, and
their subranges.
CHAR and its subranges.
REAL.
POINTER TO
type.
SET and BITSET types.
BOOLEAN.
The following operators are supported, and appear in order of increasing precedence:
,
:=
:= value is
value.
<, >
<=, >=
<.
=, <>, #
<. In GDB scripts, only <> is
available for inequality, since # conflicts with the script
comment character.
IN
<.
OR
AND, &
@
+, -
*
/
*.
DIV, MOD
*.
-
INTEGER and REAL data.
^
NOT
^.
.
RECORD field selector. Defined on RECORD data. Same
precedence as ^.
[]
ARRAY data. Same precedence as ^.
()
PROCEDURE objects. Same precedence
as ^.
::, .
Warning: Sets and their operations are not yet supported, so GDB treats the use of the operatorIN, or the use of operators+,-,*,/,=, ,<>,#,<=, and>=on sets as an error.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Modula-2 also makes available several built-in procedures and functions. In describing these, the following metavariables are used:
ARRAY variable.
CHAR constant or variable.
SET OF mtype (where mtype is the type of m).
All Modula-2 built-in procedures also return a result, described below.
ABS(n)
CAP(c)
CHR(i)
DEC(v)
DEC(v,i)
EXCL(m,s)
FLOAT(i)
HIGH(a)
INC(v)
INC(v,i)
INCL(m,s)
MAX(t)
MIN(t)
ODD(i)
ORD(x)
SIZE(x)
TRUNC(r)
VAL(t,i)
Warning: Sets and their operations are not yet supported, so GDB treats the use of proceduresINCLandEXCLas an error.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GDB allows you to express the constants of Modula-2 in the following ways:
') or double ("). They may
also be expressed by their ordinal value (their ASCII value, usually)
followed by a `C'.
') or double (").
Escape sequences in the style of C are also allowed. See section C and C++ constants, for a brief explanation of escape
sequences.
TRUE and
FALSE.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
If type and range checking are set automatically by GDB, they
both default to on whenever the working language changes to
Modula-2. This happens regardless of whether you or GDB
selected the working language.
If you allow GDB to set the language automatically, then entering code compiled from a file whose name ends with `.mod' sets the working language to Modula-2. See section Having GDB set the language automatically, for further details.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
A few changes have been made to make Modula-2 programs easier to debug. This is done primarily via loosening its type strictness:
:=) returns the value of its right-hand
argument.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Warning: in this release, GDB does not yet perform type or range checking.
GDB considers two Modula-2 variables type equivalent if:
TYPE
t1 = t2 statement
As long as type checking is enabled, any attempt to combine variables whose types are not equivalent is an error.
Range checking is done on all mathematical operations, assignment, array index bounds, and all built-in functions and procedures.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
:: and .
There are a few subtle differences between the Modula-2 scope operator
(.) and the GDB scope operator (::). The two have
similar syntax:
module . id scope :: id |
where scope is the name of a module or a procedure, module the name of a module, and id is any declared identifier within your program, except another module.
Using the :: operator makes GDB search the scope
specified by scope for the identifier id. If it is not
found in the specified scope, then GDB searches all scopes
enclosing the one specified by scope.
Using the . operator makes GDB search the current scope for
the identifier specified by id that was imported from the
definition module specified by module. With this operator, it is
an error if the identifier id was not imported from definition
module module, or if id is not an identifier in
module.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Some GDB commands have little use when debugging Modula-2 programs.
Five subcommands of set print and show print apply
specifically to C and C++: `vtbl', `demangle',
`asm-demangle', `object', and `union'. The first four
apply to C++, and the last to the C union type, which has no direct
analogue in Modula-2.
The @ operator (see section Expressions), while available
with any language, is not useful with Modula-2. Its
intent is to aid the debugging of dynamic arrays, which cannot be
created in Modula-2 as they can in C or C++. However, because an
address can be specified by an integral constant, the construct
`{type}adrexp' is still useful.
In GDB scripts, the Modula-2 inequality operator # is
interpreted as the beginning of a comment. Use <> instead.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The extensions made to GDB for Ada only support output from the GNU Ada (GNAT) compiler. Other Ada compilers are not currently supported, and attempting to debug executables produced by them is most likely to be difficult.
12.4.4.1 Introduction General remarks on the Ada syntax and semantics supported by Ada mode in GDB. 12.4.4.2 Omissions from Ada Restrictions on the Ada expression syntax. 12.4.4.3 Additions to Ada Extensions of the Ada expression syntax. 12.4.4.4 Stopping at the Very Beginning Debugging the program during elaboration. 12.4.4.5 Breaking on Ada Exceptions Setting breakpoints on exception handlers. 12.4.4.6 Extensions for Ada Tasks Listing and setting breakpoints in tasks. 12.4.4.7 Tasking Support when Debugging Core Files 12.4.4.8 Debugging Generic Units Dealing with generic instantiations. 12.4.4.9 Set commands for Ada New settable GDB parameters for Ada. 12.4.4.10 Known Peculiarities of Ada Mode Known peculiarities of Ada mode.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The Ada mode of GDB supports a fairly large subset of Ada expression syntax, with some extensions. The philosophy behind the design of this subset is
Thus, for brevity, the debugger acts as if there were
implicit with and use clauses in effect for all user-written
packages, making it unnecessary to fully qualify most names with
their packages, regardless of context. Where this causes ambiguity,
GDB asks the user's intent.
The debugger will start in Ada mode if it detects an Ada main program. As for other languages, it will enter Ada mode when stopped in a program that was translated from an Ada source file.
While in Ada mode, you may use `--' for comments. This is useful mostly for documenting command files. The standard GDB comment (`#') still works at the beginning of a line in Ada mode, but not in the middle (to allow based literals).
The debugger supports limited overloading. Given a subprogram call in which
the function symbol has multiple definitions, it will use the number of
actual parameters and some information about their types to attempt to narrow
the set of definitions. It also makes very limited use of context, preferring
procedures to functions in the context of the call command, and
functions to procedures elsewhere.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Here are the notable omissions from the subset:
obj'First, obj'Last, and obj'Length,
where obj is an array object (not a type or subtype).
type'Min and type'Max.
The prefix
type is ignored and may even be omitted.
type'Pos and type'Val. The prefix type is
only required for the second of these.
obj'Tag.
obj'Range, where obj is an array object (not a subtype),
but only as the right
operand of the membership (in) operator.
obj'Access.
obj'Address.
Characters.Latin_1 are not available and
concatenation is not implemented. Thus, escape characters in strings are
not currently available.
and, or,
xor, not, and relational tests other than equality)
are not implemented.
new operator is not implemented.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
As it does for other languages, GDB makes certain generic extensions to Ada (see section 8.1 Expressions):
E@N displays the values of
E and the N-1 adjacent variables following it in memory as an array.
In Ada, this operator is generally not necessary, since its prime use
is in displaying parts of an array, and slicing will usually do this in Ada.
However, there are occasional uses when debugging programs
in which certain debugging information has been optimized away.
B::var means "the variable named var that appears
in function or file B." When B is a file name, you must typically
surround it in single quotes.
{type} addr means "the variable of type
type that appears at address addr."
In addition, GDB provides a few other shortcuts and outright additions specific to Ada:
set x := y + 3 print A(tmp := y + 1) |
break f condition 1 (report(i); k += 1; A(k) > 100) |
"One line.["0a"]Next line.["0a"]" |
Ada.Characters.Latin_1.LF) after each
period.
type'Pos, type'Min, and
type'Max is optional (and is ignored in any case). For example, it is valid
to write
print 'max(x, y) |
(3 => 10, 17, 1) |
That is, in contrast to valid Ada, only the first component has a =>
clause.
arr'len, arr'gth, or arr'lh
in place of arr'length.
gdb print <JMPBUF_SAVE>[0] |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
It is sometimes necessary to debug the program during elaboration, and
before reaching the main procedure.
As defined in the Ada Reference
Manual, the elaboration code is invoked from a procedure called
adainit. To run your program up to the beginning of
elaboration, simply use the following two commands:
tbreak adainit and run.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In Ada mode, you can set breakpoints that trip when your program raises selected exceptions.
break exception
break exception name
When inserting a breakpoint on a specific exception for which an
homonym entity exists in the application, it is necessary to prefix
the exception name with its package name. In particular, if an entity
sharing the same name as one of the standard exceptions has been defined,
the exception name must be prefixed with package Standard when
setting a breakpoint on this exception.
gdb break exception Standard.Constraint_Error |
break exception unhandled
info exceptions
info exceptions regexp
info exceptions command permits the user to examine all defined
exceptions within Ada programs. With a regular expression, regexp, as
argument, prints out only those exceptions whose name matches regexp.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Support for Ada tasks is analogous to that for threads (see section 4.9 Debugging programs with multiple threads). When in Ada mode (that is, when the "current language" is Ada), GDB allows the following task-related commands:
info tasks
gdb info tasks ID TID P-ID Pri State Name 1 8088000 0 15 Child Activation Wait main_task 2 80a4000 1 15 Accept Statement b 3 809a800 1 15 Child Activation Wait a * 4 80ae800 3 15 Running c |
In this listing, the asterisk before the first task indicates it to be the currently running task.
info task taskno
gdb info tasks ID TID P-ID Pri State Name 1 8077880 0 15 Child Activation Wait main_task * 2 807c468 1 15 Running task_1 gdb info task 2 Ada Task: 0x807c468 Name: task_1 Thread: 0x807f378 Parent: 1 (main_task) Base Priority: 15 State: Runnable |
task
gdb info tasks ID TID P-ID Pri State Name 1 8077870 0 15 Child Activation Wait main_task * 2 807c458 1 15 Running t gdb task [Current task is 2] |
task taskno
thread threadno
command (see section 4.9 Debugging programs with multiple threads). It switches the context of debugging
from the current task to the given task.
This command has not been implemented on AIX yet. Task switching when debugging core files has not been implemented.
gdb info tasks
ID TID P-ID Pri State Name
1 8077870 0 15 Child Activation Wait main_task
* 2 807c458 1 15 Running t
gdb task 1
[Switching to task 1]
#0 0x8067726 in pthread_cond_wait ()
gdb bt
#0 0x8067726 in pthread_cond_wait ()
#1 0x8056714 in system.os_interface.pthread_cond_wait ()
#2 0x805cb63 in system.task_primitives.operations.sleep ()
#3 0x806153e in system.tasking.stages.activate_tasks ()
#4 0x804aacc in un () at un.adb:5
#5 0x8049d56 in main (argc=1, argv=3221223804, envp=3221223812)
at b~un.adb:163
|
break linespec task taskno
break linespec task taskno if ...
break ... thread ...
(see section 5.4 Stopping and starting multi-thread programs).
linespec specifies source lines, as described
in Setting breakpoints.
Use the qualifier `task taskno' with a breakpoint command to specify that you only want GDB to stop the program when a particular Ada task reaches this breakpoint. taskno is one of the numeric task identifiers assigned by GDB, shown in the first column of the `info tasks' display.
If you do not specify `task taskno' when you set a breakpoint, the breakpoint applies to all tasks of your program.
You can use the task qualifier on conditional breakpoints as
well; in this case, place `task taskno' before the
breakpoint condition (before the if).
For example,
gdb info tasks
ID TID P-ID Pri State Name
1 140022020 0 15 Child Activation Wait main_task
2 140045060 1 15 Accept/Select Wait t2
3 140044840 1 15 Runnable t1
* 4 140056040 1 15 Running t3
gdb b 15 task 2
Breakpoint 5 at 0x120044cb0: file test_task_debug.adb, line 15.
gdb cont
Continuing.
task # 1 running
task # 2 running
Breakpoint 5, test_task_debug.tB.1 (_task=0x11ffffc60)
at test_task_debug.adb:15
15 flush;
gdb info tasks
ID TID P-ID Pri State Name
1 140022020 0 15 Child Activation Wait main_task
* 2 140045060 1 15 Running t2
3 140044840 1 15 Runnable t1
4 140056040 1 15 Delay Sleep t3
|
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
When inspecting a core file, as opposed to debugging a live program, tasking support may be limited or even unavailable, depending on the platform being used. For instance, on x86-linux, the list of tasks is available, but task switching is not supported. On Tru64, however, task switching will work as usual.
On certain platforms, including Tru64, the debugger needs to perform some memory writes in order to provide Ada tasking support. When inspecting a core file, this means that the core file must be opened with read-write privileges, using the command `"set write on"'. Under these circumstances, you should make a backup copy of the core file before inspecting it with GDB.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GNAT always uses code expansion for generic instantiation. This means that each time an instantiation occurs, a complete copy of the original code is made with appropriate substitutions.
It is not possible to refer to the original generic entities themselves
in GDB (there is no code to refer to), but it
is certainly possible to debug a particular instance of a generic, simply by
using the appropriate expanded names. For example, suppose that
Gen is a generic package:
-- In file gen.ads:
generic package Gen is
function F (v1 : Integer) return Integer;
end Gen;
-- In file gen.adb:
package body Gen is
function F (v1 : Integer) return Integer is
begin
return v1+1; -- Line 5
end F;
end Gen;
|
and we have the following expansions
with Gen; procedure G is package Gen1 is new Gen; package Gen2 is new Gen; I : Integer := 0; begin I := Gen1.F (I); I := Gen2.F (I); I := Gen1.F (I); I := Gen2.F (I); end; |
Then to break on a call to procedure F in the Gen2 instance, simply
use the command:
break G.Gen2.F |
To break at a particular line in a particular generic instance, say the return
statement in G.Gen2, append the line specification to the file and
function name:
break gen.adb:G.Gen2.F:5 |
To break on this line line in all instances of Gen, use `*'
as the function name:
break gen.adb:*:5 |
This will set individual breakpoints at all instances; they are independent of each other and you may remove, conditionalize, or otherwise modify them individually.
When a breakpoint occurs, you can step through the code of the generic instance in the normal manner. You can also examine values of data in the normal manner, providing the appropriate generic package qualification to refer to non-local entities.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Ada introduces one new set command.
set varsize-limit size
x.y.z, may
fail if the size of x.y is dynamic and exceeds size.
On the other hand, GDB is sometimes clever;
the expression A(i), where A is an
array variable with non-constant size, will generally succeed regardless of the
bounds on A, as long as the component size is less than size.
show varsize-limit
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Besides the omissions listed previously (see section 12.4.4.2 Omissions from Ada), we know of several problems with and limitations of Ada mode in GDB, some of which will be fixed with planned future releases of the debugger and the GNU Ada compiler.
.all after an expression
to get it printed properly.
obj'Address might not be System.Address.
up commands to get to
frame containing the variable you wish to see.
Access to non-local variables does not, at the moment, work in
the test expressions for conditional breakpoints
(see section Break conditions) unless you happen to specify these
while stopped in the subprogram in which they are to be applied.
break foo). In effect, the
nested functions act like local variables of the enclosing function.
On these platforms, you must wait until GDB is stopped in
the enclosing function before using this form of break command.
This is not much of a limitation, since you can still set a breakpoint on
the first line of the desired function using the usual
break file:line syntax.
Standard for any of
the standard symbols defined by the Ada language. GDB knows about
this: it will strip the prefix from names when you use it, and will never
look for a name you have so qualified among local symbols, nor match against
symbols in other packages or subprograms. If you have
defined entities anywhere in your program other than parameters and
local variables whose simple names match names in Standard,
GNAT's lack of qualification here can cause confusion. When this happens,
you can usually resolve the confusion
by qualifying the problematic names with package
Standard explicitly.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
In addition to the other fully-supported programming languages,
GDB also provides a pseudo-language, called minimal.
It does not represent a real programming language, but provides a set
of capabilities close to what the C or assembly languages provide.
This should allow most simple operations to be performed while debugging
an application that uses a language currently not supported by GDB.
If the language is set to auto, GDB will automatically
select this language if the current frame corresponds to an unsupported
language.
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |