1
# 前端处理的简化示例
2
source = "int x = 42;"
3

4
# 词法分析：字符流 → Token 流
5
tokens = [
6
    Token(type="INT", value="int"),
7
    Token(type="IDENT", value="x"),
8
    Token(type="ASSIGN", value="="),
9
    Token(type="INT_LIT", value="42"),
10
    Token(type="SEMI", value=";"),
11
]
12

13
# 语法分析：Token 流 → AST
14
ast = VarDecl(
15
    type=Type("int"),
16
    name="x",
17
    init=IntLit(42)
18
)
19

20
# 语义分析：AST + 类型检查 → 带类型的 AST
21
typed_ast = VarDecl(
22
    type=Type("int"),
23
    name="x",
24
    init=IntLit(42, type=Type("int")),  # 类型已标注
25
    symbol=Symbol(name="x", type=Type("int"), scope=0)
26
)

1
// 优化前
2
int foo(int x) {
3
    int a = 10;       // 常量
4
    int b = 20;       // 常量
5
    int c = a + b;    // 常量折叠 → c = 30
6
    int d = x * 0;    // 乘零消除 → d = 0
7
    int e = d + c;    // 常量传播 → e = 30
8
    return e;         // 死代码消除后 → return 30
9
}
10

11
// 优化后
12
int foo(int x) {
13
    return 30;
14
}

1
# 查看预处理输出
2
gcc -E hello.c -o hello.i
3

4
# 预处理做了什么
5
# 1. #include <stdio.h> → 展开 stdio.h 的全部内容（约 800 行）
6
# 2. #define MAX 100 → 文本替换
7
# 3. #ifdef DEBUG → 条件编译
8
# 4. 注释删除

1
# 预处理
2
clang -E hello.c -o hello.i
3

4
# 词法分析（查看 Token）
5
clang -dump-tokens hello.c
6

7
# 语法分析（查看 AST）
8
clang -ast-dump hello.c
9

10
# 生成 LLVM IR
11
clang -emit-llvm -S hello.c -o hello.ll
12

13
# 查看优化后的 LLVM IR
14
clang -emit-llvm -S -O2 hello.c -o hello_opt.ll
15

16
# 生成汇编
17
clang -S hello.c -o hello.s
18

19
# 生成目标文件
20
clang -c hello.c -o hello.o
21

22
# 查看目标文件的段
23
objdump -h hello.o
24

25
# 查看反汇编
26
objdump -d hello.o
27

28
# 链接生成可执行文件
29
clang hello.o -o hello

1
# 动态类型（Python）—— 运行时才知道类型
2
def add(a, b):
3
    return a + b  # a 和 b 可以是 int、float、str...
4

5
add(1, 2)        # 3
6
add("hello", " world")  # "hello world"
7
add(1, "2")      # TypeError at runtime!

1
// 静态类型（Rust）—— 编译期就知道类型
2
fn add(a: i32, b: i32) -> i32 {
3
    a + b
4
}
5

6
add(1, 2);       // OK
7
add("hello", " world"); // Compile error!

1
// 示例：计算斐波那契数列
2
int fib(int n) {
3
    if (n <= 1) return n;
4
    return fib(n - 1) + fib(n - 2);
5
}

1
# -O0：无优化，忠实翻译
2
clang -O0 -S fib.c -o fib_O0.s
3
# 结果：直接翻译，每次递归调用都压栈
4

5
# -O2：标准优化
6
clang -O2 -S fib.c -o fib_O2.s
7
# 结果：尾调用优化、内联、常量传播
8

9
# -O3：激进优化
10
clang -O3 -S fib.c -o fib_O3.s
11
# 结果：可能展开递归、向量化

1
// 你写的代码
2
memcpy(dst, src, 16);
3

4
// 编译器可能替换为
5
__builtin_memcpy(dst, src, 16);
6
// → 如果大小已知且较小，直接生成 SIMD 指令
7
// → 如果大小未知，调用 libc 的 memcpy
8

9
// 你写的代码
10
for (int i = 0; i < n; i++) dst[i] = src[i];
11

12
// 编译器可能自动识别为 memcpy 模式
13
// → 生成向量化指令或调用 memcpy

1
// 这段代码有 UB：有符号整数溢出
2
int sum(int n) {
3
    int result = 0;
4
    for (int i = 1; i <= n; i++) {
5
        result += i;  // 如果 n 很大，result 会溢出
6
    }
7
    return result;
8
}
9

10
// 编译器假设溢出不会发生，可能：
11
// 1. 将循环替换为公式 result = n * (n + 1) / 2
12
// 2. 删除溢出检查
13
// 3. 如果 n 足够大，结果与预期不同

1
# Ubuntu/Debian
2
sudo apt install clang llvm
3

4
# macOS（Xcode 自带）
5
xcode-select --install
6

7
# 验证安装
8
clang --version
9
llvm-config --version

1
# 创建示例文件
2
cat > hello.c << 'EOF'
3
int add(int a, int b) {
4
    return a + b;
5
}
6

7
int main() {
8
    return add(3, 4);
9
}
10
EOF
11

12
# 1. 预处理
13
clang -E hello.c | head -20
14

15
# 2. 查看 Token
16
clang -dump-tokens hello.c 2>/dev/null | head -20
17

18
# 3. 查看 AST
19
clang -ast-dump hello.c 2>/dev/null | head -30
20

21
# 4. 生成 LLVM IR（未优化）
22
clang -emit-llvm -S -O0 hello.c -o hello_O0.ll
23

24
# 5. 生成 LLVM IR（优化后）
25
clang -emit-llvm -S -O2 hello.c -o hello_O2.ll
26

27
# 6. 对比优化前后的 IR
28
diff hello_O0.ll hello_O2.ll
29

30
# 7. 生成汇编
31
clang -S -O2 hello.c -o hello.s
32

33
# 8. 生成目标文件
34
clang -c hello.c -o hello.o
35

36
# 9. 查看目标文件信息
37
readelf -h hello.o    # ELF 头
38
readelf -S hello.o    # 段表
39
objdump -d hello.o    # 反汇编
40

41
# 10. 链接并运行
42
clang hello.o -o hello && ./hello
43
echo $?  # 应输出 7