C# – MSIL

1. 前言

1.1. MSIL 是什么？

Microsoft Intermediate Language （MSIL）：微软中间语言。

1.2. C# 代码编译过程？

C# 源代码通过 LC (Language Complier) 转为 IL 代码，IL 主要包含一些元数据和中间语言指令；

JIT 编译器 把 IL 代码转为物理 CPU 能识别的机器代码。

如下图：

• Language Complier（语言编译器）的作用：无论是 VB code 还是 C# code 都会被 Language Compiler 转换为 MSIL。

• MSIL（微软中间语言）的作用：MSIL 包含一些元数据和中间语言指令。

• JIT Complier（JIT编译器）的作用：根据系统环境将 MSIL 中间语言指令转换为机器码（Native Code）。

2. MSIL 的框架

• Managed Heap（托管堆）：这就是 .NET 中的托管堆，用来存放引用类型，它是由 GC（垃圾回收器自动进行回收）管理；

• Evaluation Stack（计算堆栈）：每个线程都有自己的线程栈，IL 里面的任何计算，都发生在 Evaluation Stack 上，其实就是一个 Stack 结构。可以 Push，也可以 Pop。

• Call Stack（调用堆栈）：也是一个 Stack 结构，调用堆栈保存了被调用函数的参数列表（Argument List），还保存了调用返回信息，以及被调用函数的局部变量（Local Vars），非常类似于物理 CPU 上的 Call Stack，只不过没有相应的 寄存器 变量。

上图的出处：https://msdn.microsoft.com/zh-tw/library/dd229210.aspx

3. IL 汇编

3.1. 示例代码

用 C# 写一个简单控制台应用程序，代码如下：

using System;

namespace ILDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 1;
            int j = 2;
            int k = 3;
            int answer = i + j + k;
            Console.WriteLine("i + j + k = " + answer);
            Console.ReadKey();
        }
    }
}

3.2. 反编译

用 ILDasm 反编译上面代码的 exe 文件后得到的 IL 汇编如下：

.method private hidebysig static void Main(string[] args) cil managed
{
  .entrypoint   // 程序入口
  // 这个程序的的代码大小   42字节 (0x2a)
  .maxstack  2  // 计算堆栈(Evaluation Stack)的大小

  .locals init (
      [0] int32 i,
      [1] int32 j,
      [2] int32 k,
      [3] int32 answer
  ) // 定义 int32 类型的 i, j, k, answer

  IL_0000:  nop       // 无操作

  IL_0001:  ldc.i4.1  // 把整数值 1 (常量), 即 i = 1 压入计算堆栈最顶端, 相当于 push 1 到计算堆栈上
  IL_0002:  stloc.0   // 把计算堆栈顶部的值( i 的值)放到调用堆栈索引 0 处
  IL_0003:  ldc.i4.2  // 把整数值 2 (常量), 即 j = 2 压入计算堆栈最顶端, 相当于 push 2 到计算堆栈上
  IL_0004:  stloc.1   // 把计算堆栈顶部的值( j 的值)放到调用堆栈索引 1 处
  IL_0005:  ldc.i4.3  // 把整数值 3 (常量), 即 k = 3 压入计算堆栈最顶端, 相当于 push 3 到计算堆栈上
  IL_0006:  stloc.2   // 把计算堆栈顶部的值( k 的值)放到调用堆栈索引 2 处

  IL_0007:  ldloc.0   // 把调用堆栈索引为 0 处的值复制到计算堆栈上
  IL_0008:  ldloc.1   // 把调用堆栈索引为 1 处的值复制到计算堆栈上
  IL_0009:  add       // 相加, 即 (i + j)
  IL_000a:  ldloc.2   // 把调用堆栈索引为 2 处的值复制到计算堆栈上
  IL_000b:  add       // 相加, 即 ((i + j) + k)
  IL_000c:  stloc.3   // 把计算堆栈顶部的值(add 的值)放到调用堆栈索引 3 处, 即 (i + j + k)
  IL_000d:  ldstr ""i + j + k = ""  // 推送对元数据中存储的字符串的新对象引用。
  IL_0012:  ldloc.3   // 把调用堆栈索引为 3 处的值复制到计算堆栈上

  IL_0013:  box        [mscorlib]System.Int32     // 装箱
  IL_0018:  call       string [mscorlib]System.String::Concat(object, object)  // 调用内部方法
  IL_001d:  call       void [mscorlib]System.Console::WriteLine(string)        // 调用 WriteLine
  IL_0022:  nop        // 无操作
  IL_0023:  call       valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey()  // 调用 ConsoleKey
  IL_0028:  pop        // 弹出堆栈(对计算堆栈操作)
  IL_0029:  ret        // return, 返回
}
// end of method Program::Main

总结一下常用的 IL 指令：

• .entrypoint：指令表示 CLR 加载程序时，是首先从 .entrypoint 开始的，即从 Main 方法作为程序的入口函数；
• stloc.X：把计算堆栈顶部的值放到调用堆栈索引为 X 处的位置；
• ldloc.X：把调用堆栈 X 处位置的值复制到计算堆栈上；
• .newobj：用于创建引用类型的对象；
• .ldstr：用于创建 String 对象变量；
• .newarr：用于创建数组型对象；
• .box：在值类型转换为引用类型的对象时，将值类型拷贝至托管堆上分配内存；
• .assembly：指令告诉编译器，我们准备去用一个外部的类库（不是我们自己写的，而是提前编译好的）。

关于 .maxstack 的理解

上面的 IL 汇编代码中，看起来好像最多用到了 3 个计算堆栈的寄存器位置，但为什么 .maxstack 的值却是 2 呢？

这是因为，实际上，上面的 IL 代码中最多只用到了两个计算堆栈的寄存器位置。比如，一开始虽然“ldc.i4.1”，“ldc.i4.2”，“ldc.i4.3”指令分别加载了 3 个常量值到计算堆栈上，但每一个加载指令后面都有一条 stloc.X 指令，该指令把计算堆栈顶端的值写回到调用堆栈上了，下一条 ldc.i4.X 指令加载的值是可以覆盖原来调用堆栈最顶端的寄存器的，所以最多只需要一个计算堆栈的寄存器就可以了。

再看之后的两条 add 指令。第一条 add 指令，会对计算堆栈最顶端的两个 int32 的寄存器相加，并且把相加后的值写回到计算堆栈的最顶端。然后，第二条 add 指令之前，ldloc.2 把调用堆栈上的索引 2 位置的值复制到了计算堆栈上，同时，前面 i + j 相加后的值会被挤到第二位，第二条 add 指令还是对计算堆栈最顶端的两个 int32 的寄存器相加。所以，最多只需要两个计算堆栈的寄存器位置即可，后面的代码分析也同样不超过 2。

所以，对于上面的 IL 汇编代码，.maxstack 的值是 2 。

4. IL指令大全

5. 参考文章

1. 浅谈 C# 中的 IL

   https://blog.csdn.net/neil3611244/article/details/71211398

2. C# IL 入门

   https://blog.csdn.net/icebergliu1234/article/details/81322455

3. C# IL DASM 使用

   https://www.cnblogs.com/caokai520/p/4921706.html