Info file gdb.info, produced by Makeinfo, -*- Text -*- from input
file gdb-all.texi.

   This file documents the GNU debugger GDB.

   Copyright (C) 1988, 1989, 1990, 1991 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of
this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this
manual under the conditions for verbatim copying, provided also that
the section entitled "GNU General Public License" is included
exactly as in the original, and provided that the entire resulting
derived work is distributed under the terms of a permission notice
identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for
modified versions, except that the section entitled "GNU General
Public License" may be included in a translation approved by the
Free Software Foundation instead of in the original English.


File: gdb.info,  Node: Index,  Prev: Copying,  Up: Top

Index
*****

* Menu:

* #:                                    Command Syntax.
* $_:                                   Convenience Vars.
* $__:                                  Convenience Vars.
* .:                                    M2 Scope.
* :::                                   M2 Scope.
* :::                                   Variables.
* @:                                    Arrays.
* # in Modula-2:                        GDB/M2.
* $$:                                   Value History.
* $_ and info breakpoints:              Set Breaks.
* $_ and info line:                     Machine Code.
* $_, $__, and value history:           Memory.
* $:                                    Value History.
* .gdbinit:                             Command Files.
* AMD EB29K:                            Target Commands.
* Bug Criteria:                         Bug Criteria.
* Bug Reports:                          Bug Reporting.
* Bugs in GDB:                          GDB Bugs.
* C and C++:                            C.
* C and C++ checks:                     C Checks.
* C and C++ constants:                  C Operators.
* C and C++ defaults:                   C Defaults.
* C and C++ operators:                  C.
* C++:                                  C.
* C++ exception handling:               Debugging C plus plus.
* C++ scope resolution:                 Variables.
* C++ symbol display:                   Debugging C plus plus.
* Core Dump:                            Bug Criteria.
* EB29K board:                          EB29K Remote.
* EBMON:                                Comms (EB29K).
* Fatal Signal:                         Bug Criteria.
* GDB Bugs, Reporting:                  Bug Reporting.
* GDB reference card:                   Formatting Documentation.
* GNU C++:                              C.
* INCLUDE_RDB:                          VxWorks Remote.
* Invalid Input:                        Bug Criteria.
* Modula-2:                             Modula-2.
* Modula-2 builtins:                    M2 Operators.
* Modula-2 checks:                      M2 Checks.
* Modula-2 constants:                   Builtin Func/Proc.
* Modula-2 defaults:                    M2 Defaults.
* Modula-2 operators:                   M2 Operators.
* Modula-2, deviations from:            Deviations.
* Nindy:                                i960-Nindy Remote.
* RET:                                  Command Syntax.
* Reporting Bugs in GDB:                GDB Bugs.
* VxWorks:                              VxWorks Remote.
* abbreviation:                         Command Syntax.
* active targets:                       Active Targets.
* add-symbol-file:                      Files.
* add-syms:                             Renamed Commands.
* arguments (to your program):          Arguments.
* artificial array:                     Arrays.
* assignment:                           Assignment.
* attach:                               Attach.
* attach:                               Attach.
* automatic display:                    Auto Display.
* b:                                    Set Breaks.
* backtrace:                            Backtrace.
* break:                                Set Breaks.
* break in overloaded functions:        Debugging C plus plus.
* breakpoint commands:                  Break Commands.
* breakpoint conditions:                Conditions.
* breakpoints:                          Breakpoints.
* bt:                                   Backtrace.
* call:                                 Calling.
* call overloaded functions:            Cplusplus expressions.
* call stack:                           Stack.
* calling functions:                    Calling.
* calling make:                         Shell Commands.
* catch:                                Exception Handling.
* catch exceptions:                     Frame Info.
* cd:                                   Working Directory.
* checks, range:                        Type Checking.
* checks, type:                         Checks.
* clear:                                Delete Breaks.
* clearing breakpoints, watchpoints:    Delete Breaks.
* colon-colon:                          Variables.
* command files:                        Command Files.
* command line editing:                 Editing.
* commands:                             Break Commands.
* commands for C++:                     Debugging C plus plus.
* comment:                              Command Syntax.
* condition:                            Conditions.
* conditional breakpoints:              Conditions.
* configuring GDB:                      Installing GDB.
* confirmation:                         Messages/Warnings.
* continue:                             Continuing and Stepping.
* continue COUNT:                       Conditions.
* continuing:                           Continuing and Stepping.
* controlling terminal:                 Input/Output.
* convenience variables:                Convenience Vars.
* core:                                 Files.
* core dump file:                       Files.
* core-file:                            Files.
* d:                                    Delete Breaks.
* debugging target:                     Targets.
* define:                               Define.
* delete:                               Delete Breaks.
* delete breakpoints:                   Delete Breaks.
* delete display:                       Auto Display.
* delete environment:                   Renamed Commands.
* deleting breakpoints, watchpoints:    Delete Breaks.
* detach:                               Attach.
* directories for source files:         Source Path.
* directory:                            Source Path.
* dis:                                  Disabling.
* disable:                              Disabling.
* disable breakpoints:                  Disabling.
* disable display:                      Auto Display.
* disabled breakpoints:                 Disabling.
* disassemble:                          Machine Code.
* display:                              Auto Display.
* display of expressions:               Auto Display.
* do:                                   Selection.
* document:                             Define.
* down:                                 Selection.
* down-silently:                        Selection.
* download to Nindy-960:                Files.
* download to VxWorks:                  VxWorks download.
* dynamic linking:                      Files.
* eb.log:                               Remote Log.
* echo:                                 Output.
* editing:                              Editing.
* emacs:                                Emacs.
* enable:                               Disabling.
* enable breakpoints:                   Disabling.
* enable display:                       Auto Display.
* enabled breakpoints:                  Disabling.
* end:                                  Break Commands.
* entering numbers:                     Numbers.
* environment (of your program):        Environment.
* error on Valid Input:                 Bug Criteria.
* examining data:                       Data.
* examining memory:                     Memory.
* exception handlers:                   Exception Handling.
* exception handlers:                   Frame Info.
* exec-file:                            Files.
* executable file:                      Files.
* exiting GDB:                          Leaving GDB.
* expressions:                          Expressions.
* expressions in C or C++:              C.
* expressions in C++:                   Cplusplus expressions.
* expressions in Modula-2:              Modula-2.
* f:                                    Selection.
* fatal signals:                        Signals.
* file:                                 Files.
* finish:                               Continuing and Stepping.
* flinching:                            Messages/Warnings.
* floating point:                       Floating Point Hardware.
* floating point registers:             Registers.
* foo:                                  Symbol Errors.
* format options:                       Print Settings.
* formatted output:                     Output formats.
* forward-search:                       Search.
* frame:                                Selection.
* frame:                                Frames.
* frame number:                         Frames.
* frame pointer:                        Frames.
* frameless execution:                  Frames.
* g++:                                  C.
* h:                                    Help.
* handle:                               Signals.
* handling signals:                     Signals.
* help:                                 Help.
* help target:                          Target Commands.
* help user-defined:                    Define.
* history expansion:                    History.
* history file:                         History.
* history number:                       Value History.
* history save:                         History.
* history size:                         History.
* history substitution:                 History.
* i:                                    Help.
* i/o:                                  Input/Output.
* i960:                                 i960-Nindy Remote.
* ignore:                               Conditions.
* ignore count (of breakpoint):         Conditions.
* info:                                 Help.
* info address:                         Symbols.
* info all-registers:                   Registers.
* info args:                            Frame Info.
* info breakpoints:                     Set Breaks.
* info catch:                           Frame Info.
* info convenience:                     Renamed Commands.
* info copying:                         Renamed Commands.
* info directories:                     Renamed Commands.
* info display:                         Auto Display.
* info editing:                         Renamed Commands.
* info f:                               Frame Info.
* info files:                           Files.
* info float:                           Floating Point Hardware.
* info frame:                           Show.
* info frame:                           Frame Info.
* info functions:                       Symbols.
* info history:                         Renamed Commands.
* info line:                            Machine Code.
* info locals:                          Frame Info.
* info program:                         Stopping.
* info registers:                       Registers.
* info s:                               Backtrace.
* info set:                             Help.
* info share:                           Files.
* info sharedlibrary:                   Files.
* info signals:                         Signals.
* info source:                          Show.
* info source:                          Symbols.
* info sources:                         Symbols.
* info stack:                           Backtrace.
* info target:                          Files.
* info targets:                         Renamed Commands.
* info terminal:                        Input/Output.
* info types:                           Symbols.
* info user:                            Define.
* info values:                          Renamed Commands.
* info variables:                       Symbols.
* info version:                         Renamed Commands.
* info warranty:                        Renamed Commands.
* info watchpoints:                     Set Watchpoints.
* inheritance:                          Debugging C plus plus.
* init file:                            Command Files.
* initial frame:                        Frames.
* innermost frame:                      Frames.
* inspect:                              Data.
* installation:                         Installing GDB.
* interrupt:                            Leaving GDB.
* jump:                                 Jumping.
* kill:                                 Kill Process.
* l:                                    List.
* languages:                            Languages.
* linespec:                             List.
* list:                                 List.
* load:                                 Files.
* log file for EB29K:                   Remote Log.
* lost output:                          Break Commands.
* make:                                 Shell Commands.
* member functions:                     Cplusplus expressions.
* multiple targets:                     Active Targets.
* n:                                    Continuing and Stepping.
* namespace in C++:                     Cplusplus expressions.
* next:                                 Continuing and Stepping.
* nexti:                                Continuing and Stepping.
* ni:                                   Continuing and Stepping.
* number representation:                Numbers.
* online documentation:                 Help.
* outermost frame:                      Frames.
* output:                               Output.
* output formats:                       Output formats.
* overloading:                          Breakpoint Menus.
* overloading in C++:                   Debugging C plus plus.
* partial symbol dump:                  Symbols.
* patching binaries:                    Patching.
* path:                                 Environment.
* pauses in output:                     Screen Size.
* pipes:                                Starting.
* print:                                Data.
* print settings:                       Print Settings.
* printf:                               Output.
* printing data:                        Data.
* printsyms:                            Symbols.
* printsyms:                            Symbols.
* prompt:                               Prompt.
* ptype:                                Symbols.
* pwd:                                  Working Directory.
* q:                                    Leaving GDB.
* quit:                                 Leaving GDB.
* raise exceptions:                     Exception Handling.
* range checking:                       Type Checking.
* rbreak:                               Set Breaks.
* readline:                             Editing.
* redirection:                          Input/Output.
* reference card:                       Formatting Documentation.
* reference declarations:               Cplusplus expressions.
* registers:                            Registers.
* regular expression:                   Set Breaks.
* reloading symbols:                    Messages/Warnings.
* remote debugging:                     Remote.
* repeating commands:                   Command Syntax.
* reset:                                Nindy reset.
* resuming execution:                   Continuing and Stepping.
* return:                               Returning.
* returning from a function:            Returning.
* reverse-search:                       Search.
* run:                                  Starting.
* running:                              Starting.
* running 29K programs:                 EB29K Remote.
* running VxWorks tasks:                VxWorks attach.
* s:                                    Continuing and Stepping.
* scope:                                M2 Scope.
* search:                               Search.
* searching:                            Search.
* selected frame:                       Stack.
* set addressprint:                     Renamed Commands.
* set args:                             Arguments.
* set array-max:                        Renamed Commands.
* set arrayprint:                       Renamed Commands.
* set asm-demangle:                     Renamed Commands.
* set caution:                          Renamed Commands.
* set check:                            Type Checking.
* set check:                            Range Checking.
* set check range:                      Range Checking.
* set check type:                       Type Checking.
* set complaints:                       Messages/Warnings.
* set confirm:                          Messages/Warnings.
* set demangle:                         Renamed Commands.
* set editing:                          Editing.
* set environment:                      Environment.
* set height:                           Screen Size.
* set history expansion:                History.
* set history filename:                 History.
* set history save:                     History.
* set history size:                     History.
* set history write:                    Renamed Commands.
* set language:                         Manually.
* set listsize:                         List.
* set prettyprint:                      Renamed Commands.
* set print address:                    Print Settings.
* set print array:                      Print Settings.
* set print asm-demangle:               Print Settings.
* set print demangle:                   Print Settings.
* set print elements:                   Print Settings.
* set print object:                     Print Settings.
* set print pretty:                     Print Settings.
* set print sevenbit-strings:           Print Settings.
* set print union:                      Print Settings.
* set print vtbl:                       Print Settings.
* set prompt:                           Prompt.
* set radix:                            Numbers.
* set screen-height:                    Renamed Commands.
* set screen-width:                     Renamed Commands.
* set sevenbit-strings:                 Renamed Commands.
* set symbol-reloading:                 Messages/Warnings.
* set unionprint:                       Renamed Commands.
* set variable:                         Assignment.
* set verbose:                          Messages/Warnings.
* set vtblprint:                        Renamed Commands.
* set width:                            Screen Size.
* set write:                            Patching.
* setting variables:                    Assignment.
* setting watchpoints:                  Set Watchpoints.
* share:                                Files.
* shared libraries:                     Files.
* sharedlibrary:                        Files.
* shell:                                Shell Commands.
* shell escape:                         Shell Commands.
* show:                                 Help.
* show addressprint:                    Renamed Commands.
* show args:                            Arguments.
* show array-max:                       Renamed Commands.
* show arrayprint:                      Renamed Commands.
* show asm-demangle:                    Renamed Commands.
* show caution:                         Renamed Commands.
* show check range:                     Range Checking.
* show check type:                      Type Checking.
* show commands:                        History.
* show complaints:                      Messages/Warnings.
* show confirm:                         Messages/Warnings.
* show convenience:                     Convenience Vars.
* show copying:                         Help.
* show demangle:                        Renamed Commands.
* show directories:                     Source Path.
* show editing:                         Editing.
* show environment:                     Environment.
* show height:                          Screen Size.
* show history:                         History.
* show history write:                   Renamed Commands.
* show language:                        Show.
* show listsize:                        List.
* show paths:                           Environment.
* show prettyprint:                     Renamed Commands.
* show print address:                   Print Settings.
* show print array:                     Print Settings.
* show print asm-demangle:              Print Settings.
* show print demangle:                  Print Settings.
* show print elements:                  Print Settings.
* show print object:                    Print Settings.
* show print pretty:                    Print Settings.
* show print sevenbit-strings:          Print Settings.
* show print union:                     Print Settings.
* show print vtbl:                      Print Settings.
* show prompt:                          Prompt.
* show radix:                           Numbers.
* show screen-height:                   Renamed Commands.
* show screen-width:                    Renamed Commands.
* show sevenbit-strings:                Renamed Commands.
* show unionprint:                      Renamed Commands.
* show values:                          Value History.
* show verbose:                         Messages/Warnings.
* show version:                         Help.
* show vtblprint:                       Renamed Commands.
* show warranty:                        Help.
* show width:                           Screen Size.
* show write:                           Patching.
* si:                                   Continuing and Stepping.
* signal:                               Signaling.
* signals:                              Signals.
* silent:                               Break Commands.
* size of screen:                       Screen Size.
* source:                               Command Files.
* source path:                          Source Path.
* stack frame:                          Frames.
* stacking targets:                     Active Targets.
* starting:                             Starting.
* step:                                 Continuing and Stepping.
* stepi:                                Continuing and Stepping.
* stepping:                             Continuing and Stepping.
* stupid questions:                     Messages/Warnings.
* symbol dump:                          Symbols.
* symbol overloading:                   Breakpoint Menus.
* symbol table:                         Files.
* symbol-file:                          Files.
* target:                               Targets.
* target amd-eb:                        Target Commands.
* target core:                          Target Commands.
* target exec:                          Target Commands.
* target nindy:                         Target Commands.
* target remote:                        Target Commands.
* target vxworks:                       Target Commands.
* tbreak:                               Set Breaks.
* terminal:                             Input/Output.
* this:                                 Cplusplus expressions.
* tty:                                  Input/Output.
* type checking:                        Checks.
* type conversions in C++:              Cplusplus expressions.
* u:                                    Continuing and Stepping.
* undisplay:                            Auto Display.
* unset:                                Renamed Commands.
* unset environment:                    Environment.
* until:                                Continuing and Stepping.
* up:                                   Selection.
* up-silently:                          Selection.
* user-defined command:                 Define.
* value history:                        Value History.
* variable name conflict:               Variables.
* variable values, wrong:               Variables.
* variables, setting:                   Assignment.
* version number:                       Help.
* watch:                                Set Watchpoints.
* watchpoints:                          Breakpoints.
* whatis:                               Symbols.
* where:                                Backtrace.
* working directory (of your program):  Working Directory.
* working language:                     Languages.
* writing into corefiles:               Patching.
* writing into executables:             Patching.
* wrong values:                         Variables.
* x:                                    Memory.


