G++ 尾递归优化失败

Question

I base this question on a comment I got for a previous question I asked here . A user replied I can have infinite tail recursion stacks. This is not what I found in practice however. To illustrate my point, take a look at my code:

#include <iostream>
#include <string>

void tail_print(string& in, size_t& index) //prints in backwards
{
  if (index == 0)
    {
      cout << '$' << endl;
      return;
    }

  cout << in[index];
  index--;
  tail_print(in, index);
}

int main()
{
  string a("abc$");
  size_t pos = a.length()-1;
  tail_print(a, pos);
  return 0;
}

Lets say the input string in contains characters in between the range: 1<in.length()<1000000.

The code is compiled with: g++ -pipe -std=c++14 -O2 $file -lm -o exe

This throws signal 11 (SIGSEG). I can't precisely tell at which input this fails, but I can tell with some certainty that the cause of this signal is from within this subroutine (works fine if I print the characters backwards with a for loop). Please note that this is part of a larger program so there may be unforeseeable complications (slim chance). In either way, I have to cast some doubt about tail recursion optimization if it causes a stackoverflow at a measely O(million) depth.

I'm using the following g++ version:

~$ g++ --version
g++ (Ubuntu 5.5.0-12ubuntu1~16.04) 5.5.0 20171010

Answer 1

If you rely on tail recursion you are at the mercy of the compiler as to whether it chooses to optimise your code. Debug builds will not be optimised so will always fail.

In your case printing a single character through std::cout seems to be the cause of your issue. libstdc++ seems to implement printing a single character via a call to:

std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)

For some reason this seems to trip up the tail recursion optimisation before GCC 10. All versions of Clang fail to optimise this too.

Replacing cout << in[index] with std::cout.put(in[index]) seems to allow all versions of GCC (down to 4.1.2 at least) and Clang to optimise the tail recursion: https://godbolt.org/z/Th1bT8

Interestingly calling std::__ostream_insert directly also works (but don't do that as you are then relying on internal libstdc++ implementation details): https://godbolt.org/z/9M5xd4

I think through the various levels of function call in libstdc++ you end up with (due to the function char argument being taken by value):

char c = in[index];
std::__ostream_insert<char, std::char_traits<char> >(std::cout, &c, 1);

Creating a pointer to a local variable seems to be what prevents the tail recursion: https://godbolt.org/z/KM4jGY , presumably this is because the compiler can't know what the called function will do with that pointer so it can't guarantee that using a loop will have the same behaviour.

As all tail recursions should be trivially replaceable with a loop its best to not rely on the vagaries of the compiler to do it for you, this will then work even in an unoptimised build:

void tail_print(const std::string& in, size_t index) //prints in backwards
{
    for (size_t i = index; i > 0; i--)
    {
        std::cout << in[i];
    }
    std::cout << "$\n";
}