[SOLVED] How can I get the GCC compiler to not optimize a standard library function call like 'printf'?

Issue

Is there a way that GCC does not optimize any function calls?

In the generated assembly code, the printf function is replaced by putchar. This happens even with the default -O0 minimal optimization flag.

#include <stdio.h>

int main(void) {
    printf("a");
    return 0;
}

(Godbolt is showing GCC 9 doing it, and Clang 8 keeping it unchanged.)

Solution

Use -fno-builtin to disable all replacement and inlining of standard C functions with equivalents. (This is very bad for performance in code that assumes memcpy(x,y, 4) will compile to just an unaligned/aliasing-safe load, not a function call. And disables constant-propagation such as strlen of string literals. So normally you'd want to avoid that for practical use.)

Or use -fno-builtin-FUNCNAME for a specific function, like -fno-builtin-printf.

By default, some commonly-used standard C functions are handled as builtin functions, similar to __builtin_popcount. The handler for printf replaces it with putchar or puts if possible. https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html

The implementation details of a C statement like printf("a") are not considered a visible side-effect by default, so aren't something that gets preserved. You can still set a breakpoint at the call-site and step into the function (at least in asm, or in source mode if you have debug symbols installed).

---

To disable other kinds of optimizations for a single function, see __attribute__((optimize(0))) on a function or #pragma GCC optimize. But beware:

The optimize attribute should be used for debugging purposes only. It is not suitable in production code.

---

You can't disable all optimizations. Some optimization is inherent in the way gcc transforms through an internal representation on the way to asm. See Disable all optimization options in GCC.

e.g. even at -O0 gcc will optimize x / 10 to a multiplicative inverse.

It still stores everything to memory between C statements (for consistent debugging; that's what -O0 really means); gcc doesn't have a "fully dumb" mode that tries to transliterate C to asm as naively as possible. Use tcc for that. Clang and ICC with -O0 are somewhat more literal than gcc, and so is MSVC debug mode.

Note that -g never has any effect on code-gen, only on the metadata emitted. GCC uses other options (mostly -O, -f*, and -m*) to control code-gen, so you can always safely enable -g without hurting performance, other than a larger binary. It's not debug mode (that's -O0), it's just debug symbols.

Answered By - Peter Cordes

Answer Checked By - Willingham (WPSolving Volunteer)