Bypass Tier0 in recursive calls

[EgorBo]

The following program works with TC=0 and fails with StackOverflowException in default (Tiered) mode:

FibRecursive(0, 1, 10000000);

long FibRecursive(long acc1, long acc2, int count) =>
    count switch
    {
        0 => acc1,
        1 => acc2,
        _ => FibRecursive(acc2, acc1 + acc2, count - 1)
    };

Since Roslyn never emits .tail prefix, I think JIT should at least catch obvious recursive calls by bypassing Tier0 and compile such methods with optimizations immediately (or emit tails even in Tier0 ?)

@dotnet/jit-contrib for opinions

[MihuBot]

I'm a bot. Here is a possible related and/or duplicate issue (I may be wrong):

• Tailcall optimization doesn't work with netcoreapp3.0 runtime #13255

[jkotas]

Is the idea that we would document where users can take a dependency on implicit tailcalls? What would the documentation say?

If we want to have deterministic tailcalls in C#, I think it would be better to do that via an explicit gesture.

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[kg]

I feel like silently skipping tier0 has a potential for problems vs generating a tail here (if tails can work in gen0)

[davidwrighton]

This also adds a behavior where the interpreter will be different from jit behavior, since we certainly don't intend to add lots of weird checks like this in the interpreter. I don't think this is really worth it.

[jkotas]

Related / duplicate: dotnet/csharplang#2544

[EgorBo]

Is the idea that we would document where users can take a dependency on implicit tailcalls?

This also adds a behavior where the interpreter will be different from jit behavior,

I was thinking about it as a best-effort, the existing fast tail calls are already exactly what you're worried about - they kick in in Tier1, they may or may not kick in depending on some external factors such as ABI, or some "unrelated" code change that breaks them.

The motivation behind this suggestion is that JIT is smart enough to optimize the Fibonacci just like any other compiler, but currently any attempt to run it results in SO (which is, basically, a regression from pre .NET Core 3.0)

I feel like silently skipping tier0 has a potential for problems vs generating a tail here (if tails can work in gen0)

We already skip Tier0 for explicit .tail prefix for the same reason.

Related / duplicate: dotnet/csharplang#2544

This is definitely a better option, but it doesn't look like it will land anytime soon

[jkotas]

which is, basically, a regression from pre .NET Core 3.0

It was broken when running under VS debugger pre .NET Core 3.0 as well.