首页 > 其他分享> > LLVM Clang前端编译与调试

LLVM Clang前端编译与调试

2021-10-17 08:34:12 作者：互联网

LLVM Clang前端编译与调试

iOS 关于编译

技术学习有两种方向，一种是不断向前，了解前沿和趋势；另一种是不断向下，理解通用的底层技术和设计思想。这两种方法没有优劣之分，更应该是一种不断交替使用的方式。

编译器相关的内容，在不断学习底层知识的过程中梳理一下内容。

一、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 步：

预处理：编译开始时，LLVM 会预处理代码，比如宏替换、头文件导入；
编译：预处理完后，LLVM 会对代码进行词法分析和语法分析(Clang)，生成 AST。AST是抽象语法树，结构上比代码更精简，遍历更快，使用 AST 能够更快速地进行静态检查，更快地生成 IR。
生成：最后 AST 会生成 IR，IR 是一种更接近机器码的语言，区别在于和平台无关，通过 IR 可以生成多份适合不同平台的机器码。对于 iOS 系统，IR 生成的可执行文件就是 Mach-O。

用代码来详细解释一下这 3 个过程。

二、编译步骤的详细说明

1.预处理

新建一个工程，在 mian 中写出如下代码：

#import <Foundation/Foundation.h>
#define DefineEight 8
int main(int argc, char * argv[]) {
@autoreleasepool {
int i = DefineEight;
10.
11. int j = 6;
12.
13. NSString *string = [[NSString alloc] initWithUTF8String:"clang"];
14.
15. int rank = i + j;
16.
17. NSLog(@"%@ rank %d",string, rank);
18.
19. }
20.
21. return 0;
22.

23. }

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

clang -E main.m

执行之后控制台输出：

# 1 "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/Foundation.framework/Headers/FoundationLegacySwiftCompatibility.h" 1 3
# 193 "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h" 2 3
# 10 "main.m" 2
int main(int argc, char * argv[]) {
10.
11. @autoreleasepool {
12.
13. int i = 8;
14.
15. int j = 6;
16.
17. NSString *string = [[NSString alloc] initWithUTF8String:"clang"];
18.
19. int rank = i + j;
20.
21. NSLog(@"%@ rank %d",string, rank);
22.
23. }
24.
25. return 0;
26.

27. }

宏已经替换修改，头文件引入变成了相关文件地址。

2.编译

词法分析

编译阶段，Clang先进行词法分析，在命令行输入：

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

打印信息如下：

annot_module_include '#import <Foundation/Foundation.h>
#define DefineEight 8
int main(int argc, char * argv[]) {
10.
11. @autoreleasepool {
12.
13. int i = DefineEight;
14.
15. int' Loc=<main.m:9:1>
16.

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>

equal '=' [LeadingSpace] Loc=<main.m:18:18>
identifier 'i' [LeadingSpace] Loc=<main.m:18:20>
plus '+' [LeadingSpace] Loc=<main.m:18:22>
identifier 'j' [LeadingSpace] Loc=<main.m:18:24>
semi ';' Loc=<main.m:18:25>
identifier 'NSLog' [StartOfLine] [LeadingSpace] Loc=<main.m:19:9>
l_paren '(' Loc=<main.m:19:14>
at '@' Loc=<main.m:19:15>
string_literal '"%@ rank %d"' Loc=<main.m:19:16>
comma ',' Loc=<main.m:19:28>
identifier 'string' Loc=<main.m:19:29>
comma ',' Loc=<main.m:19:35>
identifier 'rank' [LeadingSpace] Loc=<main.m:19:37>
r_paren ')' Loc=<main.m:19:41>
semi ';' Loc=<main.m:19:42>
r_brace '}' [StartOfLine] [LeadingSpace] Loc=<main.m:20:5>
return 'return' [StartOfLine] [LeadingSpace] Loc=<main.m:21:5>
numeric_constant '0' [LeadingSpace] Loc=<main.m:21:12>
semi ';' Loc=<main.m:21:13>
r_brace '}' [StartOfLine] Loc=<main.m:22:1>
eof '' Loc=<main.m:22:2>

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

关键字：语法中的关键字，比如 if、else、while、for 等；
标识符：变量名；
字面量：值、数字、字符串；

特殊符号：加减乘除等符号；
所有的 Token 类型可以查看https://opensource.apple.com//source/lldb/lldb-69/llvm/tools/clang/include/clang/Basic/TokenKinds.def。

语法分析

词法分析完成后，进行语法分析，验证语法是否正确，将输出的 Token 先按照语法组合成语义生成节点，将这些节点按照层级关系组成抽象语法树（AST）。
在命令行中输入：

clang -fmodules -fsyntax-only -Xclang -ast-dump main.m

输出信息如下：

TranslationUnitDecl 0x7ff3e4015608 <<invalid sloc>> <invalid sloc> <undeserialized declarations>
|-TypedefDecl 0x7ff3e4015ea0 <<invalid sloc>> <invalid sloc> implicit __int128_t '__int128'
| `-BuiltinType 0x7ff3e4015ba0 '__int128'
|-TypedefDecl 0x7ff3e4015f10 <<invalid sloc>> <invalid sloc> implicit __uint128_t 'unsigned __int128'
| `-BuiltinType 0x7ff3e4015bc0 'unsigned __int128'
10.

11. |-TypedefDecl 0x7ff3e4015fb0 <<invalid sloc>> <invalid sloc> implicit SEL 'SEL *'

13. | `-PointerType 0x7ff3e4015f70 'SEL *' imported

15. | `-BuiltinType 0x7ff3e4015e00 'SEL'

17. |-TypedefDecl 0x7ff3e4016098 <<invalid sloc>> <invalid sloc> implicit id 'id'

19. | `-ObjCObjectPointerType 0x7ff3e4016040 'id' imported

21. | `-ObjCObjectType 0x7ff3e4016010 'id' imported

23. |-TypedefDecl 0x7ff3e4016178 <<invalid sloc>> <invalid sloc> implicit Class 'Class'

25. | `-ObjCObjectPointerType 0x7ff3e4016120 'Class' imported

27. | `-ObjCObjectType 0x7ff3e40160f0 'Class' imported

29. |-ObjCInterfaceDecl 0x7ff3e40161d0 <<invalid sloc>> <invalid sloc> implicit Protocol

31. |-TypedefDecl 0x7ff3e4016548 <<invalid sloc>> <invalid sloc> implicit __NSConstantString 'struct __NSConstantString_tag'

33. | `-RecordType 0x7ff3e4016340 'struct __NSConstantString_tag'

35. | `-Record 0x7ff3e40162a0 '__NSConstantString_tag'

37. |-TypedefDecl 0x7ff3e4052c00 <<invalid sloc>> <invalid sloc> implicit __builtin_ms_va_list 'char *'

39. | `-PointerType 0x7ff3e40165a0 'char *'

41. | `-BuiltinType 0x7ff3e40156a0 'char'

43. |-TypedefDecl 0x7ff3e4052ee8 <<invalid sloc>> <invalid sloc> 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 **)'

54.
55. |-ParmVarDecl 0x7ff3e42ce7d0 <col:10, col:14> col:14 argc 'int'
56.
57. |-ParmVarDecl 0x7ff3e42ce8f0 <col:20, col:32> col:27 argv 'char **':'char **'
58.
59. `-CompoundStmt 0x7ff3e390be60 <col:35, line:22:1>
60.
61. |-ObjCAutoreleasePoolStmt 0x7ff3e390be18 <line:14:5, line:20:5>
62.
63. | `-CompoundStmt 0x7ff3e390bde0 <line:14:22, line:20:5>
64.
65. | |-DeclStmt 0x7ff3e42cebf0 <line:15:9, col:28>
66.
67. | | `-VarDecl 0x7ff3e42ceb68 <col:9, line:10:22> line:15:13 used i 'int' cinit
68.
69. | | `-IntegerLiteral 0x7ff3e42cebd0 <line:10:22> 'int' 8
70.
71. | |-DeclStmt 0x7ff3e5023750 <line:16:9, col:18>
72.
73. | | `-VarDecl 0x7ff3e42cec20 <col:9, col:17> col:13 used j 'int' cinit
74.
75. | | `-IntegerLiteral 0x7ff3e42cec88 <col:17> 'int' 6
76.
77. | |-DeclStmt 0x7ff3e390b5e8 <line:17:9, col:73>
78.
79. | | `-VarDecl 0x7ff3e50237b0 <col:9, col:72> col:19 used string 'NSString *' cinit
80.
81. | | `-ObjCMessageExpr 0x7ff3e3820390 <col:28, col:72> 'NSString * _Nullable':'NSString *' selector=initWithUTF8String:
82.
83. | | |-ObjCMessageExpr 0x7ff3e5023b98 <col:29, col:44> 'NSString *' selector=alloc class='NSString'
84.
85. | | `-ImplicitCastExpr 0x7ff3e3820378 <col:65> 'const char * _Nonnull':'const char *' <NoOp>
86.
87. | | `-ImplicitCastExpr 0x7ff3e3820360 <col:65> 'char *' <ArrayToPointerDecay>
88.
89. | | `-StringLiteral 0x7ff3e5023c08 <col:65> 'char [6]' lvalue "clang"
90.
91. | |-DeclStmt 0x7ff3e390bbc8 <line:18:9, col:25>
92.
93. | | `-VarDecl 0x7ff3e390b618 <col:9, col:24> col:13 used rank 'int' cinit
94.
95. | | `-BinaryOperator 0x7ff3e390b720 <col:20, col:24> 'int' '+'
96.
97. | | |-ImplicitCastExpr 0x7ff3e390b6f0 <col:20> 'int' <LValueToRValue>
98.
99. | | | `-DeclRefExpr 0x7ff3e390b680 <col:20> 'int' lvalue Var 0x7ff3e42ceb68 'i' 'int'
| | `-ImplicitCastExpr 0x7ff3e390b708 <col:24> 'int' <LValueToRValue>
| | `-DeclRefExpr 0x7ff3e390b6b8 <col:24> 'int' lvalue Var 0x7ff3e42cec20 'j' 'int'
| `-CallExpr 0x7ff3e390bd60 <line:19:9, col:41> 'void'
| |-ImplicitCastExpr 0x7ff3e390bd48 <col:9> 'void (*)(id, ...)' <FunctionToPointerDecay>
| | `-DeclRefExpr 0x7ff3e390bbe0 <col:9> 'void (id, ...)' Function 0x7ff3e390b748 'NSLog' 'void (id, ...)'
| |-ImplicitCastExpr 0x7ff3e390bd98 <col:15, col:16> 'id':'id' <BitCast>
| | `-ObjCStringLiteral 0x7ff3e390bc60 <col:15, col:16> 'NSString *'
| | `-StringLiteral 0x7ff3e390bc38 <col:16> 'char [11]' lvalue "%@ rank %d"
| |-ImplicitCastExpr 0x7ff3e390bdb0 <col:29> 'NSString *' <LValueToRValue>
| | `-DeclRefExpr 0x7ff3e390bc80 <col:29> 'NSString *' lvalue Var 0x7ff3e50237b0 'string' 'NSString *'
| `-ImplicitCastExpr 0x7ff3e390bdc8 <col:37> 'int' <LValueToRValue>
| `-DeclRefExpr 0x7ff3e390bcb8 <col:37> 'int' lvalue Var 0x7ff3e390b618 'rank' 'int'
`-ReturnStmt 0x7ff3e390be50 <line:21:5, col:12>
`-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：

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 的内存格式。在命令行中输入：

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

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

; ModuleID = 'main.m'
source_filename = "main.m"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"
10.

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_$_" = internal global %struct._class_t* @"OBJC_CLASS_$_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 {

62.
63. %3 = alloca i32, align 4
64.
65. %4 = alloca i32, align 4
66.
67. %5 = alloca i8**, align 8
68.
69. %6 = alloca i32, align 4
70.
71. %7 = alloca i32, align 4
72.
73. %8 = alloca %0*, align 8
74.
75. %9 = alloca i32, align 4
76.
77. store i32 0, i32* %3, align 4
78.
79. store i32 %0, i32* %4, align 4
80.
81. store i8** %1, i8*** %5, align 8
82.
83. %10 = call i8* @llvm.objc.autoreleasePoolPush() #2
84.
85. store i32 8, i32* %6, align 4
86.
87. store i32 6, i32* %7, align 4
88.
89. %11 = load %struct._class_t*, %struct._class_t** @"OBJC_CLASSLIST_REFERENCES_$_", align 8
90.
91. %12 = bitcast %struct._class_t* %11 to i8*
92.
93. %13 = call i8* @objc_alloc(i8* %12)
94.
95. %14 = bitcast i8* %13 to %0*
96.
97. %15 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_, align 8, !invariant.load !9
98.
99. %16 = bitcast %0* %14 to i8*
%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))
%18 = bitcast i8* %17 to %0*
store %0* %18, %0** %8, align 8
%19 = load i32, i32* %6, align 4
+ = load i32, i32* %7, align 4
%21 = add nsw i32 %19, +
store i32 %21, i32* %9, align 4
%22 = load %0*, %0** %8, align 8
%23 = load i32, i32* %9, align 4
notail call void (i8*, ...) @NSLog(i8* bitcast (%struct.__NSConstantString_tag* @_unnamed_cfstring_ to i8*), %0* %22, i32 %23)
call void @llvm.objc.autoreleasePoolPop(i8* %10)
ret i32 0
}
; Function Attrs: nounwind
declare i8* @llvm.objc.autoreleasePoolPush() #2
declare i8* @objc_alloc(i8*)
; Function Attrs: nonlazybind
declare i8* @objc_msgSend(i8*, i8*, ...) #3
declare void @NSLog(i8*, ...) #4
; Function Attrs: nounwind
declare void @llvm.objc.autoreleasePoolPop(i8*) #2
attributes #0 = { "objc_arc_inert" }
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" }
attributes #2 = { nounwind }
attributes #3 = { nonlazybind }
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" }
!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6, !7}
!llvm.ident = !{!8}
!0 = !{i32 2, !"SDK Version", [3 x i32] [i32 10, i32 15, i32 4]}
!1 = !{i32 1, !"Objective-C Version", i32 2}
!2 = !{i32 1, !"Objective-C Image Info Version", i32 0}
!3 = !{i32 1, !"Objective-C Image Info Section", !"__DATA,__objc_imageinfo,regular,no_dead_strip"}
!4 = !{i32 4, !"Objective-C Garbage Collection", i32 0}
!5 = !{i32 1, !"Objective-C Class Properties", i32 64}
!6 = !{i32 1, !"wchar_size", i32 4}
!7 = !{i32 7, !"PIC Level", i32 2}
!8 = !{!"Apple clang version 11.0.3 (clang-1103.0.32.29)"}
!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：内容最多的部分，包含了代码、数据。比如符号表、动态符号表等；

四、小结

接下来来归纳一下：

iOS 使用编译器而不是解释器来处理代码，为了获得更快的运行速度；
iOS 的编译过程是通过 LLVM 编译工具生成语法树 AST，把 AST 转换成 IR，最后把 IR 生成平台的机器码。
编译成功生成的几个文件 Link Map File、dSYM 和 Mach-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 插件制作步骤如下：

下载 LLVM ，生成 Xcode 工程，编译项目
新增 Clang 插件，自定义插件开发，编译出 dylib
Xcode 添加编译设置，接入插件

下载编译 LLVM

先下载 LLVM 工程，在本地新建一个文件夹 LLVM，打开命令行 cd 到该目录下，输入命令：

git clone https://github.com/llvm/llvm-project.git
cd llvm-project
mkdir build
cd build
cmake -G Xcode -DLLVM_ENABLE_PROJECTS=clang ../llvm
10.

其中 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 文件的末尾，添加一行代码：

add_clang_subdirectory(CodeStandardsPlugin)

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

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

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

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

2.功能开发

在 CodeStandardsPlugin/CMakeLists.txt 中，添加如下代码：

add_llvm_library(CodeStandardsPlugin MODULE CodeStandardsPlugin.cpp PLUGIN_TOOL clang)
if(LLVM_ENABLE_PLUGINS AND (WIN32 OR CYGWIN))
target_link_libraries(CodeStandardsPlugin PRIVATE
clangAST
10.
11. clangBasic
12.
13. clangFrontend
14.
15. LLVMSupport
16.
17. )
18.

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 中，添加如下语句：

-Xclang -load -Xclang （插件 dylib 绝对路径）-Xclang -add-plugin -Xclang （ Plugin 名字）

示例如下：

-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

标签：i8,LLVM,struct,Loc,i32,Clang,编译
来源： https://www.cnblogs.com/wujianming-110117/p/15415877.html