Compiler changes printf to puts

by

Am I correct in assuming that compiler ‘introspected my string’, or there is another explanation of this?

Yes, this is exactly what happens. It’s a pretty simple and common optimization done by the compiler.

Since your first printf() call is just:

printf("Hello world\n");

It’s equivalent to:

puts("Hello world");

Since puts() does not need to scan and parse the string for format specifiers, it’s quite faster than printf(). The compiler notices that your string ends with a newline and does not contain format specifiers, and therefore automatically converts the call.

This also saves a bit of space, since now only one string "Hello world" needs to be stored in the resulting binary.

Note that this is not possible in general for calls of the form:

printf(some_var);

If some_var is not a simple constant string, the compiler cannot know if it ends in \n.

Other common optimizations are:

  • strlen("constant string") might get evaluated at compile time and converted into a number.
  • memmove(location1, location2, sz) might get transformed into memcpy() if the compiler is sure that location1 and location2 don’t overlap.
  • memcpy() of small sizes can be converted in a single mov instruction, and even if the size is larger the call can sometimes be inlined to be faster.

Another interesting thing is that in bar, compiler zero’ed out the return register (eax) even though it is a void function. Why did it do that there and not in foo?

See here: Why is %eax zeroed before a call to printf?

Related interesting posts

More Related Contents:

  1. Why is gcc allowed to speculatively load from a struct?
  2. Assembly code fsqrt and fmul instructions
  3. How to remove “noise” from GCC/clang assembly output?
  4. Why does clang produce inefficient asm with -O0 (for this simple floating point sum)?
  5. Why does GCC use multiplication by a strange number in implementing integer division?
  6. How can I indicate that the memory *pointed* to by an inline ASM argument may be used?
  7. Can I use Intel syntax of x86 assembly with GCC?
  8. Disable all optimization options in GCC
  9. Why does GCC allocate more space than necessary on the stack, beyond what’s needed for alignment?
  10. Stack allocation, padding, and alignment
  11. Adding leading underscores to assembly symbols with GCC on Win32?
  12. C optimisation of string literals
  13. Is it possible to tell the branch predictor how likely it is to follow the branch?
  14. How does GCC implement variable-length arrays?
  15. What does it mean to align the stack?
  16. Syscall implementation of exit()
  17. Looping over arrays with inline assembly
  18. Why does GCC pad functions with NOPs?
  19. How to access C variable for inline assembly manipulation?
  20. How to turn off gcc compiler optimization to enable buffer overflow
  21. How can I multiply 64 bit operands and get 128 bit result portably?
  22. multi-word addition using the carry flag
  23. Why does gcc use movl instead of push to pass function args?
  24. execute binary machine code from C
  25. Why we need Clobbered registers list in Inline Assembly?
  26. How to tell GCC to generate 16-bit code for real mode
  27. Produce loops without cmp instruction in GCC
  28. How to get the size of a C function from inside a C program or with inline assembly?
  29. Using condition flags as GNU C inline asm outputs
  30. How do I compile the asm generated by GCC?

Leave a Comment