AOT漫谈专题(第四篇): C#程序如何编译成Native代码

自作多情是种病

一：背景

1. 讲故事

大家都知道所谓的.NET Native AOT即通过AOT编译器直接将C#代码编译成机器码，大家也习惯用C/C++的编译过程来类比，都是静态编译本质上都差不多，这篇我们借助工具从宏观层面去看一看AOT的编译过程。
二：C/C++ 的编译过程

用gcc编译过c代码的朋友都知道，分别可以用 -E, -S, -c，-o 来显示编译的各个阶段，即：

• 预处理阶段：落地 define，include文件和代码。
  
• 编译阶段：将C转为汇编代码。
  
• 汇编阶段：汇编代码转为机器码。
  
• 链接阶段：链接libc库及系统库，生成可执行文件。
  

画一张图如下：

这个世界上虽然说隔行如隔山，但隔行不隔理，有了这些知识，接下来就是按图索骥的对号入座即可。
三：AOT编译过程

在.NET中AOT编译器叫做ilc.exe，它是用C#代码写的，并且随.NET版本更新，比如我这里的 C:\Users\Administrator\.nuget\packages\runtime.win-x64.microsoft.dotnet.ilcompiler\8.0.8\tools\ilc.exe 。

对应的源码是在 D:\sources\runtime\src\coreclr\tools\aot 下。

还有一点要注意的是 ilc.exe 接收的是 MSIL 代码，而不是 C# 代码，有些朋友要问了 MSIL 何处来，自然是 dotnet publish 的时候先调用 Rolysn 来准备了，画个图如下：

接下来就是正式的ilc阶段。
1. 预处理阶段在哪里

这个阶段其实就对应着AOT的 依赖图构建和优化 ，当然C#这里比较复杂，包括的东西也比较多，比如：

• 构建依赖图
  
• Pinvoke，COM，Delegate 的IL代码二次处理
  
• ValueType 的 GetHashCode 和 Equals 生成。
  
• 对 反射的有限支持，提供了一些元数据。
  
• 摇树优化
  

为依赖图构建的所有物料，可以参考 obj\Debug\net8.0\win-x64\native 文件夹下的 Example_21_2.ilc.rsp。

感兴趣的朋友可以重点研究下这个库下的代码以及 DependencyAnalyzer 类，截图如下：

1.     /// <summary>
2.     /// Implement a dependency analysis framework. This works much like a Garbage Collector's mark algorithm
3.     /// in that it finds a set of nodes from an initial root set.
4.     ///
5.     /// However, in contrast to a typical GC in addition to simple edges from a node, there may also
6.     /// be conditional edges where a node has a dependency if some other specific node exists in the
7.     /// graph, and dynamic edges in which a node has a dependency if some other node exists in the graph,
8.     /// but what that other node might be is not known until it may exist in the graph.
9.     ///
10.     /// This analyzer also attempts to maintain a serialized state of why nodes are in the graph
11.     /// with strings describing the reason a given node was added to the graph. The degree of logging
12.     /// is configurable via the MarkStrategy
13.     ///
14.     /// </summary>
15.     public sealed class DependencyAnalyzer<MarkStrategy, DependencyContextType> : DependencyAnalyzerBase<DependencyContextType> where MarkStrategy : struct, IDependencyAnalysisMarkStrategy<DependencyContextType>
16.     {
17.         private MarkStrategy _marker = new MarkStrategy();
18.         private IComparer<DependencyNodeCore<DependencyContextType>> _resultSorter;
19.         private RandomInsertStack<DependencyNodeCore<DependencyContextType>> _markStack;
20.         private List<DependencyNodeCore<DependencyContextType>> _rootNodes = new List<DependencyNodeCore<DependencyContextType>>();
21.     }

复制代码

官方注释中写的挺有意思，这玩意就像 GC Mark 算法，看字段也是一个 深度优先算法。
有些朋友可能比较好奇，这个依赖树最后变成了什么样子，可以在 csproj 上配置 true 节点，然后通过 dotnet publish 就会生成一个 Example_21_2.map.xml 文件，打开即可看到类型和方法节点。

2. 编译阶段在哪里

C 的编译阶段是用来将C代码转成汇编代码，在 ILC 中叫做代码生成后端，在落地方案上支持两种。

• RyuJIT
  

对，你没看错，就是你熟悉的不能再熟悉的JIT编译器，AOT也在用它，毕竟这东西太成熟了，支持各大操作系统平台，对应的高层封装在 ILCompiler.RyuJit 库中，截图如下：

• LLVM
  

这东西目前主要用来生成 WebAssembly 代码，具体参见：https://github.com/dotnet/runtimelab/tree/feature/NativeAOT-LLVM
3. 汇编阶段在哪里

在 C 中这个阶段主要是将 .s 变成 .o 文件，即 汇编代码 到 机器码，如果往AOT上套的话，当属 ObjectWriter 类了，它要干的事情就是生成最终的 xxx.obj 文件。

4. 链接阶段在哪里

生成了 obj 之后，不管是 C 还是 C# 都 殊途同归 了，即调用 link.exe 将 VCRuntime运行时以及系统的.lib 库进行整体性合并，这个在 link.rsp 文件中可以窥之一二，截图如下：

图中有一个小注意点，此时的 obj 还没有 gc 代码，最终是在 link 阶段合并进去的。
三：如何眼见为实

为了研究这些过程，这里提供两款工具，一款叫 prefview，一款叫 procmon。
1. 如何观测编译流程

要想知道这个答案，找到一款合适的工具还是很容易知道的，在 Prefview 中有一个 Processes 视图，可以利用它观测 dotnet publish 命令执行后的进程启停情况，截图如下：

从卦中很明显看的出来是： dotnet.exe -> dotnet.exe (Roslyn) -> ilc.exe -> link.exe ，哈哈，这流程图是不是加深了对编译过程的理解哈。
2. 如何观测 obj 的生成

观测 obj 的生成，自然就是对 ilc.exe 的文件读写进行监控，对，可以用微软的 Procmon 工具，配置如下：

配置好之后，接下来就是使用 dotnet publish 来引诱 ilc.exe 出洞，然后 倾巢覆卵，截图如下：

接下来我们双击这一行观察 Stack 选项卡，可以很明显的看到是 ObjectWriter 所为，截图如下：

四：总结

研究这些东西还是比较麻烦的，主要是官方github上对ilc的介绍也比较有限，更多的还是需要研究源码，术业有专攻，作为一个调试师，更多精力还是耗在市场上的dump中吧。

来源:https://www.cnblogs.com/huangxincheng/p/18467144
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！