9

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.)

Peter Mortensen
  • 30,738
  • 21
  • 105
  • 131
Yuri Albuquerque
  • 474
  • 3
  • 14
  • 1
    Are you saying `-O0` is still optimizing? – Eugene Sh. Jul 16 '19 at 17:17
  • 1
    I'm saying that even passing this flag, the function is optimized – Yuri Albuquerque Jul 16 '19 at 17:18
  • 1
    Does it happen if you enable debugging symbols with `-g`? – Barmar Jul 16 '19 at 17:18
  • 2
    Looks like it is the case.. https://godbolt.org/z/NT0Cr1 Well, I would first ask - why do you need this? – Eugene Sh. Jul 16 '19 at 17:20
  • 1
    I just tried with `-g`, the answer to my question is yes, it still optimizes. – Barmar Jul 16 '19 at 17:21
  • 5
    Does `-fno-builtin` work? Of course, that will probably effect a lot more than `printf()` optimizations. – Andrew Henle Jul 16 '19 at 17:22
  • 3
    @AndrewHenle This works https://godbolt.org/z/FdXIGH – Eugene Sh. Jul 16 '19 at 17:23
  • 5
    `-fno-builtin-printf` if you want to disable only that one. Documented in the C dialect options. – Marc Glisse Jul 16 '19 at 17:25
  • 2
    @EugeneSh.: Yes, `-O0` will even optimize `x / 10` to a multiplicative inverse. See [Disable all optimization options in GCC](//stackoverflow.com/a/33284629). 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, or most other compilers with `-O0`. – Peter Cordes Jul 16 '19 at 17:27
  • 1
    @PeterCordes Yeah, my comment was about this specific optimization, I just saved few words making it a bit too general... – Eugene Sh. Jul 16 '19 at 17:28
  • 1
    @Barmar: `-g` never has any effect on code-gen for gcc, just how much debug info is emitted as metadata. – Peter Cordes Jul 16 '19 at 17:28
  • 1
    @PeterCordes I was hoping that it would impact optimization so you can find the function call when debugging, at least with low optimization levels. – Barmar Jul 16 '19 at 17:30
  • 1
    @EugeneSh.: Yeah, I was a bit surprised that gcc looked for printf->putchar at `-O0` (in fact I didn't know it did that at all). But I wasn't at all shocked; I did remember that it does the normal printf->puts optimization even at `-O0`. – Peter Cordes Jul 16 '19 at 17:30
  • 1
    There are many really simple optimizations that are almost like macro expansions. – Barmar Jul 16 '19 at 17:31
  • 2
    @Barmar: `-O0` makes sure function calls aren't optimized away. You can still set a breakpoint on the callsite and step into the call to see where it goes. And like Andrew and Marc commented, if you want to treat standard functions as not just part of the implementation, there's `-fno-builtin` or `-fno-builtin-funcname`. – Peter Cordes Jul 16 '19 at 17:31

1 Answers1

9

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 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 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.

Peter Mortensen
  • 30,738
  • 21
  • 105
  • 131
Peter Cordes
  • 328,167
  • 45
  • 605
  • 847
  • 1
    "You can't disable all optimizations." This may not be correct. That division to multiplicative inverse optimization appears to be disabled in `-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. – Hadi Brais Jul 16 '19 at 19:13
  • 1
    @HadiBrais: I think GCC is always going to at least combine `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. – Peter Cordes Jul 16 '19 at 19:19
  • Maybe. But the point I'm making is that it doesn't have to do that transformation to emit native code. I'm not very familiar with gcc's source code, but we have to look at the code and see what all flags and macros being used to enable/disable every single optimization/compilation pass. Hopefully a gcc developer will see this post and tell us for sure. – Hadi Brais Jul 16 '19 at 19:23
  • @HadiBrais: you could ping \@MarcGlisse in the comments on the question, he's a GCC dev. – Peter Cordes Jul 16 '19 at 19:29