Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




Chapter 6. Running Programs Under gdb

When you run a program under gdb, you must first generate debugging information when you compile it.

You may start gdb with its arguments, if any, in an environment of your choice. If you are doing native debugging, you may redirect your program's input and output, debug an already running process, or kill a child process.

6.1. Compiling for debugging

In order to debug a program effectively, you need to generate debugging information when you compile it. This debugging information is stored in the object file; it describes the data type of each variable or function and the correspondence between source line numbers and addresses in the executable code.

To request debugging information, specify the -g option when you run the compiler.

Most compilers do not include information about preprocessor macros in the debugging information if you specify the -g flag alone, because this information is rather large. Version 3.1 of gcc, the gnu C compiler, provides macro information if you specify the options -gdwarf-2 and -g3; the former option requests debugging information in the Dwarf 2 format, and the latter requests "extra information". In the future, we hope to find more compact ways to represent macro information, so that it can be included with -g alone.

Many C compilers are unable to handle the -g and -O options together. Using those compilers, you cannot generate optimized executables containing debugging information.

gcc, the gnu C compiler, supports -g with or without -O, making it possible to debug optimized code. We recommend that you always use -g whenever you compile a program. You may think your program is correct, but there is no sense in pushing your luck.

When you debug a program compiled with -g -O, remember that the optimizer is rearranging your code; the debugger shows you what is really there. Do not be too surprised when the execution path does not exactly match your source file! An extreme example: if you define a variable, but never use it, gdb never sees that variable--because the compiler optimizes it out of existence.

Some things do not work as well with -g -O as with just -g, particularly on machines with instruction scheduling. If in doubt, recompile with -g alone, and if this fixes the problem, please report it to us as a bug (including a test case!).

Older versions of the gnu C compiler permitted a variant option -gg for debugging information. gdb no longer supports this format; if your gnu C compiler has this option, do not use it.

  Published under the terms of the GNU General Public License Design by Interspire