InfoMagic Source Code 1993 July

home *** CD-ROM | disk | FTP | other *** search

/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / gdb / gdb.info-6 < prev next >

Wrap

GNU Info File | 1993-05-12 | 49.9 KB | 1,297 lines

This is Info file ./gdb.info, produced by Makeinfo-1.52 from the input file gdb.texinfo. START-INFO-DIR-ENTRY * Gdb: (gdb). The GNU debugger. END-INFO-DIR-ENTRY This file documents the GNU debugger GDB. This is Edition 4.09, April 1993, of `Debugging with GDB: the GNU Source-Level Debugger' for GDB Version 4.9. Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 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: gdb-EB29K, Next: Remote Log, Prev: Comms (EB29K), Up: EB29K Remote EB29K cross-debugging --------------------- Finally, `cd' to the directory containing an image of your 29K program on the Unix system, and start GDB--specifying as argument the name of your 29K program: cd /usr/joe/work29k gdb myfoo Now you can use the `target' command: target amd-eb /dev/ttya 9600 MYFOO In this example, we've assumed your program is in a file called `myfoo'. Note that the filename given as the last argument to `target amd-eb' should be the name of the program as it appears to DOS. In our example this is simply `MYFOO', but in general it can include a DOS path, and depending on your transfer mechanism may not resemble the name on the Unix side. At this point, you can set any breakpoints you wish; when you are ready to see your program run on the 29K board, use the GDB command `run'. To stop debugging the remote program, use the GDB `detach' command. To return control of the PC to its console, use `tip' or `cu' once again, after your GDB session has concluded, to attach to `EBMON'. You can then type the command `q' to shut down `EBMON', returning control to the DOS command-line interpreter. Type `CTTY con' to return command input to the main DOS console, and type `~.' to leave `tip' or `cu'. File: gdb.info, Node: Remote Log, Prev: gdb-EB29K, Up: EB29K Remote Remote log ---------- The `target amd-eb' command creates a file `eb.log' in the current working directory, to help debug problems with the connection. `eb.log' records all the output from `EBMON', including echoes of the commands sent to it. Running `tail -f' on this file in another window often helps to understand trouble with `EBMON', or unexpected events on the PC side of the connection. File: gdb.info, Node: ST2000 Remote, Next: Hitachi Remote, Prev: VxWorks Remote, Up: Remote GDB with a Tandem ST2000 ------------------------ To connect your ST2000 to the host system, see the manufacturer's manual. Once the ST2000 is physically attached, you can run target st2000 DEV SPEED to establish it as your debugging environment. The `load' and `attach' commands are *not* defined for this target; you must load your program into the ST2000 as you normally would for standalone operation. GDB will read debugging information (such as symbols) from a separate, debugging version of the program available on your host computer. These auxiliary GDB commands are available to help you with the ST2000 environment: `st2000 COMMAND' Send a COMMAND to the STDBUG monitor. See the manufacturer's manual for available commands. `connect' Connect the controlling terminal to the STDBUG command monitor. When you are done interacting with STDBUG, typing either of two character sequences will get you back to the GDB command prompt: `RET~.' (Return, followed by tilde and period) or `RET~C-d' (Return, followed by tilde and control-D). File: gdb.info, Node: VxWorks Remote, Next: ST2000 Remote, Prev: EB29K Remote, Up: Remote GDB and VxWorks --------------- GDB enables developers to spawn and debug tasks running on networked VxWorks targets from a Unix host. Already-running tasks spawned from the VxWorks shell can also be debugged. GDB uses code that runs on both the UNIX host and on the VxWorks target. The program `gdb' is installed and executed on the UNIX host. The following information on connecting to VxWorks was current when this manual was produced; newer releases of VxWorks may use revised procedures. The remote debugging interface (RDB) routines are installed and executed on the VxWorks target. These routines are included in the VxWorks library `rdb.a' and are incorporated into the system image when source-level debugging is enabled in the VxWorks configuration. If you wish, you can define `INCLUDE_RDB' in the VxWorks configuration file `configAll.h' to include the RDB interface routines and spawn the source debugging task `tRdbTask' when VxWorks is booted. For more information on configuring and remaking VxWorks, see the manufacturer's manual. Once you have included the RDB interface in your VxWorks system image and set your Unix execution search path to find GDB, you are ready to run GDB. From your UNIX host, type: % gdb GDB will come up showing the prompt: (gdb) * Menu: * VxWorks Connection:: Connecting to VxWorks * VxWorks Download:: VxWorks download * VxWorks Attach:: Running tasks File: gdb.info, Node: VxWorks Connection, Next: VxWorks Download, Up: VxWorks Remote Connecting to VxWorks --------------------- The GDB command `target' lets you connect to a VxWorks target on the network. To connect to a target whose host name is "`tt'", type: (gdb) target vxworks tt GDB will display a message similar to the following: Attaching remote machine across net... Success! GDB will then attempt to read the symbol tables of any object modules loaded into the VxWorks target since it was last booted. GDB locates these files by searching the directories listed in the command search path (*note Your program's environment: Environment.); if it fails to find an object file, it will display a message such as: prog.o: No such file or directory. This will cause the `target' command to abort. When this happens, you should add the appropriate directory to the search path, with the GDB command `path', and execute the `target' command again. File: gdb.info, Node: VxWorks Download, Next: VxWorks Attach, Prev: VxWorks Connection, Up: VxWorks Remote VxWorks download ---------------- If you have connected to the VxWorks target and you want to debug an object that has not yet been loaded, you can use the GDB `load' command to download a file from UNIX to VxWorks incrementally. The object file given as an argument to the `load' command is actually opened twice: first by the VxWorks target in order to download the code, then by GDB in order to read the symbol table. This can lead to problems if the current working directories on the two systems differ. It is simplest to set the working directory on both systems to the directory in which the object file resides, and then to reference the file by its name, without any path. Thus, to load a program `prog.o', residing in `wherever/vw/demo/rdb', on VxWorks type: -> cd "wherever/vw/demo/rdb" On GDB type: (gdb) cd wherever/vw/demo/rdb (gdb) load prog.o GDB will display a response similar to the following: Reading symbol data from wherever/vw/demo/rdb/prog.o... done. You can also use the `load' command to reload an object module after editing and recompiling the corresponding source file. Note that this will cause GDB to delete all currently-defined breakpoints, auto-displays, and convenience variables, and to clear the value history. (This is necessary in order to preserve the integrity of debugger data structures that reference the target system's symbol table.) File: gdb.info, Node: VxWorks Attach, Prev: VxWorks Download, Up: VxWorks Remote Running tasks ------------- You can also attach to an existing task using the `attach' command as follows: (gdb) attach TASK where TASK is the VxWorks hexadecimal task ID. The task can be running or suspended when you attach to it. If running, it will be suspended at the time of attachment. File: gdb.info, Node: Hitachi Remote, Next: MIPS Remote, Prev: ST2000 Remote, Up: Remote GDB and Hitachi Microprocessors ------------------------------- GDB needs to know these things to talk to your Hitachi SH, H8/300, or H8/500: 1. that you want to use `target hms', the remote debugging interface for Hitachi microprocessors (this is the default when GDB is configured specifically for the Hitachi SH, H8/300, or H8/500); 2. what serial device connects your host to your Hitachi board (the first serial device available on your host is the default); Use the special `gdb' command `device PORT' if you need to explicitly set the serial device. The default PORT is the first available port on your host. This is only necessary on Unix hosts, where it is typically something like `/dev/ttya'. `gdb' has another special command to set the communications speed: `speed BPS'. This command also is only used from Unix hosts; on DOS hosts, set the line speed as usual from outside GDB with the DOS `mode' command (for instance, `mode com2:9600,n,8,1,p' for a 9600 bps connection). The `device' and `speed' commands are available only when you use a Unix host to debug your Hitachi microprocessor programs. If you use a DOS host, GDB depends on an auxiliary terminate-and-stay-resident program called `asynctsr' to communicate with the development board through a PC serial port. You must also use the DOS `mode' command to set up the serial port on the DOS side. File: gdb.info, Node: MIPS Remote, Next: Simulator, Prev: Hitachi Remote, Up: Remote GDB and remote MIPS boards -------------------------- GDB can use the MIPS remote debugging protocol to talk to a MIPS board attached to a serial line. This is available when you configure GDB with `--target=mips-idt-ecoff'. To run a program on the board, start up `gdb' with the name of your program as the argument. To connect to the board, use the command `target mips PORT', where PORT is the name of the serial port connected to the board. If the program has not already been downloaded to the board, you may use the `load' command to download it. You can then use all the usual GDB commands. You can see some debugging information about communications with the board by setting the `remotedebug' variable. If you set it to 1 using `set remotedebug 1' every packet will be displayed. If you set it to 2 every character will be displayed. You can check the current value at any time with the command `show remotedebug'. If your target board does not support the MIPS floating point coprocessor, you should use the command `set mipsfpu off' (you may wish to put this in your .gdbinit file). This will tell GDB how to find the return value of functions which return floating point values, and tell it to call functions on the board without saving the floating point registers. File: gdb.info, Node: Simulator, Prev: MIPS Remote, Up: Remote Simulated CPU target -------------------- For some configurations, GDB includes a CPU simulator that you can use instead of a hardware CPU to debug your programs. Currently, a simulator is available when GDB is configured to debug Zilog Z8000 or Hitachi microprocessor targets. For the Z8000 family, `target sim' simulates either the Z8002 (the unsegmented variant of the Z8000 architecture) or the Z8001 (the segmented variant). The simulator recognizes which architecture is appropriate by inspecting the object code. `target sim' Debug programs on a simulated CPU (which CPU depends on the GDB configuration) After specifying this target, you can debug programs for the simulated CPU in the same style as programs for your host computer; use the `file' command to load a new program image, the `run' command to run your program, and so on. As well as making available all the usual machine registers (see `info reg'), this debugging target provides three additional items of information as specially named registers: `cycles' Counts clock-ticks in the simulator. `insts' Counts instructions run in the simulator. `time' Execution time in 60ths of a second. You can refer to these values in GDB expressions with the usual conventions; for example, `b fputc if $cycles>5000' sets a conditional breakpoint that will suspend only after at least 5000 simulated clock ticks. File: gdb.info, Node: Controlling GDB, Next: Sequences, Prev: Targets, Up: Top Controlling GDB *************** You can alter the way GDB interacts with you by using the `set' command. For commands controlling how GDB displays data, *note Print settings: Print Settings.; other settings are described here. * Menu: * Prompt:: Prompt * Editing:: Command editing * History:: Command history * Screen Size:: Screen size * Numbers:: Numbers * Messages/Warnings:: Optional warnings and messages File: gdb.info, Node: Prompt, Next: Editing, Up: Controlling GDB Prompt ====== GDB indicates its readiness to read a command by printing a string called the "prompt". This string is normally `(gdb)'. You can change the prompt string with the `set prompt' command. For instance, when debugging GDB with GDB, it is useful to change the prompt in one of the GDB sessions so that you can always tell which one you are talking to. `set prompt NEWPROMPT' Directs GDB to use NEWPROMPT as its prompt string henceforth. `show prompt' Prints a line of the form: `Gdb's prompt is: YOUR-PROMPT' File: gdb.info, Node: Editing, Next: History, Prev: Prompt, Up: Controlling GDB Command editing =============== GDB reads its input commands via the "readline" interface. This GNU library provides consistent behavior for programs which provide a command line interface to the user. Advantages are `emacs'-style or `vi'-style inline editing of commands, `csh'-like history substitution, and a storage and recall of command history across debugging sessions. You may control the behavior of command line editing in GDB with the command `set'. `set editing' `set editing on' Enable command line editing (enabled by default). `set editing off' Disable command line editing. `show editing' Show whether command line editing is enabled. File: gdb.info, Node: History, Next: Screen Size, Prev: Editing, Up: Controlling GDB Command history =============== GDB can keep track of the commands you type during your debugging sessions, so that you can be certain of precisely what happened. Use these commands to manage the GDB command history facility. `set history filename FNAME' Set the name of the GDB command history file to FNAME. This is the file from which GDB will read an initial command history list or to which it will write this list when it exits. This list is accessed through history expansion or through the history command editing characters listed below. This file defaults to the value of the environment variable `GDBHISTFILE', or to `./.gdb_history' if this variable is not set. `set history save' `set history save on' Record command history in a file, whose name may be specified with the `set history filename' command. By default, this option is disabled. `set history save off' Stop recording command history in a file. `set history size SIZE' Set the number of commands which GDB will keep in its history list. This defaults to the value of the environment variable `HISTSIZE', or to 256 if this variable is not set. History expansion assigns special meaning to the character `!'. Since `!' is also the logical not operator in C, history expansion is off by default. If you decide to enable history expansion with the `set history expansion on' command, you may sometimes need to follow `!' (when it is used as logical not, in an expression) with a space or a tab to prevent it from being expanded. The readline history facilities will not attempt substitution on the strings `!=' and `!(', even when history expansion is enabled. The commands to control history expansion are: `set history expansion on' `set history expansion' Enable history expansion. History expansion is off by default. `set history expansion off' Disable history expansion. The readline code comes with more complete documentation of editing and history expansion features. Users unfamiliar with `emacs' or `vi' may wish to read it. `show history' `show history filename' `show history save' `show history size' `show history expansion' These commands display the state of the GDB history parameters. `show history' by itself displays all four states. `show commands' Display the last ten commands in the command history. `show commands N' Print ten commands centered on command number N. `show commands +' Print ten commands just after the commands last printed. File: gdb.info, Node: Screen Size, Next: Numbers, Prev: History, Up: Controlling GDB Screen size =========== Certain commands to GDB may produce large amounts of information output to the screen. To help you read all of it, GDB pauses and asks you for input at the end of each page of output. Type RET when you want to continue the output, or `q' to discard the remaining output. Also, the screen width setting determines when to wrap lines of output. Depending on what is being printed, GDB tries to break the line at a readable place, rather than simply letting it overflow onto the following line. Normally GDB knows the size of the screen from the termcap data base together with the value of the `TERM' environment variable and the `stty rows' and `stty cols' settings. If this is not correct, you can override it with the `set height' and `set width' commands: `set height LPP' `show height' `set width CPL' `show width' These `set' commands specify a screen height of LPP lines and a screen width of CPL characters. The associated `show' commands display the current settings. If you specify a height of zero lines, GDB will not pause during output no matter how long the output is. This is useful if output is to a file or to an editor buffer. File: gdb.info, Node: Numbers, Next: Messages/Warnings, Prev: Screen Size, Up: Controlling GDB Numbers ======= You can always enter numbers in octal, decimal, or hexadecimal in GDB by the usual conventions: octal numbers begin with `0', decimal numbers end with `.', and hexadecimal numbers begin with `0x'. Numbers that begin with none of these are, by default, entered in base 10; likewise, the default display for numbers--when no particular format is specified--is base 10. You can change the default base for both input and output with the `set radix' command. `set radix BASE' Set the default base for numeric input and display. Supported choices for BASE are decimal 2, 8, 10, 16. BASE must itself be specified either unambiguously or using the current default radix; for example, any of set radix 1010 set radix 012 set radix 10. set radix 0xa will set the base to decimal. On the other hand, `set radix 10' will leave the radix unchanged no matter what it was. `show radix' Display the current default base for numeric input and display. File: gdb.info, Node: Messages/Warnings, Prev: Numbers, Up: Controlling GDB Optional warnings and messages ============================== By default, GDB is silent about its inner workings. If you are running on a slow machine, you may want to use the `set verbose' command. It will make GDB tell you when it does a lengthy internal operation, so you will not think it has crashed. Currently, the messages controlled by `set verbose' are those which announce that the symbol table for a source file is being read; see `symbol-file' in *Note Commands to specify files: Files. `set verbose on' Enables GDB output of certain informational messages. `set verbose off' Disables GDB output of certain informational messages. `show verbose' Displays whether `set verbose' is on or off. By default, if GDB encounters bugs in the symbol table of an object file, it is silent; but if you are debugging a compiler, you may find this information useful (*note Errors reading symbol files: Symbol Errors.). `set complaints LIMIT' Permits GDB to output LIMIT complaints about each type of unusual symbols before becoming silent about the problem. Set LIMIT to zero to suppress all complaints; set it to a large number to prevent complaints from being suppressed. `show complaints' Displays how many symbol complaints GDB is permitted to produce. By default, GDB is cautious, and asks what sometimes seems to be a lot of stupid questions to confirm certain commands. For example, if you try to run a program which is already running: (gdb) run The program being debugged has been started already. Start it from the beginning? (y or n) If you are willing to unflinchingly face the consequences of your own commands, you can disable this "feature": `set confirm off' Disables confirmation requests. `set confirm on' Enables confirmation requests (the default). `show confirm' Displays state of confirmation requests. Some systems allow individual object files that make up your program to be replaced without stopping and restarting your program. For example, in VxWorks you can simply recompile a defective object file and keep on running. If you are running on one of these systems, you can allow GDB to reload the symbols for automatically relinked modules: `set symbol-reloading on' Replace symbol definitions for the corresponding source file when an object file with a particular name is seen again. `set symbol-reloading off' Do not replace symbol definitions when re-encountering object files of the same name. This is the default state; if you are not running on a system that permits automatically relinking modules, you should leave `symbol-reloading' off, since otherwise GDB may discard symbols when linking large programs, that may contain several modules (from different directories or libraries) with the same name. `show symbol-reloading' Show the current `on' or `off' setting. File: gdb.info, Node: Sequences, Next: Emacs, Prev: Controlling GDB, Up: Top Canned Sequences of Commands **************************** Aside from breakpoint commands (*note Breakpoint command lists: Break Commands.), GDB provides two ways to store sequences of commands for execution as a unit: user-defined commands and command files. * Menu: * Define:: User-defined commands * Hooks:: User-defined command hooks * Command Files:: Command files * Output:: Commands for controlled output File: gdb.info, Node: Define, Next: Hooks, Up: Sequences User-defined commands ===================== A "user-defined command" is a sequence of GDB commands to which you assign a new name as a command. This is done with the `define' command. `define COMMANDNAME' Define a command named COMMANDNAME. If there is already a command by that name, you are asked to confirm that you want to redefine it. The definition of the command is made up of other GDB command lines, which are given following the `define' command. The end of these commands is marked by a line containing `end'. `document COMMANDNAME' Give documentation to the user-defined command COMMANDNAME. The command COMMANDNAME must already be defined. This command reads lines of documentation just as `define' reads the lines of the command definition, ending with `end'. After the `document' command is finished, `help' on command COMMANDNAME will print the documentation you have specified. You may use the `document' command again to change the documentation of a command. Redefining the command with `define' does not change the documentation. `help user-defined' List all user-defined commands, with the first line of the documentation (if any) for each. `show user' `show user COMMANDNAME' Display the GDB commands used to define COMMANDNAME (but not its documentation). If no COMMANDNAME is given, display the definitions for all user-defined commands. User-defined commands do not take arguments. When they are executed, the commands of the definition are not printed. An error in any command stops execution of the user-defined command. Commands that would ask for confirmation if used interactively proceed without asking when used inside a user-defined command. Many GDB commands that normally print messages to say what they are doing omit the messages when used in a user-defined command. File: gdb.info, Node: Hooks, Next: Command Files, Prev: Define, Up: Sequences User-defined command hooks ========================== You may define *hooks*, which are a special kind of user-defined command. Whenever you run the command `foo', if the user-defined command `hook-foo' exists, it is executed (with no arguments) before that command. In addition, a pseudo-command, `stop' exists. Defining (`hook-stop') makes the associated commands execute every time execution stops in your program: before breakpoint commands are run, displays are printed, or the stack frame is printed. For example, to ignore `SIGALRM' signals while single-stepping, but treat them normally during normal execution, you could define: define hook-stop handle SIGALRM nopass end define hook-run handle SIGALRM pass end define hook-continue handle SIGLARM pass end You can define a hook for any single-word command in GDB, but not for command aliases; you should define a hook for the basic command name, e.g. `backtrace' rather than `bt'. If an error occurs during the execution of your hook, execution of GDB commands stops and GDB issues a prompt (before the command that you actually typed had a chance to run). If you try to define a hook which does not match any known command, you will get a warning from the `define' command. File: gdb.info, Node: Command Files, Next: Output, Prev: Hooks, Up: Sequences Command files ============= A command file for GDB is a file of lines that are GDB commands. Comments (lines starting with `#') may also be included. An empty line in a command file does nothing; it does not mean to repeat the last command, as it would from the terminal. When you start GDB, it automatically executes commands from its "init files". These are files named `.gdbinit'. GDB reads the init file (if any) in your home directory and then the init file (if any) in the current working directory. (The init files are not executed if you use the `-nx' option; *note Choosing modes: Mode Options..) On some configurations of GDB, the init file is known by a different name (these are typically environments where a specialized form of GDB may need to coexist with other forms, hence a different name for the specialized version's init file). These are the environments with special init file names: * VxWorks (Wind River Systems real-time OS): `.vxgdbinit' * OS68K (Enea Data Systems real-time OS): `.os68gdbinit' * ES-1800 (Ericsson Telecom AB M68000 emulator): `.esgdbinit' You can also request the execution of a command file with the `source' command: `source FILENAME' Execute the command file FILENAME. The lines in a command file are executed sequentially. They are not printed as they are executed. An error in any command terminates execution of the command file. Commands that would ask for confirmation if used interactively proceed without asking when used in a command file. Many GDB commands that normally print messages to say what they are doing omit the messages when called from command files. File: gdb.info, Node: Output, Prev: Command Files, Up: Sequences Commands for controlled output ============================== During the execution of a command file or a user-defined command, normal GDB output is suppressed; the only output that appears is what is explicitly printed by the commands in the definition. This section describes three commands useful for generating exactly the output you want. `echo TEXT' Print TEXT. Nonprinting characters can be included in TEXT using C escape sequences, such as `\n' to print a newline. *No newline will be printed unless you specify one.* In addition to the standard C escape sequences, a backslash followed by a space stands for a space. This is useful for displaying a string with spaces at the beginning or the end, since leading and trailing spaces are otherwise trimmed from all arguments. To print ` and foo = ', use the command `echo \ and foo = \ '. A backslash at the end of TEXT can be used, as in C, to continue the command onto subsequent lines. For example, echo This is some text\n\ which is continued\n\ onto several lines.\n produces the same output as echo This is some text\n echo which is continued\n echo onto several lines.\n `output EXPRESSION' Print the value of EXPRESSION and nothing but that value: no newlines, no `$NN = '. The value is not entered in the value history either. *Note Expressions: Expressions, for more information on expressions. `output/FMT EXPRESSION' Print the value of EXPRESSION in format FMT. You can use the same formats as for `print'. *Note Output formats: Output Formats, for more information. `printf STRING, EXPRESSIONS...' Print the values of the EXPRESSIONS under the control of STRING. The EXPRESSIONS are separated by commas and may be either numbers or pointers. Their values are printed as specified by STRING, exactly as if your program were to execute printf (STRING, EXPRESSIONS...); For example, you can print two values in hex like this: printf "foo, bar-foo = 0x%x, 0x%x\n", foo, bar-foo The only backslash-escape sequences that you can use in the format string are the simple ones that consist of backslash followed by a letter. File: gdb.info, Node: Emacs, Next: GDB Bugs, Prev: Sequences, Up: Top Using GDB under GNU Emacs ************************* A special interface allows you to use GNU Emacs to view (and edit) the source files for the program you are debugging with GDB. To use this interface, use the command `M-x gdb' in Emacs. Give the executable file you want to debug as an argument. This command starts GDB as a subprocess of Emacs, with input and output through a newly created Emacs buffer. Using GDB under Emacs is just like using GDB normally except for two things: * All "terminal" input and output goes through the Emacs buffer. This applies both to GDB commands and their output, and to the input and output done by the program you are debugging. This is useful because it means that you can copy the text of previous commands and input them again; you can even use parts of the output in this way. All the facilities of Emacs' Shell mode are available for interacting with your program. In particular, you can send signals the usual way--for example, `C-c C-c' for an interrupt, `C-c C-z' for a stop. * GDB displays source code through Emacs. Each time GDB displays a stack frame, Emacs automatically finds the source file for that frame and puts an arrow (`=>') at the left margin of the current line. Emacs uses a separate buffer for source display, and splits the screen to show both your GDB session and the source. Explicit GDB `list' or search commands still produce output as usual, but you probably will have no reason to use them. *Warning:* If the directory where your program resides is not your current directory, it can be easy to confuse Emacs about the location of the source files, in which case the auxiliary display buffer will not appear to show your source. GDB can find programs by searching your environment's `PATH' variable, so the GDB input and output session will proceed normally; but Emacs does not get enough information back from GDB to locate the source files in this situation. To avoid this problem, either start GDB mode from the directory where your program resides, or specify a full path name when prompted for the `M-x gdb' argument. A similar confusion can result if you use the GDB `file' command to switch to debugging a program in some other location, from an existing GDB buffer in Emacs. By default, `M-x gdb' calls the program called `gdb'. If you need to call GDB by a different name (for example, if you keep several configurations around, with different names) you can set the Emacs variable `gdb-command-name'; for example, (setq gdb-command-name "mygdb") (preceded by `ESC ESC', or typed in the `*scratch*' buffer, or in your `.emacs' file) will make Emacs call the program named "`mygdb'" instead. In the GDB I/O buffer, you can use these special Emacs commands in addition to the standard Shell mode commands: `C-h m' Describe the features of Emacs' GDB Mode. `M-s' Execute to another source line, like the GDB `step' command; also update the display window to show the current file and location. `M-n' Execute to next source line in this function, skipping all function calls, like the GDB `next' command. Then update the display window to show the current file and location. `M-i' Execute one instruction, like the GDB `stepi' command; update display window accordingly. `M-x gdb-nexti' Execute to next instruction, using the GDB `nexti' command; update display window accordingly. `C-c C-f' Execute until exit from the selected stack frame, like the GDB `finish' command. `M-c' Continue execution of your program, like the GDB `continue' command. *Warning:* In Emacs v19, this command is `C-c C-p'. `M-u' Go up the number of frames indicated by the numeric argument (*note Numeric Arguments: (emacs)Arguments.), like the GDB `up' command. *Warning:* In Emacs v19, this command is `C-c C-u'. `M-d' Go down the number of frames indicated by the numeric argument, like the GDB `down' command. *Warning:* In Emacs v19, this command is `C-c C-d'. `C-x &' Read the number where the cursor is positioned, and insert it at the end of the GDB I/O buffer. For example, if you wish to disassemble code around an address that was displayed earlier, type `disassemble'; then move the cursor to the address display, and pick up the argument for `disassemble' by typing `C-x &'. You can customize this further by defining elements of the list `gdb-print-command'; once it is defined, you can format or otherwise process numbers picked up by `C-x &' before they are inserted. A numeric argument to `C-x &' will both indicate that you wish special formatting, and act as an index to pick an element of the list. If the list element is a string, the number to be inserted is formatted using the Emacs function `format'; otherwise the number is passed as an argument to the corresponding list element. In any source file, the Emacs command `C-x SPC' (`gdb-break') tells GDB to set a breakpoint on the source line point is on. If you accidentally delete the source-display buffer, an easy way to get it back is to type the command `f' in the GDB buffer, to request a frame display; when you run under Emacs, this will recreate the source buffer if necessary to show you the context of the current frame. The source files displayed in Emacs are in ordinary Emacs buffers which are visiting the source files in the usual way. You can edit the files with these buffers if you wish; but keep in mind that GDB communicates with Emacs in terms of line numbers. If you add or delete lines from the text, the line numbers that GDB knows will cease to correspond properly with the code. File: gdb.info, Node: GDB Bugs, Next: Renamed Commands, Prev: Emacs, Up: Top Reporting Bugs in GDB ********************* Your bug reports play an essential role in making GDB reliable. Reporting a bug may help you by bringing a solution to your problem, or it may not. But in any case the principal function of a bug report is to help the entire community by making the next version of GDB work better. Bug reports are your contribution to the maintenance of GDB. In order for a bug report to serve its purpose, you must include the information that enables us to fix the bug. * Menu: * Bug Criteria:: Have you found a bug? * Bug Reporting:: How to report bugs File: gdb.info, Node: Bug Criteria, Next: Bug Reporting, Up: GDB Bugs Have you found a bug? ===================== If you are not sure whether you have found a bug, here are some guidelines: * If the debugger gets a fatal signal, for any input whatever, that is a GDB bug. Reliable debuggers never crash. * If GDB produces an error message for valid input, that is a bug. * If GDB does not produce an error message for invalid input, that is a bug. However, you should note that your idea of "invalid input" might be our idea of "an extension" or "support for traditional practice". * If you are an experienced user of debugging tools, your suggestions for improvement of GDB are welcome in any case. File: gdb.info, Node: Bug Reporting, Prev: Bug Criteria, Up: GDB Bugs How to report bugs ================== A number of companies and individuals offer support for GNU products. If you obtained GDB from a support organization, we recommend you contact that organization first. You can find contact information for many support companies and individuals in the file `etc/SERVICE' in the GNU Emacs distribution. In any event, we also recommend that you send bug reports for GDB to one of these addresses: bug-gdb@prep.ai.mit.edu {ucbvax|mit-eddie|uunet}!prep.ai.mit.edu!bug-gdb *Do not send bug reports to `info-gdb', or to `help-gdb', or to any newsgroups.* Most users of GDB do not want to receive bug reports. Those that do, have arranged to receive `bug-gdb'. The mailing list `bug-gdb' has a newsgroup `gnu.gdb.bug' which serves as a repeater. The mailing list and the newsgroup carry exactly the same messages. Often people think of posting bug reports to the newsgroup instead of mailing them. This appears to work, but it has one problem which can be crucial: a newsgroup posting often lacks a mail path back to the sender. Thus, if we need to ask for more information, we may be unable to reach you. For this reason, it is better to send bug reports to the mailing list. As a last resort, send bug reports on paper to: GNU Debugger Bugs Free Software Foundation 545 Tech Square Cambridge, MA 02139 The fundamental principle of reporting bugs usefully is this: *report all the facts*. If you are not sure whether to state a fact or leave it out, state it! Often people omit facts because they think they know what causes the problem and assume that some details do not matter. Thus, you might assume that the name of the variable you use in an example does not matter. Well, probably it does not, but one cannot be sure. Perhaps the bug is a stray memory reference which happens to fetch from the location where that name is stored in memory; perhaps, if the name were different, the contents of that location would fool the debugger into doing the right thing despite the bug. Play it safe and give a specific, complete example. That is the easiest thing for you to do, and the most helpful. Keep in mind that the purpose of a bug report is to enable us to fix the bug if it is new to us. It is not as important as what happens if the bug is already known. Therefore, always write your bug reports on the assumption that the bug has not been reported previously. Sometimes people give a few sketchy facts and ask, "Does this ring a bell?" Those bug reports are useless, and we urge everyone to *refuse to respond to them* except to chide the sender to report bugs properly. To enable us to fix the bug, you should include all these things: * The version of GDB. GDB announces it if you start with no arguments; you can also print it at any time using `show version'. Without this, we will not know whether there is any point in looking for the bug in the current version of GDB. * The type of machine you are using, and the operating system name and version number. * What compiler (and its version) was used to compile GDB--e.g. "gcc-2.0". * What compiler (and its version) was used to compile the program you are debugging--e.g. "gcc-2.0". * The command arguments you gave the compiler to compile your example and observe the bug. For example, did you use `-O'? To guarantee you will not omit something important, list them all. A copy of the Makefile (or the output from make) is sufficient. If we were to try to guess the arguments, we would probably guess wrong and then we might not encounter the bug. * A complete input script, and all necessary source files, that will reproduce the bug. * A description of what behavior you observe that you believe is incorrect. For example, "It gets a fatal signal." Of course, if the bug is that GDB gets a fatal signal, then we will certainly notice it. But if the bug is incorrect output, we might not notice unless it is glaringly wrong. We are human, after all. You might as well not give us a chance to make a mistake. Even if the problem you experience is a fatal signal, you should still say so explicitly. Suppose something strange is going on, such as, your copy of GDB is out of synch, or you have encountered a bug in the C library on your system. (This has happened!) Your copy might crash and ours would not. If you told us to expect a crash, then when ours fails to crash, we would know that the bug was not happening for us. If you had not told us to expect a crash, then we would not be able to draw any conclusion from our observations. * If you wish to suggest changes to the GDB source, send us context diffs. If you even discuss something in the GDB source, refer to it by context, not by line number. The line numbers in our development sources will not match those in your sources. Your line numbers would convey no useful information to us. Here are some things that are not necessary: * A description of the envelope of the bug. Often people who encounter a bug spend a lot of time investigating which changes to the input file will make the bug go away and which changes will not affect it. This is often time consuming and not very useful, because the way we will find the bug is by running a single example under the debugger with breakpoints, not by pure deduction from a series of examples. We recommend that you save your time for something else. Of course, if you can find a simpler example to report *instead* of the original one, that is a convenience for us. Errors in the output will be easier to spot, running under the debugger will take less time, etc. However, simplification is not vital; if you do not want to do this, report the bug anyway and send us the entire test case you used. * A patch for the bug. A patch for the bug does help us if it is a good one. But do not omit the necessary information, such as the test case, on the assumption that a patch is all we need. We might see problems with your patch and decide to fix the problem another way, or we might not understand it at all. Sometimes with a program as complicated as GDB it is very hard to construct an example that will make the program follow a certain path through the code. If you do not send us the example, we will not be able to construct one, so we will not be able to verify that the bug is fixed. And if we cannot understand what bug you are trying to fix, or why your patch should be an improvement, we will not install it. A test case will help us to understand. * A guess about what the bug is or what it depends on. Such guesses are usually wrong. Even we cannot guess right about such things without first using the debugger to find the facts. File: gdb.info, Node: Renamed Commands, Next: Formatting Documentation, Prev: GDB Bugs, Up: Top Renamed Commands **************** The following commands were renamed in GDB 4, in order to make the command set as a whole more consistent and easier to use and remember: OLD COMMAND NEW COMMAND --------------- ------------------------------- add-syms add-symbol-file delete environment unset environment info convenience show convenience info copying show copying info directories show directories info editing show commands info history show values info targets help target info values show values info version show version info warranty show warranty set/show addressprint set/show print address set/show array-max set/show print elements set/show arrayprint set/show print array set/show asm-demangle set/show print asm-demangle set/show caution set/show confirm set/show demangle set/show print demangle set/show history write set/show history save set/show prettyprint set/show print pretty set/show screen-height set/show height set/show screen-width set/show width set/show sevenbit-strings set/show print sevenbit-strings set/show unionprint set/show print union set/show vtblprint set/show print vtbl unset [No longer an alias for delete] File: gdb.info, Node: Formatting Documentation, Next: Installing GDB, Prev: Renamed Commands, Up: Top Formatting Documentation ************************ The GDB 4 release includes an already-formatted reference card, ready for printing with PostScript or GhostScript, in the `gdb' subdirectory of the main source directory(1). If you can use PostScript or GhostScript with your printer, you can print the reference card immediately with `refcard.ps'. The release also includes the source for the reference card. You can format it, using TeX, by typing: make refcard.dvi The GDB reference card is designed to print in landscape mode on US "letter" size paper; that is, on a sheet 11 inches wide by 8.5 inches high. You will need to specify this form of printing as an option to your DVI output program. All the documentation for GDB comes as part of the machine-readable distribution. The documentation is written in Texinfo format, which is a documentation system that uses a single source file to produce both on-line information and a printed manual. You can use one of the Info formatting commands to create the on-line version of the documentation and TeX (or `texi2roff') to typeset the printed version. GDB includes an already formatted copy of the on-line Info version of this manual in the `gdb' subdirectory. The main Info file is `gdb-VERSION-NUMBER/gdb/gdb.info', and it refers to subordinate files matching `gdb.info*' in the same directory. If necessary, you can print out these files, or read them with any editor; but they are easier to read using the `info' subsystem in GNU Emacs or the standalone `info' program, available as part of the GNU Texinfo distribution. If you want to format these Info files yourself, you need one of the Info formatting programs, such as `texinfo-format-buffer' or `makeinfo'. If you have `makeinfo' installed, and are in the top level GDB source directory (`gdb-4.9', in the case of version 4.9), you can make the Info file by typing: cd gdb make gdb.info If you want to typeset and print copies of this manual, you need TeX, a program to print its DVI output files, and `texinfo.tex', the Texinfo definitions file. TeX is a typesetting program; it does not print files directly, but produces output files called DVI files. To print a typeset document, you need a program to print DVI files. If your system has TeX installed, chances are it has such a program. The precise command to use depends on your system; `lpr -d' is common; another (for PostScript devices) is `dvips'. The DVI print command may require a file name without any extension or a `.dvi' extension. TeX also requires a macro definitions file called `texinfo.tex'. This file tells TeX how to typeset a document written in Texinfo format. On its own, TeX cannot read, much less typeset a Texinfo file. `texinfo.tex' is distributed with GDB and is located in the `gdb-VERSION-NUMBER/texinfo' directory. If you have TeX and a DVI printer program installed, you can typeset and print this manual. First switch to the the `gdb' subdirectory of the main source directory (for example, to `gdb-4.9/gdb') and then type: make gdb.dvi ---------- Footnotes ---------- (1) In `gdb-4.9/gdb/refcard.ps' of the version 4.9 release.