How can I distinguish tail recursive calls/non-tail recursive calls? - tail-recursion

Question

int gcd(int a,int b){
if(a == b) return a;
else if (a>b) return gcd(a-b,b);
else return gcd(a,b);
}
For example, i think this is tail-recursive because you don't call another function.
int gcd(int a,int b){
int x;
if(a == b) x=a;
else if (a>b) x= gcd(a-b,b);
else x= gcd(a,b);
return x;
}
And this is non-tail recursive because it calls function gcd.
Am I right? Or is there any easier method to distinguish tail/non-tail recursive call?

Answer 1

First of all, for the purpose of g++ TCO (tail-call optimization) it doesn't matter if you are doing a recursive call or calling a different function altogether - function call will be replaced with unconditional jump.
Second of all, a tail call is happening when there is nothing happening between the call to other function and return. It can be last line before return, not last line before return or return itself.
For example,
} else {
x = gcd(a,b);
return x;
}
is a tail-call, because the value of x is returned unmodified (nothing is happening).
On the other hand,
} else {
x = gcd(a,b);
return x + 1;
}
This is not eligible for TCO, since return value is modified - something is happening.
But the fun just begins! Let's talk C++ and destructors. Consider following code:
int do2();
int do() {
std::string x;
// ...
return do2();
}
Is it a tail-call? First impression - yes, it is. Nothing is happening, right? Second impression - no, it is not! x destructor needs to happen! Third impression - yes, it is - because compiler, seeing as x is not used after the call, can easily destruct x before.
But, look at that:
int do2(const std::string& );
int do() {
std::string x;
// ...
return do2(x);
}
Here it is not a tail-call! x has to outlive do2, so going back to my original (deliberately vague) definition, something is happening.
Tail-calls are funny!