1
// 简化版编译入口，基于 cmd/compile/main.go
2
// 实际代码参见:
3
// https://github.com/golang/go/blob/go1.25.0/src/cmd/compile/main.go
4

5
func main() {
6
    // 1. 解析命令行参数（-N, -l, -S, -m 等）
7
    // 2. 对每个包调用 compilePackage()
8
    // 3. compilePackage() 内部流程：
9
    //    parseFiles()     → 词法 + 语法分析
10
    //    typecheck()      → 类型检查
11
    //    escapeAnalysis() → 逃逸分析
12
    //    buildSSA()       → 生成 SSA IR
13
    //    opt()            → SSA 优化遍
14
    //    genssa()         → 生成机器码
15
}

1
// Token 类型定义 — 真实源码
2
// https://github.com/golang/go/blob/go1.25.0/src/cmd/compile/internal/syntax/tokens.go
3

4
type Operator operator
5
type operator int
6

7
const (
8
    // 控制流关键字（部分）
9
    _Break operator = iota
10
    _Case _Continue _Default _Defer _Else
11
    _Fallthrough _For _Func _Go _If
12
    _Import _Interface _Map _Package _Range
13
    _Return _Select _Struct _Switch _Type _Var
14
    // ... 运算符、字面量等 Token
15
)

1
// 输入源码
2
package main
3

4
func add(a, b int) int {
5
    return a + b
6
}

1
[package] [main] [\n]
2
[func] [add] [(] [a] [,] [b] [int] [)] [int] [{]
3
[return] [a] [+] [b] [}]

1
// AST 节点类型定义 — 基于 syntax/nodes.go 简化
2
// https://github.com/golang/go/blob/go1.25.0/src/cmd/compile/internal/syntax/nodes.go
3

4
// Node 是所有 AST 节点的基础接口
5
type Node interface {
6
    Pos() Pos
7
    aNode()
8
}
9

10
// FuncDecl 函数声明节点
11
type FuncDecl struct {
12
    *Name              // 函数名
13
    *FuncType          // 参数和返回值类型
14
    Body  *BlockStmt   // 函数体
15
}
16

17
// BinaryExpr 二元表达式节点
18
type BinaryExpr struct {
19
    X  Expr
20
    Op Operator
21
    Y  Expr
22
}

1
// parser.fileOrNil — 顶层解析入口
2
// https://github.com/golang/go/blob/go1.25.0/src/cmd/compile/internal/syntax/parser.go
3

4
func (p *parser) fileOrNil() *File {
5
    // 解析 package 子句
6
    p.want(_Package)
7
    f := p.file()
8
    f.PkgName = p.name()
9
    p.want(_Semi)
10

11
    // 循环解析 import 声明和顶层声明
12
    for p.got(_Import) {
13
        f.DeclList = append(f.DeclList, p.importDecl())
14
    }
15

16
    for _ == 0 { // 简化循环条件
17
        switch p.token() {
18
        case _Func:
19
            f.DeclList = append(f.DeclList, p.funcDeclOrNil())
20
        case _Type:
21
            f.DeclList = append(f.DeclList, p.typeDecl())
22
        case _Var, _Const:
23
            f.DeclList = append(f.DeclList, p.varDecl())
24
        default:
25
            return f
26
        }
27
    }
28
}

1
// 类型检查器的核心调度 — 基于 types2/check.go 简化
2
// https://github.com/golang/go/blob/go1.25.0/src/cmd/compile/internal/types2/check.go
3

4
func (check *Checker) checkFiles(files []*syntax.File) {
5
    // 1. 收集所有声明
6
    check.collectObjects(files)
7

8
    // 2. 处理包级变量初始化顺序
9
    check.processPackageLevelInits()
10

11
    // 3. 逐个检查函数体
12
    for _, f := range check.delayed {
13
        f() // 延迟的类型检查任务
14
    }
15
}
16

17
// checkExpr 对表达式做类型检查
18
func (check *Checker) expr(x *operand, e syntax.Expr) {
19
    switch e := e.(type) {
20
    case *syntax.Name:
21
        check.ident(x, e, nil, false)
22
    case *syntax.BinaryExpr:
23
        check.binary(x, e.X, e.Y, e.Op)
24
    case *syntax.CallExpr:
25
        check.call(x, e)
26
    case *syntax.IndexExpr:
27
        check.indexExpr(x, e)
28
    // ... 更多 case
29
    }
30
}

1
# 查看内联决策
2
go build -gcflags="-m" main.go 2>&1 | grep inline
3

4
# 禁止内联
5
go build -gcflags="-l" main.go
6

7
# 查看内联成本
8
go build -gcflags="-m -m" main.go 2>&1 | grep "cost"

1
v3 = Add64 <int> v1 v2     ;; int 类型，v1 + v2
2
v7 = Const64 <int> [42]    ;; int 类型常量 42

1
// compile.go — SSA Pass 注册（简化，展示主要 Pass）
2
// https://github.com/golang/go/blob/go1.25.0/src/cmd/compile/internal/ssa/compile.go
3

4
var passes = [...]pass{
5
    // 早期阶段
6
    {name: "number lines", fn: numberLines},
7
    {name: "early copyelim", fn: copyelim},
8
    {name: "early deadcode", fn: deadcode},
9
    {name: "short circuit", fn: shortcircuit},
10
    {name: "decompose user", fn: decomposeUser},
11
    {name: "early opt", fn: opt},
12
    {name: "early deadcode", fn: deadcode},
13
    {name: "opt deadcode", fn: deadcode},
14
    {name: "generic cse", fn: cse},
15
    {name: "phielim", fn: phielim},
16
    {name: "copyelim", fn: copyelim},
17
    {name: "deadcode", fn: deadcode},
18

19
    // 循环优化
20
    {name: "looprotate", fn: loopRotate},
21

22
    // 后期优化
23
    {name: "stackcheck", fn: stackcheck},
24

25
    // 架构相关降级
26
    {name: "lower", fn: lower},
27

28
    // 寄存器分配
29
    {name: "regalloc", fn: regalloc},
30

31
    // 最终阶段
32
    {name: "stackframe", fn: stackframe},
33
    {name: "trim", fn: trim},
34
}

1
# 生成 ssa.html，在浏览器中打开
2
GOSSAFUNC=add go build main.go
3
# 输出: dumped SSA to ./ssa.html
4

5
# 也可以指定输出目录
6
GOSSAFUNC=add GOSSADIR=./ssa-out go build main.go

1
# 1. 生成 SSA 查看器（HTML 页面，可在浏览器中逐阶段浏览）
2
GOSSAFUNC=main go build main.go
3
# 输出: dumped SSA to ./ssa.html
4

5
# 2. 查看指定阶段的 SSA 文本输出
6
GOSSAFUNC=main go build -gcflags="-d=ssa/build/dump" main.go
7

8
# 3. 打印最终汇编输出
9
go tool compile -S main.go
10

11
# 4. 查看所有编译阶段
12
go tool compile -d=ssa/check_bce/dump main.go
13

14
# 5. 反汇编已编译的二进制
15
go tool objdump -s "main\.add" ./mybin

1
// 链接器内部符号表示 — 基于 cmd/link/internal/sym/sym.go 简化
2
// https://github.com/golang/go/blob/go1.25.0/src/cmd/link/internal/sym/sym.go
3

4
type Symbol struct {
5
    Name    string       // 符号名，如 "main.add"
6
    Type    SymKind      // 符号类型
7
    Section *Section     // 所属段
8
    Value   int64        // 段内偏移
9
    Size    int64        // 符号大小
10
    Relocs  []Reloc      // 重定位列表
11
    Outer   *Symbol      // 被合并到的外部符号
12
    Sub     *Symbol      // 子符号链表
13
}

1
// cmd/link/internal/sym/sym.go — 重定位
2
type Reloc struct {
3
    Off  int32     // 在符号内的偏移
4
    Siz  uint8     // 重定位大小（1/2/4/8 字节）
5
    Type objabi.RelocType  // 重定位类型
6
    Add  int64     // 加数
7
    Sym  *Symbol   // 目标符号
8
}

1
go tool link -v -o mybin main.o      # 详细链接输出
2
go tool nm main.o                    # 查看目标文件中的符号
3
go tool nm ./mybin | grep "main\."   # 查看最终二进制的符号表

1
# === 编译 ===
2
go build hello.go                   # 编译为可执行文件
3
go run hello.go                     # 编译并运行
4
go install hello                    # 安装到 $GOPATH/bin
5

6
# === 编译优化控制 ===
7
go build -gcflags="-N"              # 禁止优化
8
go build -gcflags="-l"              # 禁止内联
9
go build -gcflags="-m"              # 输出内联和逃逸分析决策
10
go build -gcflags="-m -m"           # 输出更详细的逃逸分析路径
11
go build -gcflags="-d=ssa/check_bce/dump"  # 输出边界检查消除
12

13
# === 链接器控制 ===
14
go build -ldflags="-s -w"           # 去除符号表和调试信息（减小体积）
15
go build -ldflags="-X main.Version=1.0.0"   # 编译时注入变量值
16

17
# === 依赖管理 ===
18
go mod init module                  # 初始化模块
19
go mod tidy                         # 清理依赖
20

21
# === 测试 ===
22
go test ./...                       # 运行测试
23
go test -bench=.                    # 运行基准测试
24
go test -race                       # 竞态检测

1
go tool compile -S hello.go         # 打印汇编输出
2
go tool objdump -s "main\." hello   # 反汇编 main 包函数
3
go tool link -v hello.o             # 详细链接输出
4
GOSSAFUNC=main go build hello.go    # 生成 ssa.html，浏览器查看所有 SSA 阶段
5
go env GOCACHE                      # 编译缓存目录
6
go version -m ./mybin               # 查看二进制的 module 依赖信息

1
// bad.go — 导致不必要逃逸
2
package main
3

4
import "fmt"
5

6
func process(data []byte) {
7
    // fmt.Println 的参数会被转为 interface{}
8
    // 导致 data 的逃逸分析变得保守
9
    fmt.Println("data:", data)
10
}
11

12
func main() {
13
    buf := make([]byte, 1024)
14
    process(buf)
15
}

1
$ go build -gcflags="-m" bad.go 2>&1
2
# command-line-arguments
3
./bad.go:7:2: inlining call to fmt.Println
4
./bad.go:12:2: make([]byte, 1024) escapes to heap  ;; 逃逸到堆
5
./bad.go:7:18: data escapes to heap                 ;; 逃逸到堆

1
// good.go — 减少逃逸
2
package main
3

4
func process(data []byte) {
5
    // 直接使用 println，不经过 interface{}
6
    // 或者将数据写入 sync.Pool 复用
7
    _ = data // 处理逻辑
8
}
9

10
func main() {
11
    buf := make([]byte, 1024)
12
    process(buf)
13
}

1
$ go build -gcflags="-m" good.go 2>&1
2
# command-line-arguments
3
./good.go:12:2: make([]byte, 1024) does not escape  ;; 栈分配！

1
# 允许内联：main 函数中直接计算 1+2，无 CALL 指令
2
$ go tool compile -S inline.go | grep -A 5 "main"
3

4
# 禁止内联 (-l)：可以看到 CALL main.add(SB) 指令
5
$ go tool compile -S -l inline.go | grep -A 5 "main"

1
# 查看边界检查消除情况（无输出 = 全部消除）
2
$ go build -gcflags="-d=ssa/check_bce/dump" bce.go 2>&1