Subversion Repositories openrisc_2011-10-31

This is gdb.info, produced by makeinfo version 4.8 from

This is gdb.info, produced by makeinfo version 4.8 from

../.././gdb/doc/gdb.texinfo.

../.././gdb/doc/gdb.texinfo.

INFO-DIR-SECTION Software development

INFO-DIR-SECTION Software development

START-INFO-DIR-ENTRY

START-INFO-DIR-ENTRY

* Gdb: (gdb).                     The GNU debugger.

* Gdb: (gdb).                     The GNU debugger.

END-INFO-DIR-ENTRY

END-INFO-DIR-ENTRY

   This file documents the GNU debugger GDB.

   This file documents the GNU debugger GDB.

   This is the Ninth Edition, of `Debugging with GDB: the GNU

   This is the Ninth Edition, of `Debugging with GDB: the GNU

Source-Level Debugger' for GDB Version 6.8.

Source-Level Debugger' for GDB Version 6.8.

   Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,

   Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,

1998,

1998,

1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006

1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006

Free Software Foundation, Inc.

Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document

   Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.1 or

under the terms of the GNU Free Documentation License, Version 1.1 or

any later version published by the Free Software Foundation; with the

any later version published by the Free Software Foundation; with the

Invariant Sections being "Free Software" and "Free Software Needs Free

Invariant Sections being "Free Software" and "Free Software Needs Free

Documentation", with the Front-Cover Texts being "A GNU Manual," and

Documentation", with the Front-Cover Texts being "A GNU Manual," and

with the Back-Cover Texts as in (a) below.

with the Back-Cover Texts as in (a) below.

   (a) The FSF's Back-Cover Text is: "You are free to copy and modify

   (a) The FSF's Back-Cover Text is: "You are free to copy and modify

this GNU Manual.  Buying copies from GNU Press supports the FSF in

this GNU Manual.  Buying copies from GNU Press supports the FSF in

developing GNU and promoting software freedom."

developing GNU and promoting software freedom."

File: gdb.info,  Node: Automatic Overlay Debugging,  Next: Overlay Sample Program,  Prev: Overlay Commands,  Up: Overlays

File: gdb.info,  Node: Automatic Overlay Debugging,  Next: Overlay Sample Program,  Prev: Overlay Commands,  Up: Overlays

11.3 Automatic Overlay Debugging

11.3 Automatic Overlay Debugging

================================

================================

GDB can automatically track which overlays are mapped and which are

GDB can automatically track which overlays are mapped and which are

not, given some simple co-operation from the overlay manager in the

not, given some simple co-operation from the overlay manager in the

inferior.  If you enable automatic overlay debugging with the `overlay

inferior.  If you enable automatic overlay debugging with the `overlay

auto' command (*note Overlay Commands::), GDB looks in the inferior's

auto' command (*note Overlay Commands::), GDB looks in the inferior's

memory for certain variables describing the current state of the

memory for certain variables describing the current state of the

overlays.

overlays.

   Here are the variables your overlay manager must define to support

   Here are the variables your overlay manager must define to support

GDB's automatic overlay debugging:

GDB's automatic overlay debugging:

`_ovly_table':

`_ovly_table':

     This variable must be an array of the following structures:

     This variable must be an array of the following structures:

          struct

          struct

          {

          {

            /* The overlay's mapped address.  */

            /* The overlay's mapped address.  */

            unsigned long vma;

            unsigned long vma;

            /* The size of the overlay, in bytes.  */

            /* The size of the overlay, in bytes.  */

            unsigned long size;

            unsigned long size;

            /* The overlay's load address.  */

            /* The overlay's load address.  */

            unsigned long lma;

            unsigned long lma;

            /* Non-zero if the overlay is currently mapped;

            /* Non-zero if the overlay is currently mapped;

               zero otherwise.  */

               zero otherwise.  */

            unsigned long mapped;

            unsigned long mapped;

          }

          }

`_novlys':

`_novlys':

     This variable must be a four-byte signed integer, holding the total

     This variable must be a four-byte signed integer, holding the total

     number of elements in `_ovly_table'.

     number of elements in `_ovly_table'.

   To decide whether a particular overlay is mapped or not, GDB looks

   To decide whether a particular overlay is mapped or not, GDB looks

for an entry in `_ovly_table' whose `vma' and `lma' members equal the

for an entry in `_ovly_table' whose `vma' and `lma' members equal the

VMA and LMA of the overlay's section in the executable file.  When GDB

VMA and LMA of the overlay's section in the executable file.  When GDB

finds a matching entry, it consults the entry's `mapped' member to

finds a matching entry, it consults the entry's `mapped' member to

determine whether the overlay is currently mapped.

determine whether the overlay is currently mapped.

   In addition, your overlay manager may define a function called

   In addition, your overlay manager may define a function called

`_ovly_debug_event'.  If this function is defined, GDB will silently

`_ovly_debug_event'.  If this function is defined, GDB will silently

set a breakpoint there.  If the overlay manager then calls this

set a breakpoint there.  If the overlay manager then calls this

function whenever it has changed the overlay table, this will enable

function whenever it has changed the overlay table, this will enable

GDB to accurately keep track of which overlays are in program memory,

GDB to accurately keep track of which overlays are in program memory,

and update any breakpoints that may be set in overlays.  This will

and update any breakpoints that may be set in overlays.  This will

allow breakpoints to work even if the overlays are kept in ROM or other

allow breakpoints to work even if the overlays are kept in ROM or other

non-writable memory while they are not being executed.

non-writable memory while they are not being executed.

File: gdb.info,  Node: Overlay Sample Program,  Prev: Automatic Overlay Debugging,  Up: Overlays

File: gdb.info,  Node: Overlay Sample Program,  Prev: Automatic Overlay Debugging,  Up: Overlays

11.4 Overlay Sample Program

11.4 Overlay Sample Program

===========================

===========================

When linking a program which uses overlays, you must place the overlays

When linking a program which uses overlays, you must place the overlays

at their load addresses, while relocating them to run at their mapped

at their load addresses, while relocating them to run at their mapped

addresses.  To do this, you must write a linker script (*note Overlay

addresses.  To do this, you must write a linker script (*note Overlay

Description: (ld.info)Overlay Description.).  Unfortunately, since

Description: (ld.info)Overlay Description.).  Unfortunately, since

linker scripts are specific to a particular host system, target

linker scripts are specific to a particular host system, target

architecture, and target memory layout, this manual cannot provide

architecture, and target memory layout, this manual cannot provide

portable sample code demonstrating GDB's overlay support.

portable sample code demonstrating GDB's overlay support.

   However, the GDB source distribution does contain an overlaid

   However, the GDB source distribution does contain an overlaid

program, with linker scripts for a few systems, as part of its test

program, with linker scripts for a few systems, as part of its test

suite.  The program consists of the following files from

suite.  The program consists of the following files from

`gdb/testsuite/gdb.base':

`gdb/testsuite/gdb.base':

`overlays.c'

`overlays.c'

     The main program file.

     The main program file.

`ovlymgr.c'

`ovlymgr.c'

     A simple overlay manager, used by `overlays.c'.

     A simple overlay manager, used by `overlays.c'.

`foo.c'

`foo.c'

`bar.c'

`bar.c'

`baz.c'

`baz.c'

`grbx.c'

`grbx.c'

     Overlay modules, loaded and used by `overlays.c'.

     Overlay modules, loaded and used by `overlays.c'.

`d10v.ld'

`d10v.ld'

`m32r.ld'

`m32r.ld'

     Linker scripts for linking the test program on the `d10v-elf' and

     Linker scripts for linking the test program on the `d10v-elf' and

     `m32r-elf' targets.

     `m32r-elf' targets.

   You can build the test program using the `d10v-elf' GCC

   You can build the test program using the `d10v-elf' GCC

cross-compiler like this:

cross-compiler like this:

     $ d10v-elf-gcc -g -c overlays.c

     $ d10v-elf-gcc -g -c overlays.c

     $ d10v-elf-gcc -g -c ovlymgr.c

     $ d10v-elf-gcc -g -c ovlymgr.c

     $ d10v-elf-gcc -g -c foo.c

     $ d10v-elf-gcc -g -c foo.c

     $ d10v-elf-gcc -g -c bar.c

     $ d10v-elf-gcc -g -c bar.c

     $ d10v-elf-gcc -g -c baz.c

     $ d10v-elf-gcc -g -c baz.c

     $ d10v-elf-gcc -g -c grbx.c

     $ d10v-elf-gcc -g -c grbx.c

     $ d10v-elf-gcc -g overlays.o ovlymgr.o foo.o bar.o \

     $ d10v-elf-gcc -g overlays.o ovlymgr.o foo.o bar.o \

                       baz.o grbx.o -Wl,-Td10v.ld -o overlays

                       baz.o grbx.o -Wl,-Td10v.ld -o overlays

   The build process is identical for any other architecture, except

   The build process is identical for any other architecture, except

that you must substitute the appropriate compiler and linker script for

that you must substitute the appropriate compiler and linker script for

the target system for `d10v-elf-gcc' and `d10v.ld'.

the target system for `d10v-elf-gcc' and `d10v.ld'.

File: gdb.info,  Node: Languages,  Next: Symbols,  Prev: Overlays,  Up: Top

File: gdb.info,  Node: Languages,  Next: Symbols,  Prev: Overlays,  Up: Top

12 Using GDB with Different Languages

12 Using GDB with Different Languages

*************************************

*************************************

Although programming languages generally have common aspects, they are

Although programming languages generally have common aspects, they are

rarely expressed in the same manner.  For instance, in ANSI C,

rarely expressed in the same manner.  For instance, in ANSI C,

dereferencing a pointer `p' is accomplished by `*p', but in Modula-2,

dereferencing a pointer `p' is accomplished by `*p', but in Modula-2,

it is accomplished by `p^'.  Values can also be represented (and

it is accomplished by `p^'.  Values can also be represented (and

displayed) differently.  Hex numbers in C appear as `0x1ae', while in

displayed) differently.  Hex numbers in C appear as `0x1ae', while in

Modula-2 they appear as `1AEH'.

Modula-2 they appear as `1AEH'.

   Language-specific information is built into GDB for some languages,

   Language-specific information is built into GDB for some languages,

allowing you to express operations like the above in your program's

allowing you to express operations like the above in your program's

native language, and allowing GDB to output values in a manner

native language, and allowing GDB to output values in a manner

consistent with the syntax of your program's native language.  The

consistent with the syntax of your program's native language.  The

language you use to build expressions is called the "working language".

language you use to build expressions is called the "working language".

* Menu:

* Menu:

* Setting::                     Switching between source languages

* Setting::                     Switching between source languages

* Show::                        Displaying the language

* Show::                        Displaying the language

* Checks::                      Type and range checks

* Checks::                      Type and range checks

* Supported Languages::         Supported languages

* Supported Languages::         Supported languages

* Unsupported Languages::       Unsupported languages

* Unsupported Languages::       Unsupported languages

File: gdb.info,  Node: Setting,  Next: Show,  Up: Languages

File: gdb.info,  Node: Setting,  Next: Show,  Up: Languages

12.1 Switching Between Source Languages

12.1 Switching Between Source Languages

=======================================

=======================================

There are two ways to control the working language--either have GDB set

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

it automatically, or select it manually yourself.  You can use the `set

language' command for either purpose.  On startup, GDB defaults to

language' command for either purpose.  On startup, GDB defaults to

setting the language automatically.  The working language is used to

setting the language automatically.  The working language is used to

determine how expressions you type are interpreted, how values are

determine how expressions you type are interpreted, how values are

printed, etc.

printed, etc.

   In addition to the working language, every source file that GDB

   In addition to the working language, every source file that GDB

knows about has its own working language.  For some object file

knows about has its own working language.  For some object file

formats, the compiler might indicate which language a particular source

formats, the compiler might indicate which language a particular source

file is in.  However, most of the time GDB infers the language from the

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++

name of the file.  The language of a source file controls whether C++

names are demangled--this way `backtrace' can show each frame

names are demangled--this way `backtrace' can show each frame

appropriately for its own language.  There is no way to set the

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

language of a source file from within GDB, but you can set the language

associated with a filename extension.  *Note Displaying the Language:

associated with a filename extension.  *Note Displaying the Language:

Show.

Show.

   This is most commonly a problem when you use a program, such as

   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.

`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;

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

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

original program, and will display that source code, not the generated

C code.

C code.

* Menu:

* Menu:

* Filenames::                   Filename extensions and languages.

* Filenames::                   Filename extensions and languages.

* Manually::                    Setting the working language manually

* Manually::                    Setting the working language manually

* Automatically::               Having GDB infer the source language

* Automatically::               Having GDB infer the source language

File: gdb.info,  Node: Filenames,  Next: Manually,  Up: Setting

File: gdb.info,  Node: Filenames,  Next: Manually,  Up: Setting

12.1.1 List of Filename Extensions and Languages

12.1.1 List of Filename Extensions and Languages

------------------------------------------------

------------------------------------------------

If a source file name ends in one of the following extensions, then GDB

If a source file name ends in one of the following extensions, then GDB

infers that its language is the one indicated.

infers that its language is the one indicated.

`.ada'

`.ada'

`.ads'

`.ads'

`.adb'

`.adb'

`.a'

`.a'

     Ada source file.

     Ada source file.

`.c'

`.c'

     C source file

     C source file

`.C'

`.C'

`.cc'

`.cc'

`.cp'

`.cp'

`.cpp'

`.cpp'

`.cxx'

`.cxx'

`.c++'

`.c++'

     C++ source file

     C++ source file

`.m'

`.m'

     Objective-C source file

     Objective-C source file

`.f'

`.f'

`.F'

`.F'

     Fortran source file

     Fortran source file

`.mod'

`.mod'

     Modula-2 source file

     Modula-2 source file

`.s'

`.s'

`.S'

`.S'

     Assembler source file.  This actually behaves almost like C, but

     Assembler source file.  This actually behaves almost like C, but

     GDB does not skip over function prologues when stepping.

     GDB does not skip over function prologues when stepping.

   In addition, you may set the language associated with a filename

   In addition, you may set the language associated with a filename

extension.  *Note Displaying the Language: Show.

extension.  *Note Displaying the Language: Show.

File: gdb.info,  Node: Manually,  Next: Automatically,  Prev: Filenames,  Up: Setting

File: gdb.info,  Node: Manually,  Next: Automatically,  Prev: Filenames,  Up: Setting

12.1.2 Setting the Working Language

12.1.2 Setting the Working Language

-----------------------------------

-----------------------------------

If you allow GDB to set the language automatically, expressions are

If you allow GDB to set the language automatically, expressions are

interpreted the same way in your debugging session and your program.

interpreted the same way in your debugging session and your program.

   If you wish, you may set the language manually.  To do this, issue

   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,

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

such as `c' or `modula-2'.  For a list of the supported languages, type

`set language'.

`set language'.

   Setting the language manually prevents GDB from updating the working

   Setting the language manually prevents GDB from updating the working

language automatically.  This can lead to confusion if you try to debug

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

a program when the working language is not the same as the source

language, when an expression is acceptable to both languages--but means

language, when an expression is acceptable to both languages--but means

different things.  For instance, if the current source file were

different things.  For instance, if the current source file were

written in C, and GDB was parsing Modula-2, a command such as:

written in C, and GDB was parsing Modula-2, a command such as:

     print a = b + c

     print a = b + c

might not have the effect you intended.  In C, this means to add `b'

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

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

value of `a'.  In Modula-2, this means to compare `a' to the result of

`b+c', yielding a `BOOLEAN' value.

`b+c', yielding a `BOOLEAN' value.

File: gdb.info,  Node: Automatically,  Prev: Manually,  Up: Setting

File: gdb.info,  Node: Automatically,  Prev: Manually,  Up: Setting

12.1.3 Having GDB Infer the Source Language

12.1.3 Having GDB Infer the Source Language

-------------------------------------------

-------------------------------------------

To have GDB set the working language automatically, use `set language

To have GDB set the working language automatically, use `set language

local' or `set language auto'.  GDB then infers the working 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

That is, when your program stops in a frame (usually by encountering a

breakpoint), GDB sets the working language to the language recorded for

breakpoint), GDB sets the working language to the language recorded for

the function in that frame.  If the language for a frame is unknown

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

(that is, if the function or block corresponding to the frame was

defined in a source file that does not have a recognized extension),

defined in a source file that does not have a recognized extension),

the current working language is not changed, and GDB issues a warning.

the current working language is not changed, and GDB issues a warning.

   This may not seem necessary for most programs, which are written

   This may not seem necessary for most programs, which are written

entirely in one source language.  However, program modules and libraries

entirely in one source language.  However, program modules and libraries

written in one source language can be used by a main program written in

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

a different source language.  Using `set language auto' in this case

frees you from having to set the working language manually.

frees you from having to set the working language manually.

File: gdb.info,  Node: Show,  Next: Checks,  Prev: Setting,  Up: Languages

File: gdb.info,  Node: Show,  Next: Checks,  Prev: Setting,  Up: Languages

12.2 Displaying the Language

12.2 Displaying the Language

============================

============================

The following commands help you find out which language is the working

The following commands help you find out which language is the working

language, and also what language source files were written in.

language, and also what language source files were written in.

`show language'

`show language'

     Display the current working language.  This is the language you

     Display the current working language.  This is the language you

     can use with commands such as `print' to build and compute

     can use with commands such as `print' to build and compute

     expressions that may involve variables in your program.

     expressions that may involve variables in your program.

`info frame'

`info frame'

     Display the source language for this frame.  This language becomes

     Display the source language for this frame.  This language becomes

     the working language if you use an identifier from this frame.

     the working language if you use an identifier from this frame.

     *Note Information about a Frame: Frame Info, to identify the other

     *Note Information about a Frame: Frame Info, to identify the other

     information listed here.

     information listed here.

`info source'

`info source'

     Display the source language of this source file.  *Note Examining

     Display the source language of this source file.  *Note Examining

     the Symbol Table: Symbols, to identify the other information

     the Symbol Table: Symbols, to identify the other information

     listed here.

     listed here.

   In unusual circumstances, you may have source files with extensions

   In unusual circumstances, you may have source files with extensions

not in the standard list.  You can then set the extension associated

not in the standard list.  You can then set the extension associated

with a language explicitly:

with a language explicitly:

`set extension-language EXT LANGUAGE'

`set extension-language EXT LANGUAGE'

     Tell GDB that source files with extension EXT are to be assumed as

     Tell GDB that source files with extension EXT are to be assumed as

     written in the source language LANGUAGE.

     written in the source language LANGUAGE.

`info extensions'

`info extensions'

     List all the filename extensions and the associated languages.

     List all the filename extensions and the associated languages.

File: gdb.info,  Node: Checks,  Next: Supported Languages,  Prev: Show,  Up: Languages

File: gdb.info,  Node: Checks,  Next: Supported Languages,  Prev: Show,  Up: Languages

12.3 Type and Range Checking

12.3 Type and Range Checking

============================

============================

     _Warning:_ In this release, the GDB commands for type and range

     _Warning:_ In this release, the GDB commands for type and range

     checking are included, but they do not yet have any effect.  This

     checking are included, but they do not yet have any effect.  This

     section documents the intended facilities.

     section documents the intended facilities.

   Some languages are designed to guard you against making seemingly

   Some languages are designed to guard you against making seemingly

common errors through a series of compile- and run-time checks.  These

common errors through a series of compile- and run-time checks.  These

include checking the type of arguments to functions and operators, and

include checking the type of arguments to functions and operators, and

making sure mathematical overflows are caught at run time.  Checks such

making sure mathematical overflows are caught at run time.  Checks such

as these help to ensure a program's correctness once it has been

as these help to ensure a program's correctness once it has been

compiled by eliminating type mismatches, and providing active checks

compiled by eliminating type mismatches, and providing active checks

for range errors when your program is running.

for range errors when your program is running.

   GDB can check for conditions like the above if you wish.  Although

   GDB can check for conditions like the above if you wish.  Although

GDB does not check the statements in your program, it can check

GDB does not check the statements in your program, it can check

expressions entered directly into GDB for evaluation via the `print'

expressions entered directly into GDB for evaluation via the `print'

command, for example.  As with the working language, GDB can also

command, for example.  As with the working language, GDB can also

decide whether or not to check automatically based on your program's

decide whether or not to check automatically based on your program's

source language.  *Note Supported Languages: Supported Languages, for

source language.  *Note Supported Languages: Supported Languages, for

the default settings of supported languages.

the default settings of supported languages.

* Menu:

* Menu:

* Type Checking::               An overview of type checking

* Type Checking::               An overview of type checking

* Range Checking::              An overview of range checking

* Range Checking::              An overview of range checking

File: gdb.info,  Node: Type Checking,  Next: Range Checking,  Up: Checks

File: gdb.info,  Node: Type Checking,  Next: Range Checking,  Up: Checks

12.3.1 An Overview of Type Checking

12.3.1 An Overview of Type Checking

-----------------------------------

-----------------------------------

Some languages, such as Modula-2, are strongly typed, meaning that the

Some languages, such as Modula-2, are strongly typed, meaning that the

arguments to operators and functions have to be of the correct type,

arguments to operators and functions have to be of the correct type,

otherwise an error occurs.  These checks prevent type mismatch errors

otherwise an error occurs.  These checks prevent type mismatch errors

from ever causing any run-time problems.  For example,

from ever causing any run-time problems.  For example,

     1 + 2 => 3

     1 + 2 => 3

but

but

     error--> 1 + 2.3

     error--> 1 + 2.3

   The second example fails because the `CARDINAL' 1 is not

   The second example fails because the `CARDINAL' 1 is not

type-compatible with the `REAL' 2.3.

type-compatible with the `REAL' 2.3.

   For the expressions you use in GDB commands, you can tell the GDB

   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

type checker to skip checking; to treat any mismatches as errors and

abandon the expression; or to only issue warnings when type mismatches

abandon the expression; or to only issue warnings when type mismatches

occur, but evaluate the expression anyway.  When you choose the last of

occur, but evaluate the expression anyway.  When you choose the last of

these, GDB evaluates expressions like the second example above, but

these, GDB evaluates expressions like the second example above, but

also issues a warning.

also issues a warning.

   Even if you turn type checking off, there may be other reasons

   Even if you turn type checking off, there may be other reasons

related to type that prevent GDB from evaluating an expression.  For

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'.

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

These particular type errors have nothing to do with the language in

use, and usually arise from expressions, such as the one described

use, and usually arise from expressions, such as the one described

above, which make little sense to evaluate anyway.

above, which make little sense to evaluate anyway.

   Each language defines to what degree it is strict about type.  For

   Each language defines to what degree it is strict about type.  For

instance, both Modula-2 and C require the arguments to arithmetical

instance, both Modula-2 and C require the arguments to arithmetical

operators to be numbers.  In C, enumerated types and pointers can be

operators to be numbers.  In C, enumerated types and pointers can be

represented as numbers, so that they are valid arguments to mathematical

represented as numbers, so that they are valid arguments to mathematical

operators.  *Note Supported Languages: Supported Languages, for further

operators.  *Note Supported Languages: Supported Languages, for further

details on specific languages.

details on specific languages.

   GDB provides some additional commands for controlling the type

   GDB provides some additional commands for controlling the type

checker:

checker:

`set check type auto'

`set check type auto'

     Set type checking on or off based on the current working language.

     Set type checking on or off based on the current working language.

     *Note Supported Languages: Supported Languages, for the default

     *Note Supported Languages: Supported Languages, for the default

     settings for each language.

     settings for each language.

`set check type on'

`set check type on'

`set check type off'

`set check type off'

     Set type checking on or off, overriding the default setting for the

     Set type checking on or off, overriding the default setting for the

     current working language.  Issue a warning if the setting does not

     current working language.  Issue a warning if the setting does not

     match the language default.  If any type mismatches occur in

     match the language default.  If any type mismatches occur in

     evaluating an expression while type checking is on, GDB prints a

     evaluating an expression while type checking is on, GDB prints a

     message and aborts evaluation of the expression.

     message and aborts evaluation of the expression.

`set check type warn'

`set check type warn'

     Cause the type checker to issue warnings, but to always attempt to

     Cause the type checker to issue warnings, but to always attempt to

     evaluate the expression.  Evaluating the expression may still be

     evaluate the expression.  Evaluating the expression may still be

     impossible for other reasons.  For example, GDB cannot add numbers

     impossible for other reasons.  For example, GDB cannot add numbers

     and structures.

     and structures.

`show type'

`show type'

     Show the current setting of the type checker, and whether or not

     Show the current setting of the type checker, and whether or not

     GDB is setting it automatically.

     GDB is setting it automatically.

File: gdb.info,  Node: Range Checking,  Prev: Type Checking,  Up: Checks

File: gdb.info,  Node: Range Checking,  Prev: Type Checking,  Up: Checks

12.3.2 An Overview of Range Checking

12.3.2 An Overview of Range Checking

------------------------------------

------------------------------------

In some languages (such as Modula-2), it is an error to exceed the

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

bounds of a type; this is enforced with run-time checks.  Such range

checking is meant to ensure program correctness by making sure

checking is meant to ensure program correctness by making sure

computations do not overflow, or indices on an array element access do

computations do not overflow, or indices on an array element access do

not exceed the bounds of the array.

not exceed the bounds of the array.

   For expressions you use in GDB commands, you can tell GDB to treat

   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

range errors in one of three ways: ignore them, always treat them as

errors and abandon the expression, or issue warnings but evaluate the

errors and abandon the expression, or issue warnings but evaluate the

expression anyway.

expression anyway.

   A range error can result from numerical overflow, from exceeding an

   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

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.

any type.  Some languages, however, do not treat overflows as an error.

In many implementations of C, mathematical overflow causes the result

In many implementations of C, mathematical overflow causes the result

to "wrap around" to lower values--for example, if M is the largest

to "wrap around" to lower values--for example, if M is the largest

integer value, and S is the smallest, then

integer value, and S is the smallest, then

     M + 1 => S

     M + 1 => S

   This, too, is specific to individual languages, and in some cases

   This, too, is specific to individual languages, and in some cases

specific to individual compilers or machines.  *Note Supported

specific to individual compilers or machines.  *Note Supported

Languages: Supported Languages, for further details on specific

Languages: Supported Languages, for further details on specific

languages.

languages.

   GDB provides some additional commands for controlling the range

   GDB provides some additional commands for controlling the range

checker:

checker:

`set check range auto'

`set check range auto'

     Set range checking on or off based on the current working language.

     Set range checking on or off based on the current working language.

     *Note Supported Languages: Supported Languages, for the default

     *Note Supported Languages: Supported Languages, for the default

     settings for each language.

     settings for each language.

`set check range on'

`set check range on'

`set check range off'

`set check range off'

     Set range checking on or off, overriding the default setting for

     Set range checking on or off, overriding the default setting for

     the current working language.  A warning is issued if the setting

     the current working language.  A warning is issued if the setting

     does not match the language default.  If a range error occurs and

     does not match the language default.  If a range error occurs and

     range checking is on, then a message is printed and evaluation of

     range checking is on, then a message is printed and evaluation of

     the expression is aborted.

     the expression is aborted.

`set check range warn'

`set check range warn'

     Output messages when the GDB range checker detects a range error,

     Output messages when the GDB range checker detects a range error,

     but attempt to evaluate the expression anyway.  Evaluating the

     but attempt to evaluate the expression anyway.  Evaluating the

     expression may still be impossible for other reasons, such as

     expression may still be impossible for other reasons, such as

     accessing memory that the process does not own (a typical example

     accessing memory that the process does not own (a typical example

     from many Unix systems).

     from many Unix systems).

`show range'

`show range'

     Show the current setting of the range checker, and whether or not

     Show the current setting of the range checker, and whether or not

     it is being set automatically by GDB.

     it is being set automatically by GDB.

File: gdb.info,  Node: Supported Languages,  Next: Unsupported Languages,  Prev: Checks,  Up: Languages

File: gdb.info,  Node: Supported Languages,  Next: Unsupported Languages,  Prev: Checks,  Up: Languages

12.4 Supported Languages

12.4 Supported Languages

========================

========================

GDB supports C, C++, Objective-C, Fortran, Java, Pascal, assembly,

GDB supports C, C++, Objective-C, Fortran, Java, Pascal, assembly,

Modula-2, and Ada.  Some GDB features may be used in expressions

Modula-2, and Ada.  Some GDB features may be used in expressions

regardless of the language you use: the GDB `@' and `::' operators, and

regardless of the language you use: the GDB `@' and `::' operators, and

the `{type}addr' construct (*note Expressions: Expressions.) can be

the `{type}addr' construct (*note Expressions: Expressions.) can be

used with the constructs of any supported language.

used with the constructs of any supported language.

   The following sections detail to what degree each source language is

   The following sections detail to what degree each source language is

supported by GDB.  These sections are not meant to be language

supported by GDB.  These sections are not meant to be language

tutorials or references, but serve only as a reference guide to what the

tutorials or references, but serve only as a reference guide to what the

GDB expression parser accepts, and what input and output formats should

GDB expression parser accepts, and what input and output formats should

look like for different languages.  There are many good books written

look like for different languages.  There are many good books written

on each of these languages; please look to these for a language

on each of these languages; please look to these for a language

reference or tutorial.

reference or tutorial.

* Menu:

* Menu:

* C::                           C and C++

* C::                           C and C++

* Objective-C::                 Objective-C

* Objective-C::                 Objective-C

* Fortran::                     Fortran

* Fortran::                     Fortran

* Pascal::                      Pascal

* Pascal::                      Pascal

* Modula-2::                    Modula-2

* Modula-2::                    Modula-2

* Ada::                         Ada

* Ada::                         Ada

File: gdb.info,  Node: C,  Next: Objective-C,  Up: Supported Languages

File: gdb.info,  Node: C,  Next: Objective-C,  Up: Supported Languages

12.4.1 C and C++

12.4.1 C and C++

----------------

----------------

Since C and C++ are so closely related, many features of GDB apply to

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

both languages.  Whenever this is the case, we discuss those languages

together.

together.

   The C++ debugging facilities are jointly implemented by the C++

   The C++ debugging facilities are jointly implemented by the C++

compiler and GDB.  Therefore, to debug your C++ code effectively, you

compiler and GDB.  Therefore, to debug your C++ code effectively, you

must compile your C++ programs with a supported C++ compiler, such as

must compile your C++ programs with a supported C++ compiler, such as

GNU `g++', or the HP ANSI C++ compiler (`aCC').

GNU `g++', or the HP ANSI C++ compiler (`aCC').

   For best results when using GNU C++, use the DWARF 2 debugging

   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; if it doesn't work on your system, try the stabs+ debugging

format.  You can select those formats explicitly with the `g++'

format.  You can select those formats explicitly with the `g++'

command-line options `-gdwarf-2' and `-gstabs+'.  *Note Options for

command-line options `-gdwarf-2' and `-gstabs+'.  *Note Options for

Debugging Your Program or GCC: (gcc.info)Debugging Options.

Debugging Your Program or GCC: (gcc.info)Debugging Options.

* Menu:

* Menu:

* C Operators::                 C and C++ operators

* C Operators::                 C and C++ operators

* C Constants::                 C and C++ constants

* C Constants::                 C and C++ constants

* C Plus Plus Expressions::     C++ expressions

* C Plus Plus Expressions::     C++ expressions

* C Defaults::                  Default settings for C and C++

* C Defaults::                  Default settings for C and C++

* C Checks::                    C and C++ type and range checks

* C Checks::                    C and C++ type and range checks

* Debugging C::                 GDB and C

* Debugging C::                 GDB and C

* Debugging C Plus Plus::       GDB features for C++

* Debugging C Plus Plus::       GDB features for C++

* Decimal Floating Point::      Numbers in Decimal Floating Point format

* Decimal Floating Point::      Numbers in Decimal Floating Point format

File: gdb.info,  Node: C Operators,  Next: C Constants,  Up: C

File: gdb.info,  Node: C Operators,  Next: C Constants,  Up: C

12.4.1.1 C and C++ Operators

12.4.1.1 C and C++ Operators

............................

............................

Operators must be defined on values of specific types.  For instance,

Operators must be defined on values of specific types.  For instance,

`+' is defined on numbers, but not on structures.  Operators are often

`+' is defined on numbers, but not on structures.  Operators are often

defined on groups of types.

defined on groups of types.

   For the purposes of C and C++, the following definitions hold:

   For the purposes of C and C++, the following definitions hold:

   * _Integral types_ include `int' with any of its storage-class

   * _Integral types_ include `int' with any of its storage-class

     specifiers; `char'; `enum'; and, for C++, `bool'.

     specifiers; `char'; `enum'; and, for C++, `bool'.

   * _Floating-point types_ include `float', `double', and `long

   * _Floating-point types_ include `float', `double', and `long

     double' (if supported by the target platform).

     double' (if supported by the target platform).

   * _Pointer types_ include all types defined as `(TYPE *)'.

   * _Pointer types_ include all types defined as `(TYPE *)'.

   * _Scalar types_ include all of the above.

   * _Scalar types_ include all of the above.

The following operators are supported.  They are listed here in order

The following operators are supported.  They are listed here in order

of increasing precedence:

of increasing precedence:

`,'

`,'

     The comma or sequencing operator.  Expressions in a

     The comma or sequencing operator.  Expressions in a

     comma-separated list are evaluated from left to right, with the

     comma-separated list are evaluated from left to right, with the

     result of the entire expression being the last expression

     result of the entire expression being the last expression

     evaluated.

     evaluated.

`='

`='

     Assignment.  The value of an assignment expression is the value

     Assignment.  The value of an assignment expression is the value

     assigned.  Defined on scalar types.

     assigned.  Defined on scalar types.

`OP='

`OP='

     Used in an expression of the form `A OP= B', and translated to

     Used in an expression of the form `A OP= B', and translated to

     `A = A OP B'.  `OP=' and `=' have the same precedence.  OP is any

     `A = A OP B'.  `OP=' and `=' have the same precedence.  OP is any

     one of the operators `|', `^', `&', `<<', `>>', `+', `-', `*',

     one of the operators `|', `^', `&', `<<', `>>', `+', `-', `*',

     `/', `%'.

     `/', `%'.

`?:'

`?:'

     The ternary operator.  `A ? B : C' can be thought of as:  if A

     The ternary operator.  `A ? B : C' can be thought of as:  if A

     then B else C.  A should be of an integral type.

     then B else C.  A should be of an integral type.

`||'

`||'

     Logical OR.  Defined on integral types.

     Logical OR.  Defined on integral types.

`&&'

`&&'

     Logical AND.  Defined on integral types.

     Logical AND.  Defined on integral types.

`|'

`|'

     Bitwise OR.  Defined on integral types.

     Bitwise OR.  Defined on integral types.

`^'

`^'

     Bitwise exclusive-OR.  Defined on integral types.

     Bitwise exclusive-OR.  Defined on integral types.

`&'

`&'

     Bitwise AND.  Defined on integral types.

     Bitwise AND.  Defined on integral types.

`==, !='

`==, !='

     Equality and inequality.  Defined on scalar types.  The value of

     Equality and inequality.  Defined on scalar types.  The value of

     these expressions is 0 for false and non-zero for true.

     these expressions is 0 for false and non-zero for true.

`<, >, <=, >='

`<, >, <=, >='

     Less than, greater than, less than or equal, greater than or equal.

     Less than, greater than, less than or equal, greater than or equal.

     Defined on scalar types.  The value of these expressions is 0 for

     Defined on scalar types.  The value of these expressions is 0 for

     false and non-zero for true.

     false and non-zero for true.

`<<, >>'

`<<, >>'

     left shift, and right shift.  Defined on integral types.

     left shift, and right shift.  Defined on integral types.

`@'

`@'

     The GDB "artificial array" operator (*note Expressions:

     The GDB "artificial array" operator (*note Expressions:

     Expressions.).

     Expressions.).

`+, -'

`+, -'

     Addition and subtraction.  Defined on integral types,

     Addition and subtraction.  Defined on integral types,

     floating-point types and pointer types.

     floating-point types and pointer types.

`*, /, %'

`*, /, %'

     Multiplication, division, and modulus.  Multiplication and

     Multiplication, division, and modulus.  Multiplication and

     division are defined on integral and floating-point types.

     division are defined on integral and floating-point types.

     Modulus is defined on integral types.

     Modulus is defined on integral types.

`++, --'

`++, --'

     Increment and decrement.  When appearing before a variable, the

     Increment and decrement.  When appearing before a variable, the

     operation is performed before the variable is used in an

     operation is performed before the variable is used in an

     expression; when appearing after it, the variable's value is used

     expression; when appearing after it, the variable's value is used

     before the operation takes place.

     before the operation takes place.

`*'

`*'

     Pointer dereferencing.  Defined on pointer types.  Same precedence

     Pointer dereferencing.  Defined on pointer types.  Same precedence

     as `++'.

     as `++'.

`&'

`&'

     Address operator.  Defined on variables.  Same precedence as `++'.

     Address operator.  Defined on variables.  Same precedence as `++'.

     For debugging C++, GDB implements a use of `&' beyond what is

     For debugging C++, GDB implements a use of `&' beyond what is

     allowed in the C++ language itself: you can use `&(&REF)' to

     allowed in the C++ language itself: you can use `&(&REF)' to

     examine the address where a C++ reference variable (declared with

     examine the address where a C++ reference variable (declared with

     `&REF') is stored.

     `&REF') is stored.

`-'

`-'

     Negative.  Defined on integral and floating-point types.  Same

     Negative.  Defined on integral and floating-point types.  Same

     precedence as `++'.

     precedence as `++'.

`!'

`!'

     Logical negation.  Defined on integral types.  Same precedence as

     Logical negation.  Defined on integral types.  Same precedence as

     `++'.

     `++'.

`~'

`~'

     Bitwise complement operator.  Defined on integral types.  Same

     Bitwise complement operator.  Defined on integral types.  Same

     precedence as `++'.

     precedence as `++'.

`., ->'

`., ->'

     Structure member, and pointer-to-structure member.  For

     Structure member, and pointer-to-structure member.  For

     convenience, GDB regards the two as equivalent, choosing whether

     convenience, GDB regards the two as equivalent, choosing whether

     to dereference a pointer based on the stored type information.

     to dereference a pointer based on the stored type information.

     Defined on `struct' and `union' data.

     Defined on `struct' and `union' data.

`.*, ->*'

`.*, ->*'

     Dereferences of pointers to members.

     Dereferences of pointers to members.

`[]'

`[]'

     Array indexing.  `A[I]' is defined as `*(A+I)'.  Same precedence

     Array indexing.  `A[I]' is defined as `*(A+I)'.  Same precedence

     as `->'.

     as `->'.

`()'

`()'

     Function parameter list.  Same precedence as `->'.

     Function parameter list.  Same precedence as `->'.

`::'

`::'

     C++ scope resolution operator.  Defined on `struct', `union', and

     C++ scope resolution operator.  Defined on `struct', `union', and

     `class' types.

     `class' types.

`::'

`::'

     Doubled colons also represent the GDB scope operator (*note

     Doubled colons also represent the GDB scope operator (*note

     Expressions: Expressions.).  Same precedence as `::', above.

     Expressions: Expressions.).  Same precedence as `::', above.

   If an operator is redefined in the user code, GDB usually attempts

   If an operator is redefined in the user code, GDB usually attempts

to invoke the redefined version instead of using the operator's

to invoke the redefined version instead of using the operator's

predefined meaning.

predefined meaning.

File: gdb.info,  Node: C Constants,  Next: C Plus Plus Expressions,  Prev: C Operators,  Up: C

File: gdb.info,  Node: C Constants,  Next: C Plus Plus Expressions,  Prev: C Operators,  Up: C

12.4.1.2 C and C++ Constants

12.4.1.2 C and C++ Constants

............................

............................

GDB allows you to express the constants of C and C++ in the following

GDB allows you to express the constants of C and C++ in the following

ways:

ways:

   * Integer constants are a sequence of digits.  Octal constants are

   * Integer constants are a sequence of digits.  Octal constants are

     specified by a leading `0' (i.e. zero), and hexadecimal constants

     specified by a leading `0' (i.e. zero), and hexadecimal constants

     by a leading `0x' or `0X'.  Constants may also end with a letter

     by a leading `0x' or `0X'.  Constants may also end with a letter

     `l', specifying that the constant should be treated as a `long'

     `l', specifying that the constant should be treated as a `long'

     value.

     value.

   * Floating point constants are a sequence of digits, followed by a

   * Floating point constants are a sequence of digits, followed by a

     decimal point, followed by a sequence of digits, and optionally

     decimal point, followed by a sequence of digits, and optionally

     followed by an exponent.  An exponent is of the form:

     followed by an exponent.  An exponent is of the form:

     `e[[+]|-]NNN', where NNN is another sequence of digits.  The `+'

     `e[[+]|-]NNN', where NNN is another sequence of digits.  The `+'

     is optional for positive exponents.  A floating-point constant may

     is optional for positive exponents.  A floating-point constant may

     also end with a letter `f' or `F', specifying that the constant

     also end with a letter `f' or `F', specifying that the constant

     should be treated as being of the `float' (as opposed to the

     should be treated as being of the `float' (as opposed to the

     default `double') type; or with a letter `l' or `L', which

     default `double') type; or with a letter `l' or `L', which

     specifies a `long double' constant.

     specifies a `long double' constant.

   * Enumerated constants consist of enumerated identifiers, or their

   * Enumerated constants consist of enumerated identifiers, or their

     integral equivalents.

     integral equivalents.

   * Character constants are a single character surrounded by single

   * Character constants are a single character surrounded by single

     quotes (`''), or a number--the ordinal value of the corresponding

     quotes (`''), or a number--the ordinal value of the corresponding

     character (usually its ASCII value).  Within quotes, the single

     character (usually its ASCII value).  Within quotes, the single

     character may be represented by a letter or by "escape sequences",

     character may be represented by a letter or by "escape sequences",

     which are of the form `\NNN', where NNN is the octal representation

     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'

     of the character's ordinal value; or of the form `\X', where `X'

     is a predefined special character--for example, `\n' for newline.

     is a predefined special character--for example, `\n' for newline.

   * String constants are a sequence of character constants surrounded

   * String constants are a sequence of character constants surrounded

     by double quotes (`"').  Any valid character constant (as described

     by double quotes (`"').  Any valid character constant (as described

     above) may appear.  Double quotes within the string must be

     above) may appear.  Double quotes within the string must be

     preceded by a backslash, so for instance `"a\"b'c"' is a string of

     preceded by a backslash, so for instance `"a\"b'c"' is a string of

     five characters.

     five characters.

   * Pointer constants are an integral value.  You can also write

   * Pointer constants are an integral value.  You can also write

     pointers to constants using the C operator `&'.

     pointers to constants using the C operator `&'.

   * Array constants are comma-separated lists surrounded by braces `{'

   * Array constants are comma-separated lists surrounded by braces `{'

     and `}'; for example, `{1,2,3}' is a three-element array of

     and `}'; for example, `{1,2,3}' is a three-element array of

     integers, `{{1,2}, {3,4}, {5,6}}' is a three-by-two array, and

     integers, `{{1,2}, {3,4}, {5,6}}' is a three-by-two array, and

     `{&"hi", &"there", &"fred"}' is a three-element array of pointers.

     `{&"hi", &"there", &"fred"}' is a three-element array of pointers.

File: gdb.info,  Node: C Plus Plus Expressions,  Next: C Defaults,  Prev: C Constants,  Up: C

File: gdb.info,  Node: C Plus Plus Expressions,  Next: C Defaults,  Prev: C Constants,  Up: C

12.4.1.3 C++ Expressions

12.4.1.3 C++ Expressions

........................

........................

GDB expression handling can interpret most C++ expressions.

GDB expression handling can interpret most C++ expressions.

     _Warning:_ GDB can only debug C++ code if you use the proper

     _Warning:_ GDB can only debug C++ code if you use the proper

     compiler and the proper debug format.  Currently, GDB works best

     compiler and the proper debug format.  Currently, GDB works best

     when debugging C++ code that is compiled with GCC 2.95.3 or with

     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+'.

     GCC 3.1 or newer, using the options `-gdwarf-2' or `-gstabs+'.

     DWARF 2 is preferred over stabs+.  Most configurations of GCC emit

     DWARF 2 is preferred over stabs+.  Most configurations of GCC emit

     either DWARF 2 or stabs+ as their default debug format, so you

     either DWARF 2 or stabs+ as their default debug format, so you

     usually don't need to specify a debug format explicitly.  Other

     usually don't need to specify a debug format explicitly.  Other

     compilers and/or debug formats are likely to work badly or not at

     compilers and/or debug formats are likely to work badly or not at

     all when using GDB to debug C++ code.

     all when using GDB to debug C++ code.

  1. Member function calls are allowed; you can use expressions like

  1. Member function calls are allowed; you can use expressions like

          count = aml->GetOriginal(x, y)

          count = aml->GetOriginal(x, y)

  2. While a member function is active (in the selected stack frame),

  2. While a member function is active (in the selected stack frame),

     your expressions have the same namespace available as the member

     your expressions have the same namespace available as the member

     function; that is, GDB allows implicit references to the class

     function; that is, GDB allows implicit references to the class

     instance pointer `this' following the same rules as C++.

     instance pointer `this' following the same rules as C++.

  3. You can call overloaded functions; GDB resolves the function call

  3. You can call overloaded functions; GDB resolves the function call

     to the right definition, with some restrictions.  GDB does not

     to the right definition, with some restrictions.  GDB does not

     perform overload resolution involving user-defined type

     perform overload resolution involving user-defined type

     conversions, calls to constructors, or instantiations of templates

     conversions, calls to constructors, or instantiations of templates

     that do not exist in the program.  It also cannot handle ellipsis

     that do not exist in the program.  It also cannot handle ellipsis

     argument lists or default arguments.

     argument lists or default arguments.

     It does perform integral conversions and promotions, floating-point

     It does perform integral conversions and promotions, floating-point

     promotions, arithmetic conversions, pointer conversions,

     promotions, arithmetic conversions, pointer conversions,

     conversions of class objects to base classes, and standard

     conversions of class objects to base classes, and standard

     conversions such as those of functions or arrays to pointers; it

     conversions such as those of functions or arrays to pointers; it

     requires an exact match on the number of function arguments.

     requires an exact match on the number of function arguments.

     Overload resolution is always performed, unless you have specified

     Overload resolution is always performed, unless you have specified

     `set overload-resolution off'.  *Note GDB Features for C++:

     `set overload-resolution off'.  *Note GDB Features for C++:

     Debugging C Plus Plus.

     Debugging C Plus Plus.

     You must specify `set overload-resolution off' in order to use an

     You must specify `set overload-resolution off' in order to use an

     explicit function signature to call an overloaded function, as in

     explicit function signature to call an overloaded function, as in

          p 'foo(char,int)'('x', 13)

          p 'foo(char,int)'('x', 13)

     The GDB command-completion facility can simplify this; see *Note

     The GDB command-completion facility can simplify this; see *Note

     Command Completion: Completion.

     Command Completion: Completion.

  4. GDB understands variables declared as C++ references; you can use

  4. GDB understands variables declared as C++ references; you can use

     them in expressions just as you do in C++ source--they are

     them in expressions just as you do in C++ source--they are

     automatically dereferenced.

     automatically dereferenced.

     In the parameter list shown when GDB displays a frame, the values

     In the parameter list shown when GDB displays a frame, the values

     of reference variables are not displayed (unlike other variables);

     of reference variables are not displayed (unlike other variables);

     this avoids clutter, since references are often used for large

     this avoids clutter, since references are often used for large

     structures.  The _address_ of a reference variable is always

     structures.  The _address_ of a reference variable is always

     shown, unless you have specified `set print address off'.

     shown, unless you have specified `set print address off'.

  5. GDB supports the C++ name resolution operator `::'--your

  5. GDB supports the C++ name resolution operator `::'--your

     expressions can use it just as expressions in your program do.

     expressions can use it just as expressions in your program do.

     Since one scope may be defined in another, you can use `::'

     Since one scope may be defined in another, you can use `::'

     repeatedly if necessary, for example in an expression like

     repeatedly if necessary, for example in an expression like

     `SCOPE1::SCOPE2::NAME'.  GDB also allows resolving name scope by

     `SCOPE1::SCOPE2::NAME'.  GDB also allows resolving name scope by

     reference to source files, in both C and C++ debugging (*note

     reference to source files, in both C and C++ debugging (*note

     Program Variables: Variables.).

     Program Variables: Variables.).

   In addition, when used with HP's C++ compiler, GDB supports calling

   In addition, when used with HP's C++ compiler, GDB supports calling

virtual functions correctly, printing out virtual bases of objects,

virtual functions correctly, printing out virtual bases of objects,

calling functions in a base subobject, casting objects, and invoking

calling functions in a base subobject, casting objects, and invoking

user-defined operators.

user-defined operators.

File: gdb.info,  Node: C Defaults,  Next: C Checks,  Prev: C Plus Plus Expressions,  Up: C

File: gdb.info,  Node: C Defaults,  Next: C Checks,  Prev: C Plus Plus Expressions,  Up: C

12.4.1.4 C and C++ Defaults

12.4.1.4 C and C++ Defaults

...........................

...........................

If you allow GDB to set type and range checking automatically, they

If you allow GDB to set type and range checking automatically, they

both default to `off' whenever the working language changes to C or

both default to `off' whenever the working language changes to C or

C++.  This happens regardless of whether you or GDB selects the working

C++.  This happens regardless of whether you or GDB selects the working

language.

language.

   If you allow GDB to set the language automatically, it recognizes

   If you allow GDB to set the language automatically, it recognizes

source files whose names end with `.c', `.C', or `.cc', etc, and when

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

GDB enters code compiled from one of these files, it sets the working

language to C or C++.  *Note Having GDB Infer the Source Language:

language to C or C++.  *Note Having GDB Infer the Source Language:

Automatically, for further details.

Automatically, for further details.

File: gdb.info,  Node: C Checks,  Next: Debugging C,  Prev: C Defaults,  Up: C

File: gdb.info,  Node: C Checks,  Next: Debugging C,  Prev: C Defaults,  Up: C

12.4.1.5 C and C++ Type and Range Checks

12.4.1.5 C and C++ Type and Range Checks

........................................

........................................

By default, when GDB parses C or C++ expressions, type checking is not

By default, when GDB parses C or C++ expressions, type checking is not

used.  However, if you turn type checking on, GDB considers two

used.  However, if you turn type checking on, GDB considers two

variables type equivalent if:

variables type equivalent if:

   * The two variables are structured and have the same structure,

   * The two variables are structured and have the same structure,

     union, or enumerated tag.

     union, or enumerated tag.

   * The two variables have the same type name, or types that have been

   * The two variables have the same type name, or types that have been

     declared equivalent through `typedef'.

     declared equivalent through `typedef'.

   Range checking, if turned on, is done on mathematical operations.

   Range checking, if turned on, is done on mathematical operations.

Array indices are not checked, since they are often used to index a

Array indices are not checked, since they are often used to index a

pointer that is not itself an array.

pointer that is not itself an array.

File: gdb.info,  Node: Debugging C,  Next: Debugging C Plus Plus,  Prev: C Checks,  Up: C

File: gdb.info,  Node: Debugging C,  Next: Debugging C Plus Plus,  Prev: C Checks,  Up: C

12.4.1.6 GDB and C

12.4.1.6 GDB and C

..................

..................

The `set print union' and `show print union' commands apply to the

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'

`union' type.  When set to `on', any `union' that is inside a `struct'

or `class' is also printed.  Otherwise, it appears as `{...}'.

or `class' is also printed.  Otherwise, it appears as `{...}'.

   The `@' operator aids in the debugging of dynamic arrays, formed

   The `@' operator aids in the debugging of dynamic arrays, formed

with pointers and a memory allocation function.  *Note Expressions:

with pointers and a memory allocation function.  *Note Expressions:

Expressions.

Expressions.

File: gdb.info,  Node: Debugging C Plus Plus,  Next: Decimal Floating Point,  Prev: Debugging C,  Up: C

File: gdb.info,  Node: Debugging C Plus Plus,  Next: Decimal Floating Point,  Prev: Debugging C,  Up: C

12.4.1.7 GDB Features for C++

12.4.1.7 GDB Features for C++

.............................

.............................

Some GDB commands are particularly useful with C++, and some are

Some GDB commands are particularly useful with C++, and some are

designed specifically for use with C++.  Here is a summary:

designed specifically for use with C++.  Here is a summary:

`breakpoint menus'

`breakpoint menus'

     When you want a breakpoint in a function whose name is overloaded,

     When you want a breakpoint in a function whose name is overloaded,

     GDB breakpoint menus help you specify which function definition

     GDB breakpoint menus help you specify which function definition

     you want.  *Note Breakpoint Menus: Breakpoint Menus.

     you want.  *Note Breakpoint Menus: Breakpoint Menus.

`rbreak REGEX'

`rbreak REGEX'

     Setting breakpoints using regular expressions is helpful for

     Setting breakpoints using regular expressions is helpful for

     setting breakpoints on overloaded functions that are not members

     setting breakpoints on overloaded functions that are not members

     of any special classes.  *Note Setting Breakpoints: Set Breaks.

     of any special classes.  *Note Setting Breakpoints: Set Breaks.

`catch throw'

`catch throw'

`catch catch'

`catch catch'

     Debug C++ exception handling using these commands.  *Note Setting

     Debug C++ exception handling using these commands.  *Note Setting

     Catchpoints: Set Catchpoints.

     Catchpoints: Set Catchpoints.

`ptype TYPENAME'

`ptype TYPENAME'

     Print inheritance relationships as well as other information for

     Print inheritance relationships as well as other information for

     type TYPENAME.  *Note Examining the Symbol Table: Symbols.

     type TYPENAME.  *Note Examining the Symbol Table: Symbols.

`set print demangle'

`set print demangle'

`show print demangle'

`show print demangle'

`set print asm-demangle'

`set print asm-demangle'

`show print asm-demangle'

`show print asm-demangle'

     Control whether C++ symbols display in their source form, both when

     Control whether C++ symbols display in their source form, both when

     displaying code as C++ source and when displaying disassemblies.

     displaying code as C++ source and when displaying disassemblies.

     *Note Print Settings: Print Settings.

     *Note Print Settings: Print Settings.

`set print object'

`set print object'

`show print object'

`show print object'

     Choose whether to print derived (actual) or declared types of

     Choose whether to print derived (actual) or declared types of

     objects.  *Note Print Settings: Print Settings.

     objects.  *Note Print Settings: Print Settings.

`set print vtbl'

`set print vtbl'

`show print vtbl'

`show print vtbl'

     Control the format for printing virtual function tables.  *Note

     Control the format for printing virtual function tables.  *Note

     Print Settings: Print Settings.  (The `vtbl' commands do not work

     Print Settings: Print Settings.  (The `vtbl' commands do not work

     on programs compiled with the HP ANSI C++ compiler (`aCC').)

     on programs compiled with the HP ANSI C++ compiler (`aCC').)

`set overload-resolution on'

`set overload-resolution on'

     Enable overload resolution for C++ expression evaluation.  The

     Enable overload resolution for C++ expression evaluation.  The

     default is on.  For overloaded functions, GDB evaluates the

     default is on.  For overloaded functions, GDB evaluates the

     arguments and searches for a function whose signature matches the

     arguments and searches for a function whose signature matches the

     argument types, using the standard C++ conversion rules (see *Note

     argument types, using the standard C++ conversion rules (see *Note

     C++ Expressions: C Plus Plus Expressions, for details).  If it

     C++ Expressions: C Plus Plus Expressions, for details).  If it

     cannot find a match, it emits a message.

     cannot find a match, it emits a message.

`set overload-resolution off'

`set overload-resolution off'

     Disable overload resolution for C++ expression evaluation.  For

     Disable overload resolution for C++ expression evaluation.  For

     overloaded functions that are not class member functions, GDB

     overloaded functions that are not class member functions, GDB

     chooses the first function of the specified name that it finds in

     chooses the first function of the specified name that it finds in

     the symbol table, whether or not its arguments are of the correct

     the symbol table, whether or not its arguments are of the correct

     type.  For overloaded functions that are class member functions,

     type.  For overloaded functions that are class member functions,

     GDB searches for a function whose signature _exactly_ matches the

     GDB searches for a function whose signature _exactly_ matches the

     argument types.

     argument types.

`show overload-resolution'

`show overload-resolution'

     Show the current setting of overload resolution.

     Show the current setting of overload resolution.

`Overloaded symbol names'

`Overloaded symbol names'

     You can specify a particular definition of an overloaded symbol,

     You can specify a particular definition of an overloaded symbol,

     using the same notation that is used to declare such symbols in

     using the same notation that is used to declare such symbols in

     C++: type `SYMBOL(TYPES)' rather than just SYMBOL.  You can also

     C++: type `SYMBOL(TYPES)' rather than just SYMBOL.  You can also

     use the GDB command-line word completion facilities to list the

     use the GDB command-line word completion facilities to list the

     available choices, or to finish the type list for you.  *Note

     available choices, or to finish the type list for you.  *Note

     Command Completion: Completion, for details on how to do this.

     Command Completion: Completion, for details on how to do this.