15.1 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 No value for GDBN's start-up commands (see section Getting In and Out of No value for GDBN).

Occasionally it is necessary to change to a different file during a No value for GDBN session. Or you may run No value for GDBN and forget to specify a file you want to use. Or you are debugging a remote target via gdbserver (see section Using the gdbserver Program). In these situations the No value for GDBN 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 No value for GDBN working directory, No value for GDBN 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 No value for GDBN and your program, using the path command.

You can load unlinked object ‘.o’ files into No value for GDBN using the file command. You will not be able to “run” an object file, but you can disassemble functions and inspect variables. Also, if the underlying BFD functionality supports it, you could use gdb -write to patch object files using this technique. Note that No value for GDBN can neither interpret nor modify relocations in this case, so branches and some initialized variables will appear to go to the wrong place. But this feature is still handy from time to time.

file

file with no argument makes No value for GDBN 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. No value for GDBN 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 No value for GDBN information on your program's symbol table.

The symbol-file command causes No value for GDBN to forget the contents of some 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 No value for GDBN.

symbol-file does not repeat if you press <RET> again after executing it once.

When No value for GDBN 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 No value for NGCC 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 No value for GDBN 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 ]

file filename [ -readnow ]

You can override the No value for GDBN 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 No value for GDBN has the entire symbol table available.

core-file [filename]

core

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; No value for GDBN 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 No value for GDBN. 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 ]

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; No value for GDBN 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.

Although filename is typically a shared library file, an executable file, or some other object file which has been fully relocated for loading into a process, you can also load symbolic information from relocatable ‘.o’ files, as long as:

• the file's symbolic information refers only to linker symbols defined in that file, not to symbols defined by other object files,
• every section the file's symbolic information refers to has actually been loaded into the inferior, as it appears in the file, and
• you can determine the address at which every section was loaded, and provide these to the add-symbol-file command.

Some embedded operating systems, like Sun Chorus and VxWorks, can load relocatable files into an already running program; such systems typically make the requirements above easy to meet. However, it's important to recognize that many native systems use complex link procedures (.linkonce section factoring and C++ constructor table assembly, for example) that make the requirements difficult to meet. In general, one cannot assume that using add-symbol-file to read a relocatable object file's symbolic information will have the same effect as linking the relocatable object file into the program in the normal way.

add-symbol-file does not repeat if you press <RET> after using it.

add-symbol-file-from-memory address

Load symbols from the given address in a dynamically loaded object file whose image is mapped directly into the inferior's memory. For example, the Linux kernel maps a syscall DSO into each process's address space; this DSO provides kernel-specific code for some system calls. The argument can be any expression whose evaluation yields the address of the file's shared object file header. For this command to work, you must have used symbol-file or exec-file commands in advance.

add-shared-symbol-files library-file

assf library-file

The add-shared-symbol-files command can currently be used only in the Cygwin build of No value for GDBN on MS-Windows OS, where it is an alias for the dll-symbols command (see section Features for Debugging MS Windows PE Executables). No value for GDBN automatically looks for shared libraries, however if No value for GDBN does not find yours, you can invoke add-shared-symbol-files. It takes one argument: the shared library's file name. assf is a shorthand alias for add-shared-symbol-files.

section section addr

The section command changes the base address of the named 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 No value for GDBN, and the files from which symbols were loaded. The command help target lists all possible targets rather than current ones.

maint info sections

Another command that can give you extra information about program sections is maint info sections. In addition to the section information displayed by info files, this command displays the flags and file offset of each section in the executable and core dump files. In addition, maint info sections provides the following command options (which may be arbitrarily combined):

ALLOBJ

Display sections for all loaded object files, including shared libraries.

sections

Display info only for named sections.

section-flags

Display info only for sections for which section-flags are true. The section flags that No value for GDBN currently knows about are:

ALLOC

Section will have space allocated in the process when loaded. Set for all sections except those containing debug information.

LOAD

Section will be loaded from the file into the child process memory. Set for pre-initialized code and data, clear for .bss sections.

RELOC

Section needs to be relocated before loading.

READONLY

Section cannot be modified by the child process.

CODE

Section contains executable code only.

DATA

Section contains data only (no executable code).

ROM

Section will reside in ROM.

CONSTRUCTOR

Section contains data for constructor/destructor lists.

HAS_CONTENTS

Section is not empty.

NEVER_LOAD

An instruction to the linker to not output the section.

COFF_SHARED_LIBRARY

A notification to the linker that the section contains COFF shared library information.

IS_COMMON

Section contains common symbols.

set trust-readonly-sections on

Tell No value for GDBN that readonly sections in your object file really are read-only (i.e. that their contents will not change). In that case, No value for GDBN can fetch values from these sections out of the object file, rather than from the target program. For some targets (notably embedded ones), this can be a significant enhancement to debugging performance.

The default is off.

set trust-readonly-sections off

Tell No value for GDBN not to trust readonly sections. This means that the contents of the section might change while the program is running, and must therefore be fetched from the target when needed.

show trust-readonly-sections

Show the current setting of trusting readonly sections.

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

No value for GDBN supports GNU/Linux, MS-Windows, HP-UX, SunOS, SVr4, Irix, and IBM RS/6000 AIX shared libraries.

No value for GDBN 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, No value for GDBN 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, No value for GDBN automatically loads the symbols at the time of the shl_load call.

There are times, however, when you may wish to not automatically load symbol definitions from shared libraries, such as when they are particularly large or there are many of them.

To control the automatic loading of shared library symbols, use the commands:

set auto-solib-add mode

If mode is on, symbols from all shared object libraries will be loaded automatically when the inferior begins execution, you attach to an independently started inferior, or when the dynamic linker informs No value for GDBN that a new library has been loaded. If mode is off, symbols must be loaded manually, using the sharedlibrary command. The default value is on.

If your program uses lots of shared libraries with debug info that takes large amounts of memory, you can decrease the No value for GDBN memory footprint by preventing it from automatically loading the symbols from shared libraries. To that end, type set auto-solib-add off before running the inferior, then load each library whose debug symbols you do need with sharedlibrary regexp, where regexp is a regular expression that matches the libraries whose symbols you want to be loaded.

show auto-solib-add

Display the current autoloading mode.

To explicitly load shared library symbols, use the sharedlibrary command:

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.

nosharedlibrary

Unload all shared object library symbols. This discards all symbols that have been loaded from all shared libraries. Symbols from shared libraries that were loaded by explicit user requests are not discarded.

Sometimes you may wish that No value for GDBN stops and gives you control when any of shared library events happen. Use the set stop-on-solib-events command for this:

set stop-on-solib-events

This command controls whether No value for GDBN should give you control when the dynamic linker notifies it about some shared library event. The most common event of interest is loading or unloading of a new shared library.

show stop-on-solib-events

Show whether No value for GDBN stops and gives you control when shared library events happen.

Shared libraries are also supported in many cross or remote debugging configurations. A copy of the target's libraries need to be present on the host system; they need to be the same as the target libraries, although the copies on the target can be stripped as long as the copies on the host are not.

For remote debugging, you need to tell No value for GDBN where the target libraries are, so that it can load the correct copies—otherwise, it may try to load the host's libraries. No value for GDBN has two variables to specify the search directories for target libraries.

set sysroot path

Use path as the system root for the program being debugged. Any absolute shared library paths will be prefixed with path; many runtime loaders store the absolute paths to the shared library in the target program's memory. If you use set sysroot to find shared libraries, they need to be laid out in the same way that they are on the target, with e.g. a ‘/lib’ and ‘/usr/lib’ hierarchy under path.

The set solib-absolute-prefix command is an alias for set sysroot.

You can set the default system root by using the configure-time ‘--with-sysroot’ option. If the system root is inside No value for GDBN's configured binary prefix (set with ‘--prefix’ or ‘--exec-prefix’), then the default system root will be updated automatically if the installed No value for GDBN is moved to a new location.

show sysroot

Display the current shared library prefix.

set solib-search-path path

If this variable is set, path is a colon-separated list of directories to search for shared libraries. ‘solib-search-path’ is used after ‘sysroot’ fails to locate the library, or if the path to the library is relative instead of absolute. If you want to use ‘solib-search-path’ instead of ‘sysroot’, be sure to set ‘sysroot’ to a nonexistent directory to prevent No value for GDBN from finding your host's libraries. ‘sysroot’ is preferred; setting it to a nonexistent directory may interfere with automatic loading of shared library symbols.

show solib-search-path

Display the current shared library search path.