Are there any downsides to compiling with -g flag?

Question

GDB documentation tells me that in order to compile for debugging, I need to ask my compiler to generate debugging symbols. This is done by specifying a '-g' flag.

Furthermore, GDB doc recommends I'd always compile with a '-g' flag. This sounds good, and I'd like to do that.

But first, I'd like to find out about downsides. Are there any penalties involved with compiling-for-debugging in production code?

I am mostly interested in:

1. GCC as the compiler of choice
2. Red hat Linux as target OS
3. C and C++ languages

(Although information about other environments is welcome as well)

Many thanks!

Answer 1

If you use -g (which on recent GCC or Clang can be used with optimization flags like -O2):

• compilation time is slower (and linking will use a lot more memory)
• the executable is a bigger file (see elf(5) and use readelf(1)...)
• the executable carries a lot of information about your source code.
• you can use GDB easily
• some interesting libraries, like Ian Taylor's libbacktrace, requires DWARF information (e.g. -g)

If you don't use -g it would be harder to use the GDB debugger (but possible).

So if you transmit the binary executable to a partner that should not understand how your source code was written, you need to avoid -g

See also the strip(1) and strace(1) commands.

Notice that using the -g flag for debugging information is also valid for Ocaml, Rust

PS. Recent GCC (e.g. GCC 10 or GCC 11 in 2021) accept many debugger flags. With -g3 your executable carries more debug information (e.g. description of C++ macros and their expansion) that with -g or -g1. Of course, compilation time increases, and executable size also. In principle, your GCC plugin (perhaps Bismon in 2021, or those inside the source code of the Linux kernel) could add even more debug information. In practice, you won't do that unless you can improve your debugger. However, a GCC plugin (or some #pragmas) can remove some debug information (e.g. remove debug information for a selected set of functions).

Answer 2

Generally, adding debug information increases the size of the binary files (or creates extra files for the debug information). That's nowadays usually not a problem, unless you're distributing it over slow networks. And of course this debug information may help others in analyzing your code, if they want to do that. Typically, the -g flag is used together with -O0 (the default), which disables compiler optimization and generates code that is as close as possible to the source, so that debugging is easier. While you can use debug information together with optimizations enabled, this is really tricky, because variables may not exist, or the sequence of instructions may be different than in the source. This is generally only done if an error needs to be analyzed that only happens after the optimizations are enabled. Of course, the downside of -O0 is poorer performance.

So as a conclusion: Typically one uses -g -O0 during development, and for distribution or production code just -O3.