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.)
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.
6.59 Other Built-in Functions Provided by GCC
The implementation details of a C statement like printf("a") are not considered a visible side effect by default, so they aren't something that get preserved. You can still set a breakpoint at the call site and step into the function (at least in assembly, 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
optimizeattribute 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 assembly. 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 assembly 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 generation, only on the metadata emitted. GCC uses other options (mostly -O, -f*, and -m*) to control code generation, 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.
-Os. Then we can use gcc -Os -Q --help=optimizers | grep enabled to determine what optimizations that are enabled by -Os and explicitly disable each one of them using the corresponding flag. (I'm not sure if there is a flag dedicated to optimizing divisions). -fno-builtin has to also be used (or even -ffreestanding). I don't know whether this will disable all optimizations, but I don't agree with that answer you linked.
x = y + 1 + 2 +3 into x = y + 6 with any options, if y is an integer type. The general point about GCC transforming through an internal representation is good.
-fno-builtinwork? Of course, that will probably effect a lot more thanprintf()optimizations.-fno-builtin-printfif you want to disable only that one. Documented in the C dialect options.-O0will even optimizex / 10to a multiplicative inverse. See Disable all optimization options in GCC. It still stores everything to memory between C statements (for consistent debugging; that's what-O0really means); gcc doesn't have a "fully dumb" mode that tries to transliterate C to asm as naively as possible. Usetccfor that, or most other compilers with-O0.