一、什么是编译器

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

高级计算机语言便于人编写，阅读交流，维护。机器语言是计算机能直接解读、运行的。编译器将汇编或高级计算机语言源程序（Source program）作为输入，翻译成目标语言（Target language）机器代码的等价程序。源代码一般为高级语言 (High-level language)， 如Pascal、C、C++、Java、汉语编程等或汇编语言，而目标则是机器语言的目标代码（Object code），有时也称作机器代码（Machine code）。

二、LLVM概述

LLVM是构架编译器(compiler)的框架系统，以C++编写而成，用于优化以任意程序语言编写的程序的编译时间(compile-time)、链接时间(link-time)、运行时间(run-time)以及空闲时间(idle-time)，对开发者保持开放，并兼容已有脚本。LLVM计划启动于2000年，最初由美国UIUC大学的Chris Lattner博士主持开展。2006年Chris Lattner加盟Apple Inc.并致力于LLVM在Apple开发体系中的应用。Apple也是LLVM计划的主要资助者。
目前LLVM已经被Apple、Microsoft、Google、Facebook等各大公司采用。

传统的编译器

传统的编译器.png

编译器前端（Frontend）

编译器前端的任务是解析代码。它会进行：词法分析，语法分析，语义分析，检查源代码是否存在错误，然后构建抽象语法树（Abstract Syntax Tree, AST）, LLVM前端还会生成中间代码（Intermediate Representation, IR）。

优化器（Optimizer）

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

编译器后端(Backend)/代码生成器（CodeGenerator）

将代码映射到目标指令集。生成机器语言，并进行机器相关的代码优化等；

iOS编译器架构

Objective-C/C/C++的编译器前端是clang, swift的编译器前端是swift，编译器后端都是LLVM。

iOS编译器架构.png

LLVM编译器设计

LLVM编译器的最大特点是可以支持多种源语言和多种硬件架构。其他编译器如GCC，它是作为应用程序整体设计的，因此它的用途受到了限制。LLVM设计的最重要方面是使用通用的代码表示形式（IR），它是用来在编译器中表示代码的形式（可以理解为中介层）。所以LLVM可以为任意编程语言独立编写前端，也可以为任意硬件架构独立编写后端。

LLVM设计.png

Clang

Clang是LLVM项目中的一个子项目。它是基于LLVM的轻量级编译器，诞生之初就是为了代替GCC，提供更快的编译速度。它是负责编译Objective-C、C、C++的编译器，它属于整个LLVM架构中的编译器前端。对于iOS开发者来说研究Clang是很有必要的。

三、LLVM编译流程

以下面的Demo为例来分析LLVM的编译流程

Demo结构.png

里面只有一个main.m文件。以下的命令都是在Demo这个目录下执行的。

通过命令打印源码的编译各个阶段

clang -ccc-print-phases main.m

打印结果如下:

+- 0: input, "main.m", objective-c
+- 1: preprocessor, {0}, objective-c-cpp-output
+- 2: compiler, {1}, ir
+- 3: backend, {2}, assembler
+- 4: assembler, {3}, object
+- 5: linker, {4}, image
+- 6: bind-arch, "x86_64", {5}, image

流程分析：

0、输入文件：找到源文件路径；
1、预处理阶段：这个过程处理包括宏的替换，头文件的导入；
2、编译阶段：进行词法分析、语法分析、检测语法是否正确，最终生成IR;
3、后端：这个过程LLVM通过一个个Pass去优化，每个Paas做一些事情，最终生成汇编代码；
4、生成目标文件；
5、连接：连接需要的动态库和静态库，生成可执行文件（符号冲突发生在这个阶段）；
6、通过不同的架构，生成对应的可执行文件。

预处理阶段

预处理阶段也叫预编译。预编译过程主要处理那些源代码文件中的以“#”开始的预编译指令。比如“#import”、“#include”、“#define”等，主要处理规则如下：

• 将所有的“#define”删除，并且展开所有宏定义。
• 处理所有条件预编译指令，比如“#if”、“#ifdef”、“#elif”、“#else”、“#endIf”。
• 处理“#include”预编译指令，将被包含的文件插入到该预编译指令的位置。值得注意的是，这个过程递归进行的，也就是说被包含的文件可能还包含其他的文件。
• 删除所有注释“//”和“/**/”。
• 添加行号标识和文件标识，比如# 11 "main.m" 2，以便于编译时编译器产生调试用的行号信息以及编译错误或警告时能够显示文件和行号。
• 保留所有的#pragma编译器指令，因为编译器须要使用他们。

执行如下命令

clang -E main.m -o main.i

执行完可以看到头文件的导入和宏的替换。
比如下面的代码

#define CustomNum 30

int test(int a,int b){
    return a + b + CustomNum;
}

int main(int argc, const char * argv[]) {
    int a = test(1, 2);
    printf("%d",a);
    return 0;
}

经过预处理之后

int test(int a,int b){
    return a + b + 30;
}

int main(int argc, const char * argv[]) {
    int a = test(1, 2);
    printf("%d",a);
    return 0;
}

在使用宏CustomNum的地方被替换成了30

编译阶段

词法分析

预处理完成就会进行词法分析。在这过程中，首先源代码会被输入扫描器，扫描器的任务很简单，它只是简单地进行词法分析，运用一种类似于有限状态机的算法可以很轻松地将源代码的字符序列分割成一系列的记号（Token）。词法分析产生的记号一般可以分为如下几类：关键字、标识符、字面量（包含数字、字符串等）和特殊符号（如加号、等号）。在识别记号的同时，扫描器也完成了其他的工作。比如将标识符存放到符号表，将数字、字符串常亮存放到文字表等，以备后面的步骤使用。
下面我们用clang 对main.m进行词法分析：

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

annot_module_include '#import <stdio.h>

#define CustomNum 30

typedef int LN_INT_64;

int test(int a,int b){
    return a + b + CustomNum;
}

int main(int'       Loc=<main.m:9:1>
typedef 'typedef'    [StartOfLine]  Loc=<main.m:13:1>
int 'int'    [LeadingSpace] Loc=<main.m:13:9>
identifier 'LN_INT_64'   [LeadingSpace] Loc=<main.m:13:13>
semi ';'        Loc=<main.m:13:22>
int 'int'    [StartOfLine]  Loc=<main.m:15:1>
identifier 'test'    [LeadingSpace] Loc=<main.m:15:5>
l_paren '('     Loc=<main.m:15:9>
int 'int'       Loc=<main.m:15:10>
identifier 'a'   [LeadingSpace] Loc=<main.m:15:14>
comma ','       Loc=<main.m:15:15>
int 'int'       Loc=<main.m:15:16>

语语法分析和语义分析

词法分析之后就是语法分析，它的任务是验证语法是否正确。在词法分析的基础上将单词序列组成各类语法短语。如“程序”、“语句”、“表达式”等等，然后将所有节点抽象成相应的语法树（Abstract Syntax Tree, AST）。语法分析仅仅是完成了对表达式语法层面的分析，但是他并不了解这个语句在语法上是否合法：比如一个指针和一个浮点型乘法运算是否合法。编译器所能分析的语义是静态语义（Static Semantic）,所谓静态语义是指编译期可以确定的语义，与之对应的是动态语义（Dynamic Semantic）就是只有在运行期间才能确定的语义。静态语义通常包括声明和类型的匹配，类型的转换。比如当一个浮点型的表达式复制给一个整型的表达式时，其中隐含了一个浮点型到整型的转换过程，语义分析过程需要完成此步骤。比如将一个浮点型赋值给一个指针的时候，语义分析程序会发现这个类型不匹配，编译器会报错。
下面通过Clang 对main.m进行语法分析

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

结果示例：

|-FunctionDecl 0x7f9a060344d8 <line:15:1, line:17:1> line:15:5 used test 'int (int, int)'
| |-ParmVarDecl 0x7f9a06034340 <col:10, col:14> col:14 used a 'int'
| |-ParmVarDecl 0x7f9a060343c0 <col:16, col:20> col:20 used b 'int'
| `-CompoundStmt 0x7f9a060f14e0 <col:22, line:17:1>
|   `-ReturnStmt 0x7f9a060f14d0 <line:16:5, line:11:19>
|     `-BinaryOperator 0x7f9a060f14b0 <line:16:12, line:11:19> 'int' '+'
|       |-BinaryOperator 0x7f9a060f1470 <line:16:12, col:16> 'int' '+'
|       | |-ImplicitCastExpr 0x7f9a060f1440 <col:12> 'int' <LValueToRValue>
|       | | `-DeclRefExpr 0x7f9a060f1400 <col:12> 'int' lvalue ParmVar 0x7f9a06034340 'a' 'int'
|       | `-ImplicitCastExpr 0x7f9a060f1458 <col:16> 'int' <LValueToRValue>
|       |   `-DeclRefExpr 0x7f9a060f1420 <col:16> 'int' lvalue ParmVar 0x7f9a060343c0 'b' 'int'
|       `-IntegerLiteral 0x7f9a060f1490 <line:11:19> 'int' 30

生成中间代码IR(Intermediate representation)

完成以上步骤就可以开始生成中间代码IR了，代码生成器（CodeGenerator）会将语法树自顶向下遍历生成LLVM IR。通过如下命令可以生成.ll格式的文本文件，查看IR代码。

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

生成.ll文件.png

Objective-C代码还在这一步进行runtime桥接：property合成、ARC处理等。
查看.ll文件内容：

; ModuleID = 'main.m'
source_filename = "main.m"
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx11.0.0"

@.str = private unnamed_addr constant [3 x i8] c"%d\00", align 1

; Function Attrs: noinline nounwind optnone ssp uwtable
define i32 @test(i32 %0, i32 %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  store i32 %0, i32* %3, align 4
  store i32 %1, i32* %4, align 4
  %5 = load i32, i32* %3, align 4
  %6 = load i32, i32* %4, align 4
  %7 = add nsw i32 %5, %6
  %8 = add nsw i32 %7, 30
  ret i32 %8
}

; Function Attrs: noinline optnone ssp uwtable
define i32 @main(i32 %0, i8** %1) #1 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i8**, align 8
  %6 = alloca i32, align 4
  store i32 0, i32* %3, align 4
  store i32 %0, i32* %4, align 4
  store i8** %1, i8*** %5, align 8
  %7 = call i32 @test(i32 1, i32 2)
  store i32 %7, i32* %6, align 4
  %8 = load i32, i32* %6, align 4
  %9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32 %8)
  ret i32 0
}

declare i32 @printf(i8*, ...) #2

attributes #0 = { noinline nounwind optnone ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "darwin-stkchk-strong-link" 

• IR基本语法

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

• IR的优化
  LLVM级别的优化有O0、O1、O2、O3、Os。下面的命令使用Os:

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

优化后的代码：

; ModuleID = 'main.m'
source_filename = "main.m"
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx11.0.0"

@.str = private unnamed_addr constant [3 x i8] c"%d\00", align 1

; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
define i32 @test(i32 %0, i32 %1) local_unnamed_addr #0 {
  %3 = add i32 %0, 30
  %4 = add i32 %3, %1
  ret i32 %4
}

; Function Attrs: nofree nounwind optsize ssp uwtable
define i32 @main(i32 %0, i8** nocapture readnone %1) local_unnamed_addr #1 {
  %3 = tail call i32 (i8*, ...) @printf(i8* nonnull dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32 33) #3, !clang.arc.no_objc_arc_exceptions !9
  ret i32 0
}

; Function Attrs: nofree nounwind optsize
declare i32 @printf(i8* nocapture readonly, ...) local_unnamed_addr #2

attributes #0 = { norecurse nounwind optsize readnone 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" 

明显感觉代码少了很多

bitCode

bitcode是被编译程序的一种中间形式的代码。包含bitcode配置的程序将会在App store上被编译和链接。bitcode允许苹果在后期重新优化我们程序的二进制文件，而不需要我们重新提交一个新的版本到App store上。开启bitcode后苹果会做进一步的优化。生成.bc的中间代码。
通过优化后的.ll生成.bc代码：

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

生成main.bc文件.png

生成汇编代码

可以通过.ll或.bc生成最终的汇编代码：

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

生成main.s汇编代码.png

汇编代码展示：

    .section    __TEXT,__text,regular,pure_instructions
    .build_version macos, 11, 0 sdk_version 11, 3
    .globl  _test                           ## -- Begin function test
_test:                                  ## @test
    .cfi_startproc
## %bb.0:
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    addl    $30, %edi
    addl    %esi, %edi
    movl    %edi, %eax
    popq    %rbp
    retq
    .cfi_endproc
                                        ## -- End function
    .globl  _main                           ## -- Begin function main
_main:                                  ## @main
    .cfi_startproc
## %bb.0:
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    subq    $32, %rsp
    leaq    L_.str(%rip), %rax
    movl    %edi, -4(%rbp)                  ## 4-byte Spill
    movq    %rax, %rdi
    movl    $33, %ecx
    movq    %rsi, -16(%rbp)                 ## 8-byte Spill
    movl    %ecx, %esi
    movb    $0, %al
    callq   _printf
    xorl    %ecx, %ecx
    movl    %eax, -20(%rbp)                 ## 4-byte Spill
    movl    %ecx, %eax
    addq    $32, %rsp
    popq    %rbp
    retq
    .cfi_endproc
                                        ## -- End function
    .section    __TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
    .asciz  "%d"

    .section    __DATA,__objc_imageinfo,regular,no_dead_strip
L_OBJC_IMAGE_INFO:
    .long   0
    .long   64

.subsections_via_symbols

生成汇编代码也可以再进行优化：

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

汇编（生成目标文件）

汇编过程主要是由汇编器将汇编代码转换成机器可以执行的指令，每一个汇编语句几乎对着一条机器指令。所以汇编器的汇编过程相对编译器来讲比较简单，它没有复杂的语法，也没有语义，也不需要指令优化，只是根据汇编指令和机器码指令的对照表一一翻译就好了，“汇编”的名字也来源于此。目标文件的生成，是汇编器以汇编代码的作为输入，将汇编代码转换成机器代码，最后输出目标文件（Object file）。汇编过程我们可以通过Clang或者汇编器as来完成，如下所示：

clang -fmodules -c main.s -o main.o
或者 as -c main.s -o main.o 

生成目标文件.png

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

xcrun nm -nm main.o

结果：

          (undefined) external _printf
0000000000000000 (__TEXT,__text) external _test
000000000000000a (__TEXT,__text) external _main

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

链接（生成可执行文件）

链接（link）的主要内容就是把各个模块（目标文件）之间相互引用的部分都处理好，使得各个模块之间能够正确地衔接。链接器的工作就是把一些指令对其他符号地址的引用加以修正。链接的过程主要包括地址和空间分配（Address and Storage Allocation）、符号决议（Symbol Resolution）和重定位（Relocation）等这些步骤。

符号决议有时候也被叫做符号绑定（Symbol Binding），也有叫地址绑定（Address Binding），大体意思是一样的，但从细节角度来区分，它们之间还是存在一定的区别的，比如“决议”更倾向于静态链接，而“绑定”更倾向于动态链接，即它们所使用的范围不完全相同。在静态链接我们统一称为符号决议。

下面用Clang对main.o进行链接操作：

clang main.o -o main 

生成可执行文件.png

查看链接之后的符号：

xcrun nm -nm main

查看结果：

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

四、编译LLVM工程

待后续。。。