How do I check if gcc is performing tail-recursion optimization?

by

Let’s use the example code from the other question. Compile it, but tell gcc not to assemble:

gcc -std=c99 -S -O2 test.c

Now let’s look at the _atoi function in the resultant test.s file (gcc 4.0.1 on Mac OS 10.5):

        .text
        .align 4,0x90
_atoi:
        pushl   %ebp
        testl   %eax, %eax
        movl    %esp, %ebp
        movl    %eax, %ecx
        je      L3
        .align 4,0x90
L5:
        movzbl  (%ecx), %eax
        testb   %al, %al
        je      L3
        leal    (%edx,%edx,4), %edx
        movsbl  %al,%eax
        incl    %ecx
        leal    -48(%eax,%edx,2), %edx
        jne     L5
        .align 4,0x90
L3:
        leave
        movl    %edx, %eax
        ret

The compiler has performed tail-call optimization on this function. We can tell because there is no call instruction in that code whereas the original C code clearly had a function call. Furthermore, we can see the jne L5 instruction, which jumps backward in the function, indicating a loop when there was clearly no loop in the C code. If you recompile with optimization turned off, you’ll see a line that says call _atoi, and you also won’t see any backward jumps.

Whether you can automate this is another matter. The specifics of the assembler code will depend on the code you’re compiling.

You could discover it programmatically, I think. Make the function print out the current value of the stack pointer (register ESP on x86). If the function prints the same value for the first call as it does for the recursive call, then the compiler has performed the tail-call optimization. This idea requires modifying the function you hope to observe, though, and that might affect how the compiler chooses to optimize the function. If the test succeeds (prints the same ESP value both times), then I think it’s reasonable to assume that the optimization would also be performed without your instrumentation, but if the test fails, we won’t know whether the failure was due to the addition of the instrumentation code.

More Related Contents:

  1. GCC dump preprocessor defines
  2. LD_LIBRARY_PATH vs LIBRARY_PATH
  3. How to see which flags -march=native will activate?
  4. OS X 10.9 gcc links to clang
  5. What’s the difference between gcc and g++/gcc-c++?
  6. Can CMake use g++ to compile C files?
  7. Linking with dynamic library with dependencies
  8. gcc/g++ option to place all object files into separate directory
  9. How do I set up CLion to compile and run?
  10. Why gcc 4.1 + gcov reports 100% branch coverage and newer (4.4, 4.6, 4.8) reports 50% for “p = new class;” line?
  11. Makefile removes object files for no reason
  12. Tail recursion in gcc/g++
  13. How to load address of function or label into register
  14. libpthread.so.0: error adding symbols: DSO missing from command line
  15. how to link static library into dynamic library in gcc
  16. Why does typeid.name() return weird characters using GCC and how to make it print unmangled names?
  17. How to use AddressSanitizer with GCC?
  18. gcc/g++: “No such file or directory”
  19. Exec format error 32-bit executable Windows Subsystem for Linux?
  20. ARM compilation error, VFP registers used by executable, not object file
  21. GNU C++ how to check when -std=c++0x is in effect?
  22. CFLAGS, CCFLAGS, CXXFLAGS – what exactly do these variables control?
  23. CMake: The C Compiler is not able to compile a simple test program
  24. Does the restrict keyword provide significant benefits in gcc/g++?
  25. linking arbitrary data using GCC ARM toolchain
  26. Hiding symbol names in library
  27. valgrind, gcc 6.2.0 and “-fsanitize=address”
  28. How to view C preprocessor output?
  29. How do I recover a semaphore when the process that decremented it to zero crashes?
  30. What’s the difference between -O3 and (-O2 + flags that man gcc says -O3 adds to -O2)?

Leave a Comment