| Red Hat Enterprise Linux 4: Debugging with gdb | ||
|---|---|---|
| Prev | Chapter 14. Using gdb with Different Languages | Next |
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. Refer to Section 14.4 Supported languages, for the default settings of supported languages.
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. Refer to Section 14.4 Supported languages, for further details on specific languages.
gdb provides some additional commands for controlling the type checker:
Set type checking on or off based on the current working language. Refer to Section 14.4 Supported languages, for the default settings for each language.
Set type checking on or off, overriding the default setting for the current working language. Issue a warning if the setting does not match the language default. If any type mismatches occur in evaluating an expression while type checking is on, gdb prints a message and aborts evaluation of the expression.
Cause the type checker to issue warnings, but to always attempt to evaluate the expression. Evaluating the expression may still be impossible for other reasons. For example, gdb cannot add numbers and structures.
Show the current setting of the type checker, and whether or not gdb is setting it automatically.
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. Refer to Section 14.4 Supported languages, for further details on specific languages.
gdb provides some additional commands for controlling the range checker:
Set range checking on or off based on the current working language. Refer to Section 14.4 Supported languages, for the default settings for each language.
Set range checking on or off, overriding the default setting for the current working language. A warning is issued if the setting does not match the language default. If a range error occurs and range checking is on, then a message is printed and evaluation of the expression is aborted.
Output messages when the gdb range checker detects a range error, but attempt to evaluate the expression anyway. Evaluating the expression may still be impossible for other reasons, such as accessing memory that the process does not own (a typical example from many Unix systems).
Show the current setting of the range checker, and whether or not it is being set automatically by gdb.