c# - 有没有办法查看 JITter 为给定的 C#/CIL 生成的 native 代码？

Question

在对 this answer 的评论中(这建议在整数乘法/除法上使用位移运算符以提高性能)，我询问这是否真的会更快。在我的脑海深处有一个想法，即在某些层面上，某些东西足够聪明来计算出 >> 1 和 /2是相同的操作。但是，我现在想知道这是否真的是真的，如果是，它发生在什么水平。

一个测试程序为两个分别划分和移动参数的方法生成以下比较 CIL(打开 optimize):

  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.2
  IL_0002:  div
  IL_0003:  ret
} // end of method Program::Divider

对比

  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.1
  IL_0002:  shr
  IL_0003:  ret
} // end of method Program::Shifter

因此 C# 编译器发出 div 或 shr​​ 指令，并不聪明。我现在想看看 JITter 生成的实际 x86 汇编程序，但我不知道该怎么做。有可能吗？

编辑添加

调查结果

感谢您的回答，已接受来自 nobugz 的答案，因为它包含有关该调试器选项的关键信息。最终对我有用的是:

• 切换到发布配置
• 在工具|选项 |调试器，关闭“在模块加载时抑制 JIT 优化”(即我们希望允许 JIT 优化)
• 同一个地方，关闭“仅启用我的代码”(即我们要调试所有代码)
• 在某处放置一个 Debugger.Break() 语句
• 构建程序集
• 运行 .exe，当它中断时，使用现有的 VS 实例进行调试
• 现在反汇编窗口显示将要执行的实际 x86

结果至少可以说是很有启发性的——事实证明 JITter 实际上可以做算术!这是来自“反汇编”窗口的编辑示例。各种 -Shifter 方法使用 >>> 除以 2 的幂；各种 -Divider 方法使用 /

除以整数

 Console.WriteLine(string.Format("
     {0} 
     shift-divided by 2: {1} 
     divide-divided by 2: {2}", 
     60, TwoShifter(60), TwoDivider(60)));

00000026  mov         dword ptr [edx+4],3Ch 
...
0000003b  mov         dword ptr [edx+4],1Eh 
...
00000057  mov         dword ptr [esi+4],1Eh 

这两种静态除以 2 的方法不仅已被内联，而且实际计算已由 JITter 完成

Console.WriteLine(string.Format("
    {0} 
    divide-divided by 3: {1}", 
    60, ThreeDivider(60)));

00000085  mov         dword ptr [esi+4],3Ch 
...
000000a0  mov         dword ptr [esi+4],14h 

与静态除以 3 相同。

Console.WriteLine(string.Format("
    {0} 
    shift-divided by 4: {1} 
    divide-divided by 4 {2}", 
    60, FourShifter(60), FourDivider(60)));

000000ce  mov         dword ptr [esi+4],3Ch 
...
000000e3  mov         dword ptr [edx+4],0Fh 
...
000000ff  mov         dword ptr [esi+4],0Fh 

静态除以 4。

最好的:

Console.WriteLine(string.Format("
    {0} 
    n-divided by 2: {1} 
    n-divided by 3: {2} 
    n-divided by 4: {3}", 
    60, Divider(60, 2), Divider(60, 3), Divider(60, 4)));

0000013e  mov         dword ptr [esi+4],3Ch 
...
0000015b  mov         dword ptr [esi+4],1Eh 
...
0000017b  mov         dword ptr [esi+4],14h 
...
0000019b  mov         dword ptr [edi+4],0Fh 

它是内联的，然后计算所有这些静态除法!

但是如果结果不是静态的呢？我添加了代码以从控制台读取一个整数。这就是它为 split 产生的结果:

Console.WriteLine(string.Format("
    {0} 
    shift-divided by 2:  {1} 
    divide-divided by 2: {2}", 
    i, TwoShifter(i), TwoDivider(i)));

00000211  sar         eax,1 
...
00000230  sar         eax,1 

因此，尽管 CIL 不同，但 JITter 知道除以 2 是右移 1。

Console.WriteLine(string.Format("
    {0} 
    divide-divided by 3: {1}", i, ThreeDivider(i)));

00000283 idiv eax,ecx

它知道你必须除以 3。

Console.WriteLine(string.Format("
    {0} 
    shift-divided by 4: {1} 
    divide-divided by 4 {2}", 
    i, FourShifter(i), FourDivider(i)));

000002c5  sar         eax,2 
...
000002ec  sar         eax,2 

它知道除以 4 就是右移 2。

最后(又是最好的!)

Console.WriteLine(string.Format("
    {0} 
    n-divided by 2: {1} 
    n-divided by 3: {2} 
    n-divided by 4: {3}", 
    i, Divider(i, 2), Divider(i, 3), Divider(i, 4)));

00000345  sar         eax,1 
...
00000370  idiv        eax,ecx 
...
00000395  sar         esi,2 

它已内联该方法并根据静态可用参数找出最佳的处理方式。不错。

---

所以是的，在 C# 和 x86 之间的某个堆栈中， 足够聪明地计算出 >> 1 和 /2是相同的。所有这一切在我心中更加重要，我认为将 C# 编译器、JITter 和 CLR 加在一起比我们可以尝试的任何小技巧都更聪明应用程序员:)

Answer 1

在配置调试器之前，您不会获得有意义的结果。 Tools + Options，Debugging，General，关闭“Suppress JIT optimization on module load”。切换到 Release模式配置。示例片段:

static void Main(string[] args) {
  int value = 4;
  int result = divideby2(value);
}

如果反汇编看起来像这样，你就做对了:

00000000  ret  

您必须欺骗 JIT 优化器以强制对表达式求值。使用 Console.WriteLine(variable) 可以提供帮助。然后你应该看到这样的东西:

0000000a  mov         edx,2 
0000000f  mov         eax,dword ptr [ecx] 
00000011  call        dword ptr [eax+000000BCh] 

是的，它在编译时评估了结果。效果很好，不是吗。