Z ciekawości próbowałem wygenerować kod wywołania ogona za pomocą C #. Fibinacci jest łatwy, więc mój przykład c # wygląda tak:

    private static void Main(string[] args)
    {
        Console.WriteLine(Fib(int.MaxValue, 0));
    }

    public static int Fib(int i, int acc)
    {
        if (i == 0)
        {
            return acc;
        }

        return Fib(i - 1, acc + i);
    }

Jeśli zbuduję go w wersji i uruchomię bez debugowania, nie przepełnię stosu. Debugowanie lub uruchamianie go bez optymalizacji i otrzymuję przepełnienie stosu, co oznacza, że ​​wywołanie tail działa w wersji z optymalizacją (czego się spodziewałem).

MSIL dla tego wygląda tak:

.method public hidebysig static int32 Fib(int32 i, int32 acc) cil managed
{
    // Method Start RVA 0x205e
    // Code Size 17 (0x11)
    .maxstack 8
    L_0000: ldarg.0 
    L_0001: brtrue.s L_0005
    L_0003: ldarg.1 
    L_0004: ret 
    L_0005: ldarg.0 
    L_0006: ldc.i4.1 
    L_0007: sub 
    L_0008: ldarg.1 
    L_0009: ldarg.0 
    L_000a: add 
    L_000b: call int32 [ConsoleApplication2]ConsoleApplication2.Program::Fib(int32,int32)
    L_0010: ret 
}

Oczekiwałbym, że zobaczę opcode ogonowy namsdn, ale go tam nie ma. Zastanawiałem się, czy kompilator JIT był odpowiedzialny za umieszczenie go tam? Próbowałem ngen zespołu (używającngen install <exe>, przechodząc do listy zestawów okien, aby je pobrać) i załaduj z powrotem w ILSpy, ale wygląda to tak samo:

.method public hidebysig static int32 Fib(int32 i, int32 acc) cil managed
{
    // Method Start RVA 0x3bfe
    // Code Size 17 (0x11)
    .maxstack 8
    L_0000: ldarg.0 
    L_0001: brtrue.s L_0005
    L_0003: ldarg.1 
    L_0004: ret 
    L_0005: ldarg.0 
    L_0006: ldc.i4.1 
    L_0007: sub 
    L_0008: ldarg.1 
    L_0009: ldarg.0 
    L_000a: add 
    L_000b: call int32 [ConsoleApplication2]ConsoleApplication2.Program::Fib(int32,int32)
    L_0010: ret 
}

Nadal tego nie widzę.

Wiem, że F # dobrze obsługuje wywołanie ogona, więc chciałem porównać to, co zrobił F # z tym, co zrobił C #. Mój przykład F # wygląda tak:

let rec fibb i acc =  
    if i = 0 then
        acc
    else 
        fibb (i-1) (acc + i)


Console.WriteLine (fibb 3 0)

A wygenerowana IL dla metody fib wygląda następująco:

.method public static int32 fibb(int32 i, int32 acc) cil managed
{
    // Method Start RVA 0x2068
    // Code Size 18 (0x12)
    .custom instance void [FSharp.Core]Microsoft.FSharp.Core.CompilationArgumentCountsAttribute::.ctor(int32[]) = { int32[](Mono.Cecil.CustomAttributeArgument[]) }
    .maxstack 5
    L_0000: nop 
    L_0001: ldarg.0 
    L_0002: brtrue.s L_0006
    L_0004: ldarg.1 
    L_0005: ret 
    L_0006: ldarg.0 
    L_0007: ldc.i4.1 
    L_0008: sub 
    L_0009: ldarg.1 
    L_000a: ldarg.0 
    L_000b: add 
    L_000c: starg.s acc
    L_000e: starg.s i
    L_0010: br.s L_0000
}

Co, według ILSpy, jest równoważne z tym:

[Microsoft.FSharp.Core.CompilationArgumentCounts(Mono.Cecil.CustomAttributeArgument[])]
public static int32 fibb(int32 i, int32 acc)
{
    label1:
    if !(((i != 0))) 
    {
        return acc;
    }
    (i - 1);
    i = acc = (acc + i);;
    goto label1;
}

Więc F # wygenerował wywołanie ogonowe używając instrukcji goto? Tego nie oczekiwałem.

Nie próbuję polegać na połączeniach ogonowych w dowolnym miejscu, ale jestem po prostu ciekawy, gdzie dokładnie ustawia się ten opcode? Jak to robi C #?