title: Is there a technical reason that C# does not issue the "tail." CIL instruction?
body: <blockquote>
    <p><strong>Possible Duplicate:</strong><br>
    <a href="https://stackoverflow.com/questions/491376/why-doesnt-net-c-eliminate-tail-recursion">Why doesn&#39;t .net/C# eliminate tail recursion?</a>  </p>
  </blockquote>
  
  
  
  <p>Take the following C# code:</p>
  
  <pre><code>using System;
  
  namespace TailTest
  {
      class MainClass
      {
          public static void Main (string[] args)
          {
              Counter(0);
          }
  
          static void Counter(int i)
          {
              Console.WriteLine(i);
              if (i &lt; int.MaxValue) Counter(++i);
          }
      }
  }
  </code></pre>
  
  <p>The C# compiler (mine anyway) will compile the Counter method into the following CIL:</p>
  
  <pre><code>.method private static hidebysig default void Counter (int32 i) cil managed 
  {
  .maxstack 8
  IL_0000:  ldarg.0 
  IL_0001:  call void class [mscorlib]System.Console::WriteLine(int32)
  IL_0006:  ldarg.0 
  IL_0007:  ldc.i4 2147483647
  IL_000c:  bge IL_0019
  IL_0011:  ldarg.0 
  IL_0012:  ldc.i4.1 
  IL_0013:  add 
  IL_0014:  call void class TailTest.MainClass::Counter(int32)
  IL_0019:  ret 
  }
  </code></pre>
  
  <p>The problem with the above code is that it will cause a stack overflow (at about i=262000 on my hardware). To get around this problem, some languages do what is called tail-call elimination or tail-call optimization (TCO). Essentially, they turn the recursive call into a loop.</p>
  
  <p>My understanding is the the 64-bit implementation of the .NET 4 JIT now performs TCO and avoids the overflow on code like the above CIL. However, the 32-bit JIT does not. Mono does not seem to either. It is interesting that the JIT (which is under time and resource pressure) does TCO while the C# compiler does not. My question is why isn't the C# compiler itself more TCO aware?</p>
  
  <p>There is a CIL instruction that tells the JIT to perform TCO. For example, the C# compiler could instead generate the following CIL:</p>
  
  <pre><code>.method private static hidebysig default void Counter (int32 i) cil managed 
  {
  .maxstack 8
  IL_0000:  ldarg.0 
  IL_0001:  call void class [mscorlib]System.Console::WriteLine(int32)
  IL_0006:  ldarg.0 
  IL_0007:  ldc.i4 2147483647
  IL_000c:  bge IL_001c
  IL_0011:  ldarg.0 
  IL_0012:  ldc.i4.1 
  IL_0013:  add 
  IL_0014:  tail.
  IL_0017:  call void class TailTest.MainClass::Counter(int32)
  IL_001c:  ret 
  }
  </code></pre>
  
  <p>Unlike the original, this code will not overflow and will run to completion even on the 32-bit JIT (both .NET and Mono). The magic is in the <code>tail.</code> CIL instruction. Compilers like F# will generate CIL that includes this instruction automatically.</p>
  
  <p>So my question is, is there a technical reason that the C# compiler does not do this?</p>
  
  <p>I get that it has historically maybe just not been worth it. Code like <code>Counter()</code> has not been common in idiomatic C# and/or the .NET framework. You could easily view TCO for C# as an unnecessary or premature optimization.</p>
  
  <p>With the introduction of LINQ and other things, it seems like both C# and C# developers are moving in more functional directions. So, it would be nice if using recursion was not such an unsafe thing to do. But my question is really a more technical one.</p>
  
  <p>Am missing something that makes TCO like this a bad idea (or a risky one) for C#. Or is there something that makes it particularly tricky to get right? That is really what I am hoping to understand. Any insight?</p>
  
  <p><strong>EDIT:</strong> Thanks for the great information. I just wanted to be clear that I am not criticizing the lack of or even demanding this feature. I am not super interested in the rational around prioritization. My curiosity is what obstacles might I not perceive or understand that make this a difficult, dangerous, or undesirable thing to do.</p>
  
  <p>Perhaps a different context will help focus the conversation...</p>
  
  <p>Let's say I was going to implement my own C#-like language on the CLR. Why would I not (other than opportunity cost) include automatic and transparent emission of the 'tail.' instruction where appropriate? What challenges would I encounter or what constraints would I introduce in supporting this feature in a language very much like C#.</p>
  
  <p>Thank you again (and in advance) for the responses.</p>