JIT コンパイラの Dead Code Elimination を利用して，同一の CIL から複数の実装を生成する

.NET

値型かもしれない変数をnullと比較する

『プログラミングMicrosoft .NET Framework 第2版』で紹介されているように，以下のコードは合法．

ジェネリックの型引数をnullと比較する

ジェネリックの型が制約されていなくても、ジェネリックの型引数を、==演算子または!=演算子を使ってnullと比較することができます。

private static void ComparingAGenericTypeVariableWithNull<T>(T obj) {
    if (obj == null ) { /* 値型では絶対に実行されない */ }
}

Tには制約がないので、参照型にも値型にもなりえます。Tが値型であった場合、objはnullにはなりません。この場合、C#コンパイラがエラーを出力すると思うでしょう。しかし、C#コンパイラはエラーを出力しません。このコードは問題なくコンパイルされます。このメソッドが、型引数に値型を指定されて呼び出されると、JITコンパイラはifステートメントがtrueにならないことを検出し、ifのテストと中かっこ({})の中のコードに対応するネイティブコードを生成しません。!=を使っていた場合には、JITコンパイラはifのテストを出力せず(常にtrueなので)に、ifの中かっこの中のコードを生成します。

ちなみに、Tがstructに制約されていた場合、値が他の変数とnullを比較するコードを記述すべきでない(常に同じ結果になる)ので、C#コンパイラはエラーを出力します。

じゃあこれを使うと，同一の中間コード (CIL) から，複数の実装を実行時生成できるんじゃなかろうか，と思って実験してみたらうまく行ったという話が以下．

想定シナリオ

例えば次のような C# コードを眺めつつ，ソースコード上ではなるべく実装を共有したい，しかし処理効率の関係から分岐は使いたくない，という場合を考えてみる．

public static void FuncX()
{
    InitX();
    FooBar();
    CleanUpX();
}
public static void FuncY()
{
    InitY();
    FooBar();
    CleanUpY();
}

これを書き換える．

public static void Func<T>()
{
    if (default(T) == null)
    {
        InitX();
    }
    else
    {
        InitY();
    }
    FooBar();
    if (default(T) == null)
    {
        CleanUpX();
    }
    else
    {
        CleanUpY();
    }
}

このコードは，確かに単一の CIL にコンパイルされる．
T が値型か参照型かは呼び出し側が決める．それぞれのケースについて，JIT コンパイラはネイティブコードを生成する*1．
このとき JIT コンパイラの Dead Code Elimination も個別に働く．その結果，T が参照型の場合は InitX と CleanUpX の呼び出しのみが残り，T が値型のときは InitY と CleanUpY の呼び出しのみが残る．結果として 2 つの実装が生成された．というわけだ．

実験

別の例で実験してみよう．

public static void Foo<T>(int[] array)
{
    foreach (var i in array)
    {
        if(default(T) == null ? array[i] > 3 : array[i] < 3)
        {
            Console.WriteLine("BANG!");
        }
    }
}

このコードを Release ビルドし，JIT コンパイラが生成した x86 コードを見てみる．T = object の場合と T = int の場合で実験した．環境は以下の通り．

================== Foo<object> の場合 ==================
    public static void Foo<T>(int[] array)
    {
        foreach (var i in array)
00000000  push        ebp
00000001  mov         ebp,esp
00000003  push        edi
00000004  push        esi
00000005  mov         esi,ecx
00000007  xor         edi,edi
00000009  cmp         dword ptr [esi+4],0
0000000d  jle         00000042
0000000f  mov         edx,dword ptr [esi+edi*4+8]
        {
            if(default(T) == null ? array[i] > 3 : array[i] < 3)
00000013  cmp         edx,dword ptr [esi+4]
00000016  jae         00000046
00000018  cmp         dword ptr [esi+edx*4+8],3
0000001d  setg        al
00000020  movzx       eax,al
00000023  test        eax,eax
00000025  je          0000003C
            {
                Console.WriteLine("BANG!");
00000027  call        698F59D8
0000002c  mov         ecx,eax
0000002e  mov         edx,dword ptr ds:[02BE2030h]
00000034  mov         eax,dword ptr [ecx]
00000036  call        dword ptr [eax+000000D8h]
0000003c  inc         edi
        foreach (var i in array)
0000003d  cmp         dword ptr [esi+4],edi
00000040  jg          0000000F
00000042  pop         esi
            }
        }
    }
00000043  pop         edi
00000044  pop         ebp
00000045  ret
00000046  call        6A89493A
0000004b  int         3
================== Foo<int> の場合 ==================
    public static void Foo<T>(int[] array)
    {
        foreach (var i in array)
00000000  push        ebp
00000001  mov         ebp,esp
00000003  push        edi
00000004  push        esi
00000005  mov         esi,ecx
00000007  xor         edi,edi
00000009  cmp         dword ptr [esi+4],0
0000000d  jle         00000042
0000000f  mov         edx,dword ptr [esi+edi*4+8]
        {
            if(default(T) == null ? array[i] > 3 : array[i] < 3)
00000013  cmp         edx,dword ptr [esi+4]
00000016  jae         00000046
00000018  cmp         dword ptr [esi+edx*4+8],3
0000001d  setl        al
00000020  movzx       eax,al
00000023  test        eax,eax
00000025  je          0000003C
            {
                Console.WriteLine("BANG!");
00000027  call        698F5978
0000002c  mov         ecx,eax
0000002e  mov         edx,dword ptr ds:[02BE2030h]
00000034  mov         eax,dword ptr [ecx]
00000036  call        dword ptr [eax+000000D8h]
0000003c  inc         edi
        foreach (var i in array)
0000003d  cmp         dword ptr [esi+4],edi
00000040  jg          0000000F
00000042  pop         esi
            }
        }
    }
00000043  pop         edi
00000044  pop         ebp
00000045  ret
00000046  call        6A8948DA
0000004b  int         3

ほとんど同じコードだが，よく見れば 0000001d 番地の命令が異なっている．

問題点

残念ながら，この方式は万全という訳でもない．例えば，読みやすさを改善しようとすると Dead Code Elimination ができなくなる，という問題に出くわした．
まず，コードを読みやすくするために，以下のような型とユーティリティメソッドを定義した．

public interface IMetaBool<T> { }
public sealed class True : IMetaBool<True> { }
public struct False : IMetaBool<False> { }
public static class Util
{
    public static bool ToBoolean<T>() where T:IMetaBool<T>
    {
        return default(T) == null;
    }
}

これで，コードの読みやすさは改善できる．が……

public static void Foo<CheckHigher>(int[] array)
    where CheckHigher : IMetaBool<CheckHigher>
{
    foreach (var i in array)
    {
        if (Util.ToBoolean<CheckHigher>()
                ? array[i] > 3 : array[i] < 3)
        {
            Console.WriteLine("BANG!");
        }
    }
}
static void Main(string[] args)
{
    int[] array = new[] { 0, 1, 2 };
    Foo<True>(array);
    Foo<False>(array);
}

試してみると Util.ToBoolean<CheckHigher>() のインライン展開が行われないことに気付く．Util.ToBoolean<CheckHigher>() の呼び出しが残るため，if 文も除去されない．これでは，引数でフラグを指定するのと変わらない．
Util.ToBoolean<CheckHigher>() のインライン展開が行われない理由はよく分からない．where 制約を外して実験してみたがダメだった．
もうちょっとがんばれば，Generative CLR Programming とかできそうなんだが．調査はケイゾク．

*1:参照型同士であれば異なる型でもコード共有される．