Go to the first, previous, next, last section, table of contents.


Commands to specify files

You may want to specify executable and core dump file names. The usual way to do this is at start-up time, using the arguments to 's start-up commands (see section Getting In and Out of).

Occasionally it is necessary to change to a different file during a session. Or you may run and forget to specify a file you want to use. In these situations the commands to specify new files are useful.

file filename
Use filename as the program to be debugged. It is read for its symbols and for the contents of pure memory. It is also the program executed when you use the run command. If you do not specify a directory and the file is not found in the working directory, uses the environment variable PATH as a list of directories to search, just as the shell does when looking for a program to run. You can change the value of this variable, for both and your program, using the path command. On systems with memory-mapped files, an auxiliary file named `filename.syms' may hold symbol table information for filename. If so, maps in the symbol table from `filename.syms', starting up more quickly. See the descriptions of the file options `-mapped' and `-readnow' (available on the command line, and with the commands file, symbol-file, or add-symbol-file, described below), for more information.
file
file with no argument makes discard any information it has on both executable file and the symbol table.
exec-file [ filename ]
Specify that the program to be run (but not the symbol table) is found in filename. searches the environment variable PATH if necessary to locate your program. Omitting filename means to discard information on the executable file.
symbol-file [ filename ]
Read symbol table information from file filename. PATH is searched when necessary. Use the file command to get both symbol table and program to run from the same file. symbol-file with no argument clears out information on your program's symbol table. The symbol-file command causes to forget the contents of its convenience variables, the value history, and all breakpoints and auto-display expressions. This is because they may contain pointers to the internal data recording symbols and data types, which are part of the old symbol table data being discarded inside . symbol-file does not repeat if you press RET again after executing it once. When is configured for a particular environment, it understands debugging information in whatever format is the standard generated for that environment; you may use either a GNU compiler, or other compilers that adhere to the local conventions. Best results are usually obtained from GNU compilers; for example, using you can generate debugging information for optimized code. For most kinds of object files, with the exception of old SVR3 systems using COFF, the symbol-file command does not normally read the symbol table in full right away. Instead, it scans the symbol table quickly to find which source files and which symbols are present. The details are read later, one source file at a time, as they are needed. The purpose of this two-stage reading strategy is to make start up faster. For the most part, it is invisible except for occasional pauses while the symbol table details for a particular source file are being read. (The set verbose command can turn these pauses into messages if desired. See section Optional warnings and messages.) We have not implemented the two-stage strategy for COFF yet. When the symbol table is stored in COFF format, symbol-file reads the symbol table data in full right away. Note that "stabs-in-COFF" still does the two-stage strategy, since the debug info is actually in stabs format.
symbol-file filename [ -readnow ] [ -mapped ]
file filename [ -readnow ] [ -mapped ]
You can override the two-stage strategy for reading symbol tables by using the `-readnow' option with any of the commands that load symbol table information, if you want to be sure has the entire symbol table available. If memory-mapped files are available on your system through the mmap system call, you can use another option, `-mapped', to cause to write the symbols for your program into a reusable file. Future debugging sessions map in symbol information from this auxiliary symbol file (if the program has not changed), rather than spending time reading the symbol table from the executable program. Using the `-mapped' option has the same effect as starting with the `-mapped' command-line option. You can use both options together, to make sure the auxiliary symbol file has all the symbol information for your program. The auxiliary symbol file for a program called myprog is called `myprog.syms'. Once this file exists (so long as it is newer than the corresponding executable), always attempts to use it when you debug myprog; no special options or commands are needed. The `.syms' file is specific to the host machine where you run . It holds an exact image of the internal symbol table. It cannot be shared across multiple host platforms.
core-file [ filename ]
Specify the whereabouts of a core dump file to be used as the "contents of memory". Traditionally, core files contain only some parts of the address space of the process that generated them; can access the executable file itself for other parts. core-file with no argument specifies that no core file is to be used. Note that the core file is ignored when your program is actually running under . So, if you have been running your program and you wish to debug a core file instead, you must kill the subprocess in which the program is running. To do this, use the kill command (see section Killing the child process).
add-symbol-file filename address
add-symbol-file filename address [ -readnow ] [ -mapped ]
add-symbol-file filename -ssection address
The add-symbol-file command reads additional symbol table information from the file filename. You would use this command when filename has been dynamically loaded (by some other means) into the program that is running. address should be the memory address at which the file has been loaded; cannot figure this out for itself. You can additionally specify an arbitrary number of `-ssection address' pairs, to give an explicit section name and base address for that section. You can specify any address as an expression. The symbol table of the file filename is added to the symbol table originally read with the symbol-file command. You can use the add-symbol-file command any number of times; the new symbol data thus read keeps adding to the old. To discard all old symbol data instead, use the symbol-file command without any arguments. add-symbol-file does not repeat if you press RET after using it. You can use the `-mapped' and `-readnow' options just as with the symbol-file command, to change how manages the symbol table information for filename.
add-shared-symbol-file
The add-shared-symbol-file command can be used only under Harris' CXUX operating system for the Motorola 88k. automatically looks for shared libraries, however if does not find yours, you can run add-shared-symbol-file. It takes no arguments.
section
The section command changes the base address of section SECTION of the exec file to ADDR. This can be used if the exec file does not contain section addresses, (such as in the a.out format), or when the addresses specified in the file itself are wrong. Each section must be changed separately. The info files command, described below, lists all the sections and their addresses.
info files
info target
info files and info target are synonymous; both print the current target (see section Specifying a Debugging Target), including the names of the executable and core dump files currently in use by , and the files from which symbols were loaded. The command help target lists all possible targets rather than current ones.

All file-specifying commands allow both absolute and relative file names as arguments. always converts the file name to an absolute file name and remembers it that way.

supports HP-UX, SunOS, SVr4, Irix 5, and IBM RS/6000 shared libraries.

automatically loads symbol definitions from shared libraries when you use the run command, or when you examine a core file. (Before you issue the run command, does not understand references to a function in a shared library, however--unless you are debugging a core file).

On HP-UX, if the program loads a library explicitly, automatically loads the symbols at the time of the shl_load call.

info share
info sharedlibrary
Print the names of the shared libraries which are currently loaded.
sharedlibrary regex
share regex
Load shared object library symbols for files matching a Unix regular expression. As with files loaded automatically, it only loads shared libraries required by your program for a core file or after typing run. If regex is omitted all shared libraries required by your program are loaded.

On HP-UX systems, detects the loading of a shared library and automatically reads in symbols from the newly loaded library, up to a threshold that is initially set but that you can modify if you wish.

Beyond that threshold, symbols from shared libraries must be explicitly loaded. To load these symbols, use the command sharedlibrary filename. The base address of the shared library is determined automatically by and need not be specified.

To display or set the threshold, use the commands:

set auto-solib-add threshold
Set the autoloading size threshold, in megabytes. If threshold is nonzero, symbols from all shared object libraries will be loaded automatically when the inferior begins execution or when the dynamic linker informs that a new library has been loaded, until the symbol table of the program and libraries exceeds this threshold. Otherwise, symbols must be loaded manually, using the sharedlibrary command. The default threshold is 100 megabytes.
show auto-solib-add
Display the current autoloading size threshold, in megabytes.


Go to the first, previous, next, last section, table of contents.