一：编译器

计算机是不能理解高级语言的，更不能直接执行高级语言，它只能直接理解机器语言，所以使用任何高级语言编写的程序若想被计算机运行，都必须将其转换成计算机语言，也就是机器码，而这种转换都是需要编译器来完成的，但是转换的方式有两种：解释和编译。因此高级语言也分为编译型语言和解释型语言。

什么是编译器？

简单讲，编译器就是将“一种语言（通常为高级语言）”翻译为”另一种语言（通常为低级语言的程序。一个现代编译器的主要工作流程：源代码 (source code) → 预处理器 (preprocessor) → 编译器 (compiler) →  目标代码(object code) → 链接器(Linker) → 可执行程序(executables)。

编译型语言

编译型语言需要转换成二进制指令，也就是我们常说的可执行文件。这种编程语言称为编译型语言，使用的转换工具称为编译器，比如C语言、C++、OC等。

整个过程如下图：

下面我们使用一段示例代码来看下

终端执行以下命令，创建.c文件

vi testDemo.c

.c文件代码如下

#include <stdio.h>

int main(int a,char *argv[]){

    printf("我来了\n");

    return 0;

}

编辑完成后，按ESC,输入:x进行保存。

执行如下命令,生成a.out可执行文件

clang testDemo.c

使用如下命令可以查看a.out

file a.out

终端输出 a.out: Mach-O 64-bit executable arm64：可执行文件

执行如下命令后输出我来了

./a.out

编译型语言是先编译，再执行

解释型语言

解释型语言可以一边执行一边转换，不会生成可执行文件再去执行，这种编程语言称为解释型语言，使用的转换工具称为解释器，比如 Python、JavaScript、PHP等。

下面我们使用一段示例代码来看下 终端依次执行以下命令，创建testPython.py文件

mkdir Python
cd Python/
vi testPython.py

testPython.py代码如下

print("我来了\n")

执行

python testPython.py

python是Python的解释器

解释型语言，它是边解释边执行，不可脱离解释器环境运行

二：LLVM

LLVM简介

LLVM是构架编译器(compiler)的框架系统，以C++编写而成，用于优化以任意程序语言编写的程序的编译时间(compile-time)、链接时间(link-time)、运行时间(run-time)以及空闲时间(idle-time)，对开发者保持开放，并兼容已有脚本。

LLVM计划启动于2000年，最初由美国UIUC大学的 ChrisLattner博士主持开展。2006年ChrisLattner加盟AppleInc并致力于LLVM在Apple开发体系中的应用。 Apple也是LLVM计划的主要资助者。目前LLVM已经被苹果IOS开发工具、Xilinx Vivado、Facebook、Google等各大公司采用。

传统编辑器设计

传统流程如下：

编译器前端(Frontend) 编译器前端的任务是解析源代码。它会进行:词法分析，语法分析，语义分析，检查源代码是否存在错误，然后构建抽象语法树(Abstract Syntax Tree, AST)，LLVM的前端还会生成中间代码(intermediate representation，IR)，这是LLVM独有的。

优化器(Optimizer) 优化器负责进行各种优化，改善代码的运行时间，例如消除冗余计算等。

后端(Backend)/代码生成器(CodeGenerator) 将代码映射到目标指令集，生成机器语言，并且进行机器相关的代码优化。

iOS的编译器架构

ObjectiveC/C/C++使用的编译器前端是Clang，Swift是Swift，后端都是LLVM。

LLVM的设计

其他的编译器如GCC是非常成功的一款编译器，苹果早期使用的编译器也是GCC,但由于它是作为整体应用程序设计的，因此它的用途受到了很大的限制。

LLVM设计的最重要方面是，使用通用的代码表示形式(IR)，它是用来在编译器中表示代码的形式。所以LLVM可以为任何编程语言独立编写前端，并且可以为任意硬件架构独立编写后端。

Clang

平时我们接触最多的就是我们的Clang，前面也有过通过clang，将代码转化为C++文件的操作。

Clang是LLVM项目中的一个子项目。它是基于LLVM架构的轻量级编译器，诞生之初是为了替代GCC，提供更快的编译速度。它是负责编译C、C++、Objecte- C语言的编译器，它属于整个LLVM架构中的，编译器前端。对于开发者来说，研究Clang可以给我们带来很多好处。

三：编译流程

创建工程

打印源码的编译阶段

clang -ccc-print-phases

共七个阶段

• 0:输入文件:找到源文件。

• 1:预处理阶段:这个过程处理包括宏的替换，头文件的导入。

• 2:编译阶段:进行词法分析、语法分析、检测语法是否正确，最终生成IR。

• 3:后端:这里LLVM会通过一个一个的Pass(可以理解为一个节点)去优化，每个Pass做一些事情，最终生成汇编代码。

• 4:汇编代码生成目标文件。

• 5:链接:链接需要的动态库和静态库，生成相应的image(镜像)可执行文件。

• 6:根据不同的系统架构，生成对应的可执行文件。

预处理阶段

终端执行clang -E main.m，可以看到头文件导入和宏的替换,终端打印很多东西，我们使用clang -E main.m >> main1.m来看看。

我们发现在预处理阶段，#define定义的宏已经被替换成30，而使用typedef定义的别名却没有被替换，因此两者存在一定的差异。出于安全方面的考虑，我们可以使用#define。

使用define和typedef的区别：

• define：宏定义，在预处理阶段会被替换：

  • 可用来做代码混淆，将App中核心代码，用系统相似的名称进行取别名，然后在预处理阶段就被替换，以此达到代码混淆的目的。

• typedef：对数据类型取别名，在预处理阶段不会被替换掉。

比如实际工程中的方法名称叫test,此时可以如下定义，在预处理阶段就被替换成mixupMethod

#define test mixupMethod

编译阶段

编译阶段可划分为三个部分：

• 词法分析；
• 语法分析；
• 生成IR中间代码。

词法分析

预处理完成后就会进行词法分析，这里会把代码切成一个个Token，比如大小括号，等于号还有字符串等。

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

annot_module_include '#import <stdio.h>

#define P 30

typedef int Int_type;

int main(int argc, const char * a' Loc=<main.m:8:1>

typedef 'typedef' [StartOfLine] Loc=<main.m:10:1>

int 'int' [LeadingSpace] Loc=<main.m:10:9>

identifier 'Int_type' [LeadingSpace] Loc=<main.m:10:13>

semi ';' Loc=<main.m:10:21>

int 'int' [StartOfLine] Loc=<main.m:12:1>

identifier 'main' [LeadingSpace] Loc=<main.m:12:5>

l_paren '(' Loc=<main.m:12:9>

int 'int' Loc=<main.m:12:10>

identifier 'argc' [LeadingSpace] Loc=<main.m:12:14>

comma ',' Loc=<main.m:12:18>

const 'const' [LeadingSpace] Loc=<main.m:12:20>

char 'char' [LeadingSpace] Loc=<main.m:12:26>

star '*' [LeadingSpace] Loc=<main.m:12:31>

identifier 'argv' [LeadingSpace] Loc=<main.m:12:33>

l_square '[' Loc=<main.m:12:37>

r_square ']' Loc=<main.m:12:38>

r_paren ')' Loc=<main.m:12:39>

l_brace '{' [LeadingSpace] Loc=<main.m:12:41>

at '@' [StartOfLine] [LeadingSpace] Loc=<main.m:13:5>

identifier 'autoreleasepool' Loc=<main.m:13:6>

l_brace '{' [LeadingSpace] Loc=<main.m:13:22>

identifier 'Int_type' [StartOfLine] [LeadingSpace] Loc=<main.m:14:9>

identifier 'a' [LeadingSpace] Loc=<main.m:14:18>

equal '=' [LeadingSpace] Loc=<main.m:14:20>

numeric_constant '10' [LeadingSpace] Loc=<main.m:14:22>

semi ';' Loc=<main.m:14:24>

identifier 'Int_type' [StartOfLine] [LeadingSpace] Loc=<main.m:15:9>

identifier 'b' [LeadingSpace] Loc=<main.m:15:18>

equal '=' [LeadingSpace] Loc=<main.m:15:20>

numeric_constant '20' [LeadingSpace] Loc=<main.m:15:22>

...... 🌹 省略

可以看到每一行的代码都分开了

语法分析

词法分析完成之后就是语法分析，它的任务是验证语法是否正确。在词法分析的基础上将单词序列组合成各类语法短语，如“程序”，“语句”，“表达式”等等，然后将所有节点组成抽象语法树(AbstractSyntaxTree，AST)。语法分析其目的就是对源程序进行分析判断，在结构上是否正确。

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

• FunctionDecl：函数
• ParmVarDecl：参数
• CallExpr：函数调用
• BinaryOperator：运算符

生成IR代码

完成以上步骤后，就会开始生成IR中间代码，代码生成器（Code Generator）会将语法树自顶向下遍历，逐步翻译成LLVM IR，这是属于后端的工作。

为了直观的看到IR代码，我们使用下面示例代码

#import <stdio.h>

int test(int a, int b) {

    return a + b + 10;

}
int main(int argc, const char * argv[]) {

    int a = test(10,20);

    printf("%d",a);

    return 0;

}

clang -S -fobjc-arc -emit-llvm main.m

执行完成后main.m所在文件下会生成main.ll的文件

IR基本语法介绍：

• @：全局标示
• %：局部标示
• alloca：开辟空间
• align：内存对齐
• i32：32个bit，4字节
• store：写入内存
• load：读取数据
• call：调用函数
• ret：返回

IR优化

在LLVM中，优化级别分别是-O0、-O1、-O2、-O3、-Os（第一个是大写英文字母O）。

在Xcode中，找到Target→Build Setting→Optimization Level，可以对当前项目设置优化等级。

也可以通过以下命令，设置优化等级，并生成IR代码：

clang -Os -S -fobjc-arc -emit-llvm main.m -o main.ll

优化前和优化后对比一下：

Bitcode

Xcode7以后，开启Bitcode设置，苹果会做进一步的优化，生成.bc中间代码。我们通过优化后的IR代码生成bc代码，这也是一个中间代码，目的是会根据 CPU 的不同架构生成不同大小的包(App Store 商店下载)。

clang -emit-llvm -c main.ll -o main.bc

执行完成会生成.bc为后缀的文件。

什么是Bitcode？

Bitcode是被编译程序的一种中间形式的代码。包含Bitcode并上传到App Store Connect的App，会在App Store上编译和链接。包含Bitcode可以在不提交新版本App的情况下，允许Apple在将来的时候再次优化你的App二进制文件。

在Xcode中，默认开启Bitcode设置。如果你的App支持Bitcode，App使用到的其他二进制形式也要支持Bitcode，否则就会报错。

解决Bitcode报错只有两种方案：

• 【方案一】将不支持Bitcode的SDK移除掉，或等待第三方更新。
• 【方案二】：将使用Bitcode的选项设置为NO。

生成汇编代码

使用命令分别将.ll，.bc，.m的代码，生成汇编代码。

clang -S -fobjc-arc main.ll -o main.s
clang -S -fobjc-arc main.bc -o main1.
clang -S -fobjc-arc main.m -o main2.s

汇编代码一致，都是64行，如下图：

汇编代码也可以设置OPT的优化等级进行优化。

clang -Os -S -fobjc-arc main.ll -o main.s

优化后只有58行，如下图：

生成目标文件(汇编器)

目标文件的生成，是汇编器以汇编代码作为输入，将汇编代码转换为机器代码，最后输出目标文件(object-file)。

命令：

clang -fmodules -c main.s -o main.o

通过nm命令，查看main.o中的符号：

xcrun nm -nm main.o

(undefined) external _printf 
0000000000000000 (__TEXT,__text) external _main

• _printf是一个是undefined external的。
• undefined表示在当前文件暂时找不到符号_printf 
• external表示这个符号是外部可以访问的。

生成可执行文件（链接）

连接器把编译产生的.o文件和(dylib .a)文件，生成一个mach-o文件(可执行文件)。

这个过程还会链接需要的动态库和静态库

• 静态库，和可执行文件合并。
• 动态库，独立存在，运行时，由dyld动态加载。

使用以下命令，生成可执行文件：

clang main.o -o main

查看链接后可执行文件的符号：

xcrun nm -nm main.o

             (undefined) external _printf (from libSystem)                
             (undefined) external dyld_stub_binder (from libSystem)
0000000100000000 (__TEXT,__text) [referenced dynamically] external __mh_execute_header 
0000000100003f77 (__TEXT,__text) external _main 
0000000100008008 (__DATA,__data) non-external __dyld_private

• 链接后，_printf符号可以找到所属的动态库，但依然被标记为undefined。因为libSystem属于系统动态库，在运行时进行动态绑定。

• 链接后，还多了dyld_stub_binder符号，它在运行时用于符号的重绑定：

  • 以printf函数为例，printf函数存在于libSystem系统库中，它存在于懒加载符号表中。它的函数地址在运行时，首次对printf函数进行调用，才会通过dyld_stub_binder进行重绑定。
  • 而dyld_stub_binder函数地址的绑定时机：当dyld加载主程序时，符号被dyld直接绑定。