C*dder was right all along

Consider the following:
#include <stdio.h>

int
benis (int a)
{
if (a > 250)
return bonis (a);
else
return benis (a + 5);
}

int
bonis (int a)
{
return bepis (a * 2);
}

int
bepis (int a)
{
if (a > 1000)
return a;
else
banis (a + 2);
}

int
banis (int a)
{
if (a > 900)
return a;
else
bepis (a);
}

With -O2 the latest gcc (-O2, pretty much the same results with -O3) compiles it to
benis:
cmp edi, 250
jg .L4
ret
.L4:
add edi, edi
mov eax, 0
cmp edi, 1001
cmovge eax, edi
ret
bonis:
add edi, edi
mov eax, 0
cmp edi, 1001
cmovge eax, edi
ret
bepis:
cmp edi, 1000
jg .L9
ret
.L9:
mov eax, edi
ret
banis:
cmp edi, 900
jle .L11
mov eax, edi
ret
.L11:
ret
Notice all the rets even though it uses jumps (due to tail calls)?

Now, let's try to compile with C++:
benis(int):
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
cmp DWORD PTR [rbp-4], 250
jle .L2
mov eax, DWORD PTR [rbp-4]
mov edi, eax
call bonis(int)
jmp .L3
.L2:
mov eax, DWORD PTR [rbp-4]
add eax, 5
mov edi, eax
call benis(int)
nop
.L3:
leave
ret
bonis(int):
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
mov eax, DWORD PTR [rbp-4]
add eax, eax
mov edi, eax
call bepis(int)
leave
ret
bepis(int):
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
cmp DWORD PTR [rbp-4], 1000
jle .L7
mov eax, DWORD PTR [rbp-4]
jmp .L6
.L7:
mov eax, DWORD PTR [rbp-4]
add eax, 2
mov edi, eax
call banis(int)
.L6:
leave
ret
banis(int):
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
cmp DWORD PTR [rbp-4], 900
jle .L10
mov eax, DWORD PTR [rbp-4]
jmp .L9
.L10:
mov eax, DWORD PTR [rbp-4]
mov edi, eax
call bepis(int)
.L9:
leave
ret
No TCO? What? Is this a joke of some sorts? Even I can do better than that.

Same issue with C++ + Clang (-O2, for -O3 the output is the same as the C one)
benis(int): # @benis(int)
push rbp
mov rbp, rsp
sub rsp, 16
mov dword ptr [rbp - 8], edi
cmp dword ptr [rbp - 8], 250
jle .LBB0_2
mov edi, dword ptr [rbp - 8]
call bonis(int)
mov dword ptr [rbp - 4], eax
jmp .LBB0_3
.LBB0_2:
mov eax, dword ptr [rbp - 8]
add eax, 5
mov edi, eax
call benis(int)
mov dword ptr [rbp - 4], eax
.LBB0_3:
mov eax, dword ptr [rbp - 4]
add rsp, 16
pop rbp
ret
bonis(int): # @bonis(int)
push rbp
mov rbp, rsp
sub rsp, 16
mov dword ptr [rbp - 4], edi
mov edi, dword ptr [rbp - 4]
shl edi, 1
call bepis(int)
add rsp, 16
pop rbp
ret
bepis(int): # @bepis(int)
push rbp
mov rbp, rsp
sub rsp, 16
mov dword ptr [rbp - 4], edi
cmp dword ptr [rbp - 4], 1000
jle .LBB2_2
mov eax, dword ptr [rbp - 4]
add rsp, 16
pop rbp
ret
.LBB2_2:
mov eax, dword ptr [rbp - 4]
add eax, 2
mov edi, eax
call banis(int)
mov dword ptr [rbp - 8], eax # 4-byte Spill
ud2
banis(int): # @banis(int)
push rbp
mov rbp, rsp
sub rsp, 16
mov dword ptr [rbp - 4], edi
cmp dword ptr [rbp - 4], 900
jle .LBB3_2
mov eax, dword ptr [rbp - 4]
add rsp, 16
pop rbp
ret
.LBB3_2:
mov edi, dword ptr [rbp - 4]
call bepis(int)
mov dword ptr [rbp - 8], eax # 4-byte Spill
ud2

At least clang (-O1 to -O3) with C uses tail calls without ret:
benis: # @benis
cmp edi, 250
mov eax, 251
cmovg eax, edi
add eax, 4
sub eax, edi
mov ecx, 3435973837
imul rcx, rax
shr rcx, 34
lea eax, [rcx + 4*rcx]
add eax, edi
add eax, eax
ret
bonis: # @bonis
lea eax, [rdi + rdi]
ret
bepis: # @bepis
mov eax, edi
ret
banis: # @banis
mov eax, edi
ret

too long; didnt read........

WHY should i care? I make java copde, have a good job with money,

(Post not truncated)

>>3
The standard Java implementation does not optimise tail calls either.

>>1
Pay the Stroustrup Zero-Overhead Toll and check your binaries file size, you'll be surprised.

TCO in C really fucking sucks, IIRC it's due to calling conventions being retarded. optimizing anything beyond trivial recursion turns the compiler into a drooling retard