[移动开发]LLVM Clang前端编译与调试

LLVM Clang前端编译与调试
iOS 关于编译
o 一、Objective-C 编译过程
o 为什么需要重新编译？
o 编译步骤
o 二、编译步骤的详细说明
o 1.预处理
o 2.编译
o 词法分析
o 语法分析
o clang static analyzer
o 3.生成
o LLVM IR
o LLVM Backend
o 三、编译完成生成的文件
o Link Map File
o dSYM 文件
o Mach-O
o 四、总结
o 五、推荐学习
技术学习有两种方向，一种是不断向前，了解前沿和趋势；另一种是不断向下，理解通用的底层技术和设计思想。这两种方法没有优劣之分，更应该是一种不断交替使用的方式。
编译器相关的内容，在不断学习底层知识的过程中梳理一下内容。
一、Objective-C 编译过程
在说编译之前，先说明几个概念：
? LLVM：Low Level Virtual Machine，由 Chris Lattner（Swift 作者） 用于 Objective-C 和 Swift 的编译，后来加上了很多功能可用于常规编译器、JIT 编译器、调试器、静态分析工具等。总结来说，LLVM 是工具链技术与一个模块化和可重用的编译器的集合。
? Clang：是 LLVM 的子项目，可以对 C、C++和 Objective-C 进行快速编译，编译速度比 GCC 快 3 倍。Clang 可以认为是 Objective-C 的编译前端，LLVM 是编译后端，前端调用后端接口完成任务。Swift有编译前端 SIL optimizer，编译后端同样用的是 LLVM。
? AST：抽象语法树，按照层级关系排列。
? IR：中间语言，具有与语言无关的特性，整体结构为 Module(一个文件)–Function–Basic Block–Instruction(指令)。
? 编译器：编译器用于把代码编译成机器码，机器码可以直接在 CPU 上面运行。好处是运行效率高，坏处是调试周期长，需要重新编译一次（OC 改完代码需要重新运行）。
? 解释器：解释器会在运行时解释执行代码，会一段一段的把代码翻译成目标代码，然后执行目标代码。好处是具有动态性，调试及时（类似 Flutter、Playground），坏处是执行效率低。平时在调试代码的时候，使用解释器会提供效率。
为什么需要重新编译？
首先先来问个问题，为什么 Objective-C 代码每次修改之后，都要重新编译才能运行到机子上，JavaScript可以做到动态调试，不需要重新编译？
答案是 Objective-C 使用编译器的方式生成机器码，JavaScript使用解释器的方式。因为苹果公司希望 iPhone 的执行效率更高、运行速度能达到最快，选择牺牲调试周期，放弃动态性。
是不是真的不能动态调试了？不是，Objective-C 有一种加载动态库的机制，这就为动态调试留下了机会，具体的例子可以看这里https://github.com/johnno1962/InjectionIII。Injection 原理是将代码打包成动态库，如果发现代码有做更改，使用 dlopen 重新进行动态库的加载。
编译步骤
接下来，说一下编译的过程，将这个过程简单分成以下 3 步：

1. 预处理：编译开始时，LLVM 会预处理代码，比如宏替换、头文件导入；
2. 编译：预处理完后，LLVM 会对代码进行词法分析和语法分析(Clang)，生成 AST。AST是抽象语法树，结构上比代码更精简，遍历更快，使用 AST 能够更快速地进行静态检查，更快地生成 IR。
3. 生成：最后 AST 会生成 IR，IR 是一种更接近机器码的语言，区别在于和平台无关，通过 IR 可以生成多份适合不同平台的机器码。对于 iOS 系统，IR 生成的可执行文件就是 Mach-O。
   用代码来详细解释一下这 3 个过程。
   二、编译步骤的详细说明
   1.预处理
   新建一个工程，在 mian 中写出如下代码：
4. #import <Foundation/Foundation.h>
6. #define DefineEight 8
8. int main(int argc, char * argv[]) {

10.  @autoreleasepool {
    

12.      int i = DefineEight;
    

14.     int j = 6;
    

16.     NSString *string = [[NSString alloc] initWithUTF8String:"clang"];
    

18.     int rank = i + j;
    

20.     NSLog(@"%@ rank %d",string, rank);
    

22. }
    

24. return 0;
    

26. }

编译的预处理阶段会替换宏，导入头文件等，上面的main.m预处理到底做了什么。在命令行中输入：

1. clang -E main.m

执行之后控制台输出：

1. 1 “/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/Foundation.framework/Headers/FoundationLegacySwiftCompatibility.h” 1 3

3. 193 “/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h” 2 3

5. 10 “main.m” 2

9. int main(int argc, char * argv[]) {

11. @autoreleasepool {
    

13.     int i = 8;
    

15.     int j = 6;
    

17.     NSString *string = [[NSString alloc] initWithUTF8String:"clang"];
    

19.     int rank = i + j;
    

21.     NSLog(@"%@ rank %d",string, rank);
    

23. }
    

25. return 0;
    

27. }

宏已经替换修改，头文件引入变成了相关文件地址。
2.编译
词法分析
编译阶段，Clang先进行词法分析，在命令行输入：

1. clang -fmodules -fsyntax-only -Xclang -dump-tokens main.m
5. clang -fmodules -E -Xclang -dump-tokens main.m

打印信息如下：

1. annot_module_include '#import <Foundation/Foundation.h>
3. #define DefineEight 8
7. int main(int argc, char * argv[]) {

11. @autoreleasepool {
    

13.     int i = DefineEight;
    

15.     int'        Loc=<main.m:9:1>
    

17. int ‘int’ [StartOfLine] Loc=main.m:12:1
19. identifier ‘main’ [LeadingSpace] Loc=main.m:12:5
21. l_paren ‘(’ Loc=main.m:12:9
23. int ‘int’ Loc=main.m:12:10
25. identifier ‘argc’ [LeadingSpace] Loc=main.m:12:14
27. comma ‘,’ Loc=main.m:12:18
29. char ‘char’ [LeadingSpace] Loc=main.m:12:20
31. star ‘*’ [LeadingSpace] Loc=main.m:12:25
33. identifier ‘argv’ [LeadingSpace] Loc=main.m:12:27
35. l_square ‘[’ Loc=main.m:12:31
37. r_square ‘]’ Loc=main.m:12:32
39. r_paren ‘)’ Loc=main.m:12:33
41. l_brace ‘{’ [LeadingSpace] Loc=main.m:12:35
43. at ‘@’ [StartOfLine] [LeadingSpace] Loc=main.m:14:5
45. identifier ‘autoreleasepool’ Loc=main.m:14:6
47. l_brace ‘{’ [LeadingSpace] Loc=main.m:14:22
49. int ‘int’ [StartOfLine] [LeadingSpace] Loc=main.m:15:9
51. identifier ‘i’ [LeadingSpace] Loc=main.m:15:13
53. equal ‘=’ [LeadingSpace] Loc=main.m:15:15
55. numeric_constant ‘8’ [LeadingSpace] Loc=<main.m:15:17 <Spelling=main.m:10:22>>
57. semi ‘;’ Loc=main.m:15:28
59. int ‘int’ [StartOfLine] [LeadingSpace] Loc=main.m:16:9
61. identifier ‘j’ [LeadingSpace] Loc=main.m:16:13
63. equal ‘=’ [LeadingSpace] Loc=main.m:16:15
65. numeric_constant ‘6’ [LeadingSpace] Loc=main.m:16:17
67. semi ‘;’ Loc=main.m:16:18
69. identifier ‘NSString’ [StartOfLine] [LeadingSpace] Loc=main.m:17:9
71. star ‘*’ [LeadingSpace] Loc=main.m:17:18
73. identifier ‘string’ Loc=main.m:17:19
75. equal ‘=’ [LeadingSpace] Loc=main.m:17:26
77. l_square ‘[’ [LeadingSpace] Loc=main.m:17:28
79. l_square ‘[’ Loc=main.m:17:29
81. identifier ‘NSString’ Loc=main.m:17:30
83. identifier ‘alloc’ [LeadingSpace] Loc=main.m:17:39
85. r_square ‘]’ Loc=main.m:17:44
87. identifier ‘initWithUTF8String’ [LeadingSpace] Loc=main.m:17:46
89. colon ‘:’ Loc=main.m:17:64
91. string_literal ‘“clang”’ Loc=main.m:17:65
93. r_square ‘]’ Loc=main.m:17:72
95. semi ‘;’ Loc=main.m:17:73
97. int ‘int’ [StartOfLine] [LeadingSpace] Loc=main.m:18:9
99. identifier ‘rank’ [LeadingSpace] Loc=main.m:18:13
101. equal ‘=’ [LeadingSpace] Loc=main.m:18:18
103. identifier ‘i’ [LeadingSpace] Loc=main.m:18:20
105. plus ‘+’ [LeadingSpace] Loc=main.m:18:22
107. identifier ‘j’ [LeadingSpace] Loc=main.m:18:24
109. semi ‘;’ Loc=main.m:18:25
111. identifier ‘NSLog’ [StartOfLine] [LeadingSpace] Loc=main.m:19:9
113. l_paren ‘(’ Loc=main.m:19:14
115. at ‘@’ Loc=main.m:19:15
117. string_literal ‘"%@ rank %d"’ Loc=main.m:19:16
119. comma ‘,’ Loc=main.m:19:28
121. identifier ‘string’ Loc=main.m:19:29
123. comma ‘,’ Loc=main.m:19:35
125. identifier ‘rank’ [LeadingSpace] Loc=main.m:19:37
127. r_paren ‘)’ Loc=main.m:19:41
129. semi ‘;’ Loc=main.m:19:42
131. r_brace ‘}’ [StartOfLine] [LeadingSpace] Loc=main.m:20:5
133. return ‘return’ [StartOfLine] [LeadingSpace] Loc=main.m:21:5
135. numeric_constant ‘0’ [LeadingSpace] Loc=main.m:21:12
137. semi ‘;’ Loc=main.m:21:13
139. r_brace ‘}’ [StartOfLine] Loc=main.m:22:1
141. eof ‘’ Loc=main.m:22:2

Clang 在进行词法分析时，将代码切分成 一个一个Token，比如大小括号、等于号和字符串等。上面打印的信息，可以看到每个 Token ，里面有类型、值和位置。Clang 定义的 Token 类型，可以分为以下 4 类：

1. 关键字：语法中的关键字，比如 if、else、while、for 等；
2. 标识符：变量名；
3. 字面量：值、数字、字符串；
4. 特殊符号：加减乘除等符号；
   所有的 Token 类型可以查看https://opensource.apple.com//source/lldb/lldb-69/llvm/tools/clang/include/clang/Basic/TokenKinds.def。
   语法分析
   词法分析完成后，进行语法分析，验证语法是否正确，将输出的 Token 先按照语法组合成语义生成节点，将这些节点按照层级关系组成抽象语法树（AST）。
   在命令行中输入：
5. clang -fmodules -fsyntax-only -Xclang -ast-dump main.m

输出信息如下：

1. TranslationUnitDecl 0x7ff3e4015608 <>
3. |-TypedefDecl 0x7ff3e4015ea0 <> implicit __int128_t ‘__int128’
5. | `-BuiltinType 0x7ff3e4015ba0 ‘__int128’
7. |-TypedefDecl 0x7ff3e4015f10 <> implicit __uint128_t ‘unsigned __int128’
9. | `-BuiltinType 0x7ff3e4015bc0 ‘unsigned __int128’
11. |-TypedefDecl 0x7ff3e4015fb0 <> implicit SEL ‘SEL *’
13. | `-PointerType 0x7ff3e4015f70 ‘SEL *’ imported
15. | `-BuiltinType 0x7ff3e4015e00 ‘SEL’
17. |-TypedefDecl 0x7ff3e4016098 <> implicit id ‘id’
19. | `-ObjCObjectPointerType 0x7ff3e4016040 ‘id’ imported
21. | `-ObjCObjectType 0x7ff3e4016010 ‘id’ imported
23. |-TypedefDecl 0x7ff3e4016178 <> implicit Class ‘Class’
25. | `-ObjCObjectPointerType 0x7ff3e4016120 ‘Class’ imported
27. | `-ObjCObjectType 0x7ff3e40160f0 ‘Class’ imported
29. |-ObjCInterfaceDecl 0x7ff3e40161d0 <> implicit Protocol
31. |-TypedefDecl 0x7ff3e4016548 <> implicit __NSConstantString ‘struct __NSConstantString_tag’
33. | `-RecordType 0x7ff3e4016340 ‘struct __NSConstantString_tag’
35. | `-Record 0x7ff3e40162a0 ‘__NSConstantString_tag’
37. |-TypedefDecl 0x7ff3e4052c00 <> implicit __builtin_ms_va_list ‘char *’
39. | `-PointerType 0x7ff3e40165a0 ‘char *’
41. | `-BuiltinType 0x7ff3e40156a0 ‘char’
43. |-TypedefDecl 0x7ff3e4052ee8 <> implicit __builtin_va_list ‘struct __va_list_tag [1]’
45. | `-ConstantArrayType 0x7ff3e4052e90 ‘struct __va_list_tag [1]’ 1
47. | `-RecordType 0x7ff3e4052cf0 ‘struct __va_list_tag’
49. | `-Record 0x7ff3e4052c58 ‘__va_list_tag’
51. |-ImportDecl 0x7ff3e42ce778 main.m:9:1 col:1 implicit Foundation
53. `-FunctionDecl 0x7ff3e42cea40 <line:12:1, line:22:1> line:12:5 main ‘int (int, char **)’
55. |-ParmVarDecl 0x7ff3e42ce7d0 <col:10, col:14> col:14 argc ‘int’
57. |-ParmVarDecl 0x7ff3e42ce8f0 <col:20, col:32> col:27 argv ‘char **’:‘char **’
59. `-CompoundStmt 0x7ff3e390be60 <col:35, line:22:1>

61. |-ObjCAutoreleasePoolStmt 0x7ff3e390be18 <line:14:5, line:20:5>
    

63. | `-CompoundStmt 0x7ff3e390bde0 <line:14:22, line:20:5>
    

65. |   |-DeclStmt 0x7ff3e42cebf0 <line:15:9, col:28>
    

67. |   | `-VarDecl 0x7ff3e42ceb68 <col:9, line:10:22> line:15:13 used i 'int' cinit
    

69. |   |   `-IntegerLiteral 0x7ff3e42cebd0 <line:10:22> 'int' 8
    

71. |   |-DeclStmt 0x7ff3e5023750 <line:16:9, col:18>
    

73. |   | `-VarDecl 0x7ff3e42cec20 <col:9, col:17> col:13 used j 'int' cinit
    

75. |   |   `-IntegerLiteral 0x7ff3e42cec88 <col:17> 'int' 6
    

77. |   |-DeclStmt 0x7ff3e390b5e8 <line:17:9, col:73>
    

79. |   | `-VarDecl 0x7ff3e50237b0 <col:9, col:72> col:19 used string 'NSString *' cinit
    

81. |   |   `-ObjCMessageExpr 0x7ff3e3820390 <col:28, col:72> 'NSString * _Nullable':'NSString *' selector=initWithUTF8String:
    

83. |   |     |-ObjCMessageExpr 0x7ff3e5023b98 <col:29, col:44> 'NSString *' selector=alloc class='NSString'
    

85. |   |     `-ImplicitCastExpr 0x7ff3e3820378 <col:65> 'const char * _Nonnull':'const char *' <NoOp>
    

87. |   |       `-ImplicitCastExpr 0x7ff3e3820360 <col:65> 'char *' <ArrayToPointerDecay>
    

89. |   |         `-StringLiteral 0x7ff3e5023c08 <col:65> 'char [6]' lvalue "clang"
    

91. |   |-DeclStmt 0x7ff3e390bbc8 <line:18:9, col:25>
    

93. |   | `-VarDecl 0x7ff3e390b618 <col:9, col:24> col:13 used rank 'int' cinit
    

95. |   |   `-BinaryOperator 0x7ff3e390b720 <col:20, col:24> 'int' '+'
    

97. |   |     |-ImplicitCastExpr 0x7ff3e390b6f0 <col:20> 'int' <LValueToRValue>
    

99. |   |     | `-DeclRefExpr 0x7ff3e390b680 <col:20> 'int' lvalue Var 0x7ff3e42ceb68 'i' 'int'
    

101.    |   |     `-ImplicitCastExpr 0x7ff3e390b708 <col:24> 'int' <LValueToRValue>
     

103.    |   |       `-DeclRefExpr 0x7ff3e390b6b8 <col:24> 'int' lvalue Var 0x7ff3e42cec20 'j' 'int'
     

105.    |   `-CallExpr 0x7ff3e390bd60 <line:19:9, col:41> 'void'
     

107.    |     |-ImplicitCastExpr 0x7ff3e390bd48 <col:9> 'void (*)(id, ...)' <FunctionToPointerDecay>
     

109.    |     | `-DeclRefExpr 0x7ff3e390bbe0 <col:9> 'void (id, ...)' Function 0x7ff3e390b748 'NSLog' 'void (id, ...)'
     

111.    |     |-ImplicitCastExpr 0x7ff3e390bd98 <col:15, col:16> 'id':'id' <BitCast>
     

113.    |     | `-ObjCStringLiteral 0x7ff3e390bc60 <col:15, col:16> 'NSString *'
     

115.    |     |   `-StringLiteral 0x7ff3e390bc38 <col:16> 'char [11]' lvalue "%@ rank %d"
     

117.    |     |-ImplicitCastExpr 0x7ff3e390bdb0 <col:29> 'NSString *' <LValueToRValue>
     

119.    |     | `-DeclRefExpr 0x7ff3e390bc80 <col:29> 'NSString *' lvalue Var 0x7ff3e50237b0 'string' 'NSString *'
     

121.    |     `-ImplicitCastExpr 0x7ff3e390bdc8 <col:37> 'int' <LValueToRValue>
     

123.    |       `-DeclRefExpr 0x7ff3e390bcb8 <col:37> 'int' lvalue Var 0x7ff3e390b618 'rank' 'int'
     

125.    `-ReturnStmt 0x7ff3e390be50 <line:21:5, col:12>
     

127.      `-IntegerLiteral 0x7ff3e390be30 <col:12> 'int' 0
     

TranslationUnitDecl 是根节点，表示一个编译单元；Decl 表示一个声明；Expr 表示表达式；Literal 表示字面量，一个特殊的 Expr；Stmt 表示语句。
clang static analyzer
这个阶段重点说一个工具，就是 clang static analyzer。这是一个静态代码分析工具，可用于查找 C、C++和 Objective-C 程序中的 bug。clang static analyzer 包括 analyzer core 和 checker 两部分，所有的 checker 都是基于底层的 analyzer core，通过 analyzer core 提高的功能，能够编写 checker。
每执行一条语句，analyzer core 就会遍历所有 checker 中的回调函数，所以 checker 越多，语句执行速度越慢。通过命令行查看当前 Clang 版本下的 checker：

1. clang -cc1 -analyzer-checker-help

通过编译的这个过程，就可以做很多事情了，比如自定义检查规则、自动混淆代码甚至将代码转换成另一种语言等。
3.生成
LLVM IR
在编译过程中，可以把 Clang 解析出 IR 的过程称为 LLVM Frontend，把 IR 转成目标机器码的过程称为 LLVM Backend。LLVM IR 是 Frontend 的输出，也是 Backend 的输入，前后端的桥接语言。借用一张图说明：

前端 Clang 负责解析，验证和诊断输入代码中的错误，将解析的代码转换为 LLVM IR，后端 LLVM 编译把 IR 通过一系列改进代码的分析和优化，发送到代码生成器，生成本机机器代码。
不管编译的是 Objective-C 或者是 Swift，也不管对应的硬件平台是什么类型的，LLVM 里唯一不变的就是中间语言 LLVM IR，与何种语言开发无关。如果开发一个新语言，只需要在完成语法解析后，通过 LLVM 提高的接口生成 IR，可以直接在各个不同的平台上运行了。
LLVM IR 有三种表示格式：第一种 .bc 后缀，想 Bitcode 的存储格式；第二种是可读的 .ll；第三种是用于开发时操作 IR 的内存格式。在命令行中输入：

1. clang -S -emit-llvm main.m -o main.ll

在这个目录下会看到一个main.ll文件，用 xcode 打开：

1. ; ModuleID = ‘main.m’
3. source_filename = “main.m”
5. target datalayout = “e-m:o-i64:64-f80:128-n8:16:32:64-S128”
7. target triple = “x86_64-apple-macosx10.15.0”
11. %0 = type opaque
13. %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
15. %struct._objc_cache = type opaque
17. %struct._class_ro_t = type { i32, i32, i32, i8*, i8*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._ivar_list_t*, i8*, %struct._prop_list_t* }
19. %struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
21. %struct._objc_method = type { i8*, i8*, i8* }
23. %struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
25. %struct._protocol_t = type { i8*, i8*, %struct._objc_protocol_list*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._prop_list_t*, i32, i32, i8**, i8*, %struct._prop_list_t* }
27. %struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
29. %struct._ivar_t = type { i64*, i8*, i8*, i32, i32 }
31. %struct._prop_list_t = type { i32, i32, [0 x %struct._prop_t] }
33. %struct._prop_t = type { i8*, i8* }
35. %struct.__NSConstantString_tag = type { i32*, i32, i8*, i64 }
39. @“OBJC_CLASS_$_NSString” = external global %struct._class_t
41. @“OBJC_CLASSLIST_REFERENCES_${}_{"}=internalglobal$_NSString”, section “__DATA,__objc_classrefs,regular,no_dead_strip”, align 8
43. @.str = private unnamed_addr constant [6 x i8] c"clang\00", align 1
45. @OBJC_METH_VAR_NAME_ = private unnamed_addr constant [20 x i8] c"initWithUTF8String:\00", section “__TEXT,__objc_methname,cstring_literals”, align 1
47. @OBJC_SELECTOR_REFERENCES_ = internal externally_initialized global i8* getelementptr inbounds ([20 x i8], [20 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), section “__DATA,__objc_selrefs,literal_pointers,no_dead_strip”, align 8
49. @__CFConstantStringClassReference = external global [0 x i32]
51. @.str.1 = private unnamed_addr constant [11 x i8] c"%@ rank %d\00", section “__TEXT,__cstring,cstring_literals”, align 1
53. @unnamed_cfstring = private global %struct.__NSConstantString_tag { i32* getelementptr inbounds ([0 x i32], [0 x i32]* @__CFConstantStringClassReference, i32 0, i32 0), i32 1992, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), i64 10 }, section “__DATA,__cfstring”, align 8 #0
55. @llvm.compiler.used = appending global [3 x i8*] [i8* bitcast (%struct.class_t** @"OBJC_CLASSLIST_REFERENCES$" to i8*), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @OBJC_METH_VAR_NAME, i32 0, i32 0), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_ to i8*)], section “llvm.metadata”
59. ; Function Attrs: noinline optnone ssp uwtable
61. define i32 @main(i32, i8**) #1 {
63. %3 = alloca i32, align 4
65. %4 = alloca i32, align 4
67. %5 = alloca i8**, align 8
69. %6 = alloca i32, align 4
71. %7 = alloca i32, align 4
73. %8 = alloca %0*, align 8
75. %9 = alloca i32, align 4
77. store i32 0, i32* %3, align 4
79. store i32 %0, i32* %4, align 4
81. store i8** %1, i8*** %5, align 8
83. %10 = call i8* @llvm.objc.autoreleasePoolPush() #2
85. store i32 8, i32* %6, align 4
87. store i32 6, i32* %7, align 4
89. %11 = load %struct.class_t*, %struct.class_t** @"OBJC_CLASSLIST_REFERENCES$", align 8
91. %12 = bitcast %struct._class_t* %11 to i8*
93. %13 = call i8* @objc_alloc(i8* %12)
95. %14 = bitcast i8* %13 to %0*
97. %15 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_, align 8, !invariant.load !9
99. %16 = bitcast %0* %14 to i8*

101.  %17 = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* %16, i8* %15, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
     

103.  %18 = bitcast i8* %17 to %0*
     

105.  store %0* %18, %0** %8, align 8
     

107.  %19 = load i32, i32* %6, align 4
     

109.  + = load i32, i32* %7, align 4
     

111.  %21 = add nsw i32 %19, +
     

113.  store i32 %21, i32* %9, align 4
     

115.  %22 = load %0*, %0** %8, align 8
     

117.  %23 = load i32, i32* %9, align 4
     

119.  notail call void (i8*, ...) @NSLog(i8* bitcast (%struct.__NSConstantString_tag* @_unnamed_cfstring_ to i8*), %0* %22, i32 %23)
     

121.  call void @llvm.objc.autoreleasePoolPop(i8* %10)
     

123.  ret i32 0
     

125. }
129. ; Function Attrs: nounwind
131. declare i8* @llvm.objc.autoreleasePoolPush() #2
135. declare i8* @objc_alloc(i8*)
139. ; Function Attrs: nonlazybind
141. declare i8* @objc_msgSend(i8*, i8*, …) #3
145. declare void @NSLog(i8*, …) #4
149. ; Function Attrs: nounwind
151. declare void @llvm.objc.autoreleasePoolPop(i8*) #2
155. attributes #0 = { “objc_arc_inert” }
157. attributes #1 = { noinline optnone ssp uwtable “correctly-rounded-divide-sqrt-fp-math”=“false” “darwin-stkchk-strong-link” “disable-tail-calls”=“false” “frame-pointer”=“all” “less-precise-fpmad”=“false” “min-legal-vector-width”=“0” “no-infs-fp-math”=“false” “no-jump-tables”=“false” “no-nans-fp-math”=“false” “no-signed-zeros-fp-math”=“false” “no-trapping-math”=“false” “probe-stack”="___chkstk_darwin" “stack-protector-buffer-size”=“8” “target-cpu”=“penryn” “target-features”="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" “unsafe-fp-math”=“false” “use-soft-float”=“false” }
159. attributes #2 = { nounwind }
161. attributes #3 = { nonlazybind }
163. attributes #4 = { “correctly-rounded-divide-sqrt-fp-math”=“false” “darwin-stkchk-strong-link” “disable-tail-calls”=“false” “frame-pointer”=“all” “less-precise-fpmad”=“false” “no-infs-fp-math”=“false” “no-nans-fp-math”=“false” “no-signed-zeros-fp-math”=“false” “no-trapping-math”=“false” “probe-stack”="___chkstk_darwin" “stack-protector-buffer-size”=“8” “target-cpu”=“penryn” “target-features”="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" “unsafe-fp-math”=“false” “use-soft-float”=“false” }
167. !llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6, !7}
169. !llvm.ident = !{!8}
173. !0 = !{i32 2, !“SDK Version”, [3 x i32] [i32 10, i32 15, i32 4]}
175. !1 = !{i32 1, !“Objective-C Version”, i32 2}
177. !2 = !{i32 1, !“Objective-C Image Info Version”, i32 0}
179. !3 = !{i32 1, !“Objective-C Image Info Section”, !"__DATA,__objc_imageinfo,regular,no_dead_strip"}
181. !4 = !{i32 4, !“Objective-C Garbage Collection”, i32 0}
183. !5 = !{i32 1, !“Objective-C Class Properties”, i32 64}
185. !6 = !{i32 1, !“wchar_size”, i32 4}
187. !7 = !{i32 7, !“PIC Level”, i32 2}
189. !8 = !{!“Apple clang version 11.0.3 (clang-1103.0.32.29)”}
191. !9 = !{}

LLVM IR 的指令介绍：
? %：局部变量
? @：全局变量
? alloca：为当前执行的函数分配内存，当该函数执行完毕时自动释放内存
? i32：整数占位，i32 就代办 32 位
? align：对齐，向 4 个字节对齐，即便数据没有占用 4 个字节，也要为其分配 4 个字节
? load：读出
? store：写入
? icmp：两个整数值比较，返回布尔值
? br：选择分支，根据条件跳转对应的 label
? label：代码标签
? call：调用
LLVM Backend
完整的 LLVM Backend 阶段称为 CodeGen，整个过程可以分成以下几个阶段：
? Instruction Selection：指令选择，将 IR 转化成由目标平台指令组成的 DAG，选择能完成指定操作，执行时间最短的指令；
? Scheduling and Formation：调度与排序，读取 DAG，将 DAG 的指令排成 MachineInstr 队列。根据指令间的依赖进行指令重排，更好地利用 CPU 的功能单元；
? SSA 优化：由多个基于 SSA 的 Pass 组成；
? Register allocation：寄存器分配，将 Virtual Register 映射到 Physical Register 或者内存地址上；
? Prolog/Epilo 的生成：函数体指令生成后，可以确定函数所需要的堆栈大小了；
? Machine Code：机器码晚期优化，这是最后一次进行优化的机会；
? Code Emission：代码发射，输出代码，可以选择输出汇编程序或二进制机器码；
三、编译完成生成的文件
编译完成后，生成一些文件，主要介绍三种：
? 二进制内容 Link Map File
? dSYM 文件
? Mach-O
Link Map File
Link Map FIle 文件内容包含三个部分：
? Object file：.m 文件编译后的 .o 文件和需要连接的 .a 文件，包括文件编号和文件路径；
? Section：描述每个 Section 在可执行文件中的位置和大小；
? Symbol：Symbol 对 Section 进行了再划分，描述了method、ivar、string，以及对应的 address、size 和 file number 信息；
可以在 Build Settings 中查看路径，如下图：

如果使用二进制重排提升 APP 的启动速度，用到 Link Map File 了，参考链接：https://juejin.cn/post/6844904130406793224。
dSYM 文件
dSYM 文件里面存储了函数地址映射的信息，调用栈的地址，可以通过 dSYM 映射表获得具体的函数信息。通常可以做 crash 的文件符号化，将 crash 时保存的调用栈信息转化为相应的函数。这就是为什么友盟或者 bugly，都需要上传 dSYM 文件的原因。
Mach-O
Mach-O 文件是用于记录编译后的可执行文件、对象代码、共享库、动态加载代码和内存转储的文件格式。Mach-O 里面的 _CodeSignature 包含了程序代码的签名，保证里面的文件不能直接更改。如果用过企业版重签名的功能，其实还是有些东西可以改的，只不过改完后，要重新生成签名文件。
Mach-O 文件，主要包含三个部分：
? Mach-O Header：包含字节顺序、魔数、CPU 类型、加载指令的数量等；
? Load Command：包括区域的位置、符号表、动态符号表等。每个加载指令包含一个元信息，比如指令类型、名称以及在二进制中的位置等；
? Data：内容最多的部分，包含了代码、数据。比如符号表、动态符号表等；
四、小结
接下来来归纳一下：

1. iOS 使用编译器而不是解释器来处理代码，为了获得更快的运行速度；
2. iOS 的编译过程是通过 LLVM 编译工具生成语法树 AST，把 AST 转换成 IR，最后把 IR 生成平台的机器码。
3. 编译成功生成的几个文件 Link Map File、dSYM 和 Mach-O。
   Clang 代码规范检查插件
   ? Clang 代码规范检查插件
   o 什么是 LLVM 和 Clang
   o 自定义插件
   o 下载编译 LLVM
   o 自定义插件开发
   o 1.新增开发工程
   o 2.功能开发
   o Xcode 运行
   o 1. 添加 Plugin 路径
   o 2. 添加 Clang 路径
   o 3. 关闭索引建立
   o 问题
   ? 引用：
   Clang 代码规范检查插件
   使用 LLVM 和 Clang，写一个代码规范检查插件。
   什么是 LLVM 和 Clang
   LLVM 是一个模块化和可重用的编译器和工具链技术的集合，其实是一个代码工程名。早期说到 LLVM 其实是指它的核心库，可以对源码进行平台无关的优化，生成不同平台的机器码。现在LLVM指整个工具链技术集合。
   LLVM 工程包含核心库、Clang、LLDB、LLD 等相关项目。Clang 就是 LLVM 的一个子项目，包括 C，C++ 和 Objective-C 的编译器，可以提供惊人的快速编译，比 GCC 快 3 倍。clang static analyzer 主要是进行语法分析，语义分析和生成中间代码。在语义分析阶段，对语法树进行代码静态分析，在静态分析过程中，能加上代码规范检查了。
   
   
   
   

自定义插件
Clang 插件制作步骤如下：

1. 下载 LLVM ，生成 Xcode 工程，编译项目
2. 新增 Clang 插件，自定义插件开发，编译出 dylib
3. Xcode 添加编译设置，接入插件
   下载编译 LLVM
   先下载 LLVM 工程，在本地新建一个文件夹 LLVM，打开命令行 cd 到该目录下，输入命令：
4. git clone https://github.com/llvm/llvm-project.git
6. cd llvm-project
8. mkdir build
10. cd build
12. cmake -G Xcode -DLLVM_ENABLE_PROJECTS=clang …/llvm

其中 cmake -G Xcode -DLLVM_ENABLE_PROJECTS=clang …/llvm ，生成 LLVM 的 Xcode 编译工程，可以看到本地目录如下：

目录中 clang 是类 C 语言编译器的代码目录；llvm 目录的代码包含两部分，一部分是对源码进行平台无关优化的优化器代码，另一部分是生成平台相关汇编代码的生成器代码；lldb 目录里是调试器的代码；lld 里是链接器代码。
编译工程，双击打开 LLVM.Xcodeproj ，选择 Autocreat Schemes，添加 schemes All_BUILD：

点击 Running，等待编译完成，预计要大半个小时：

编译完成后，可以在目录下看到 Clang 的可执行文件：

这里 clang 和 clang++ 这两个文件的路径记下来，后面会用到。
由于 Xcode 自带的 clang 可能跟工程编译出来的版本不同，在使用自定义插件时，最好把 clang 依赖改成编译出来的版本。
自定义插件开发
1.新增开发工程
接下来开始开发插件，先在 llvm-project — clang — tools 目录下新建一个文件夹 CodeStandardsPlugin，在文件夹里面新建两个文件：CMakeLists.txt 和 CodeStandardsPlugin.cpp。
这里的 CodeStandardsPlugin 表示插件名称，可以自主命名，后续所有用到 CodeStandardsPlugin，都用命名替换即可。

在 llvm-project — clang — tools — CMakeLists.txt 文件的末尾，添加一行代码：

1. add_clang_subdirectory(CodeStandardsPlugin)

重新生成 LLVM 编译工程，在终端运行：

1. cmake -G Xcode -DLLVM_ENABLE_PROJECTS=clang …/llvm

重新打开 LLVM.xcodeproj ，按照下图点击 + 号，输入 CodeStandardsPlugin，可以添加自定义的 scheme 了。

在工程文件列表中，搜索 CodeStandardsPlugin，可以看到新建的两个文件：

2.功能开发
在 CodeStandardsPlugin/CMakeLists.txt 中，添加如下代码：

1. add_llvm_library(CodeStandardsPlugin MODULE CodeStandardsPlugin.cpp PLUGIN_TOOL clang)
5. if(LLVM_ENABLE_PLUGINS AND (WIN32 OR CYGWIN))
7. target_link_libraries(CodeStandardsPlugin PRIVATE

9.  clangAST
   

11. clangBasic
    

13. clangFrontend
    

15. LLVMSupport
    

17. )
    

19. endif()

CodeStandardsPlugin.cpp 文件，用来存放开发代码的，源码已经放在https://github.com/YakirLove/CodeStandardsPlugin/blob/master/CodeStandardsPlugin.cpp。
运行工程，在 Products 中，可以看到打包出来的执行文件：

找到 CodeStandardsPlugin.dylib ，拷贝出来，或者绝对路径记录下来。
Xcode 运行
在 Xcode 上运行自定义的编译插件，需要用到 XcodeHacking 这个工具来 hook Xcode。不过现在已经不需要那么麻烦了，在 Xcode10后，只需要添加几个编译配置。

1. 添加 Plugin 路径
   在 Targets — Build Setting — AppleClang-Custom Compiler Flags — Other C Flags 中，添加如下语句：
2. -Xclang -load -Xclang （插件 dylib 绝对路径）-Xclang -add-plugin -Xclang （ Plugin 名字）

示例如下：

1. -Xclang -load -Xclang /Users/wuyanji/Desktop/YourClang/CodeStandardsPlugin.dylib -Xclang -add-plugin -Xclang CodeStandardsPlugin

最后，可以看到结果如下图所示：

2. 添加 Clang 路径
   插件需要相应的 Clang 版本加载，需要添加依赖的 Clang 路径，在 Xcode 中新增两项自定义设置，分别为 CC 和 CCX：
   

第一步 llvm 编译后得到的 clang 和 clang++路径，就是用在这里的。CC 表示 clang 路径，CCX 表示 clang++ 路径。
3. 关闭索引建立
编译可能会遇到问题：

可以通过关闭编译建立索引，解决这个问题，将 Index-Wihle-Building Functionality 设置为 NO

编译工程，可以看到结果如下：

问题
由于将 Index-Wihle-Building Functionality 设置为 NO 了，导致 Xcode 的自动补全功能和代码颜色提醒失效，目前没有太好的解决办法。也许可以将插件做成工具形式，需要时再执行。
https://github.com/YakirLove/CodeStandardsPlugin/tree/master
参考链接：
https://xiaozhuanlan.com/topic/4352601789
https://xiaozhuanlan.com/topic/8960517324