Golang 编译器代码浅析
  • 0. Golang 编译器代码浅析
  • 1. golang 编译器 - 前言
    • 1.1 编译器简介
    • 1.2 Golang 编译器
    • 1.3 Go 语言版本
    • 1.4 项目设置
    • 1.5 约定
    • 1.6 写作目的
  • 2. golang 编译器 - 词法分析
    • 2.1 简介
    • 2.2 代码结构
    • 2.3 处理字符
    • 2.4 扫描Token
    • 2.5 总结
  • 3.a 语法分析理论知识
    • 3A.1 语法分析简介
    • 3A.2 文法
    • 3A.3 语法解析
    • 3A.3.1 自顶向下(Top-Down)
    • 3A.3.2 自顶向下 - 递归下降
    • 3A.3.3 自顶向下 - LL(1)文法
    • 3A.3.4 自底向上(Bottom-Up)
    • 3A.3.5 自底向上 - LR(0)项集及SLR预测表
    • 3A.3.6 自底向上 - LR(1)、LALR
    • 3A.4 语法分析工具
    • 3A.5 总结
  • 3B. golang 编译器 - 语法分析
    • 3B.1 简介
    • 3B.2 代码结构
    • 3B.3 数据结构
    • 3B.4 构造语法树
    • 3B.5 Unit Test及AST可视化
  • 4. Golang 编译器 - 类型检查
    • 4.1 简介
    • 4.2 代码结构
    • 4.3 符号解析
    • 4.4.1 数据结构 - 作用域
    • 4.4.2 数据结构 - Package
    • 4.4.3 数据结构 - Object 对象
    • 4.4.4-1 类型数据结构 - 简介
    • 4.4.4-2 类型接口
    • 4.4.4-3 基础类型
    • 4.4.4-4 内置复合类型
    • 4.4.4-5 Struct 类型
    • 4.4.4-6 Interface 类型
    • 4.4.4-7 Named 类型
    • 4.4.4-8 Tuple 类型
    • 4.4.4-9 Sum 类型
    • 4.4.4-10 Function & Method 类型
    • 4.4.4-11 泛型类型
    • 4.4.4-12 类型的等价规则
    • 4.4.4-13 类型的比较规则
    • 4.4.4-14 总结
    • 4.4.5 类型检查器
    • 4.4.6 总结
    • 4.5.1 类型检查逻辑 - 包加载器
    • 4.5.2 类型检查逻辑 - 初始化
    • 4.5.2-1 全局作用域
    • 4.5.2-2 类型检查器
    • 4.5.3 类型检查逻辑 - 流程分析
    • 4.5.3-1.1 总体流程
    • 4.5.3-1.2 类型检查准备工作
    • 4.5.3-1.3 类型检查核心逻辑
    • 4.5.3-1.3a 总体介绍
    • 4.5.3-1.3b 类型表达式的类型检查
    • 4.5.3-1.3c 求值表达式的类型检查
    • 4.5.3-1.3d 类型兼容性检查
    • 4.5.3-1.3e 处理delayed队列
    • 4.5.3-1.4 构建初始化顺序
    • 4.5.3-1.5 总结
    • 4.5.3-2 特定问题分析
    • 4.5.3-2a 对象循环依赖检查
    • 4.5.3-2b 方法与属性查找
    • 4.5.3-2c Underlying Type
    • 4.6 如何测试
    • 4.7 总结
  • 5. Golang 编译器 - IR Tree
    • 5.1 简介
    • 5.2 代码结构
    • 5.3 数据结构
    • 5.4 处理逻辑
    • 5.5 编译日志
    • 5.6 Unit Test
    • 5.7 总结
  • 6. golang 编译器 - 初始化任务
    • 6.1 简介
    • 6.2 代码结构
    • 6.3 总体逻辑
    • 6.4 赋值语句
    • 6.5 编译日志
    • 6.6 Unit Test
    • 6.7 总结
  • 7. golang 编译器 - 清除无效代码
    • 7.1 简介
    • 7.2 处理逻辑
    • 7.3 Unit Test
  • 8. golang 编译器 - Inline
    • 8.1 简介
    • 8.2 Inline的问题
    • 8.3 代码结构
    • 8.4 处理逻辑
    • 8.4.1 遍历调用链
    • 8.4.2 内联判断
    • 8.4.3 内联操作
    • 8.4.4 编译日志
    • 8.4.5 Unit Test
    • 8.4.6 总结
  • 9. golang 编译器 - 逃逸分析
    • 9.1 什么是逃逸分析
    • 9.2 Go 的逃逸分析
    • 9.3 算法思路
    • 9.4 代码结构
    • 9.5 处理逻辑
    • 9.5.1总体逻辑
    • 9.5.2 数据结构
    • 9.5.3 构建数据流有向图
    • 9.5.4 逃逸分析
    • 9.6 编译日志
    • 9.7 Unit Test
    • 9.8 总结
  • 10. golang 编译器 - 函数编译及导出
    • 10.1 简介
    • 10.2 编译函数
    • 10.2.1 SSA
    • 10.2.2 ABI
    • 10.2.3 并发控制
    • 10.3 导出对象文件
    • 10.4 总结
  • 11. Golang 编译器 - 写在最后
由 GitBook 提供支持
在本页

这有帮助吗?

  1. 9. golang 编译器 - 逃逸分析

9.3 算法思路

上一页9.2 Go 的逃逸分析下一页9.4 代码结构

最后更新于3年前

这有帮助吗?

编译器对函数中的静态数据流进行分析,以此来判断变量是否需要逃逸。

什么是静态数据流呢?函数变量以及变量之间的赋值操作构成了一个有向图,该图的顶点(Vertex)代表变量,边(Edge)代表赋值语句,方向(Direction)代表数据流向。例如下列代码:

type T struct {
    Name string
}

func escapeAnalysis(arg T) (*T, bool) {
    l1 := arg
    l1.Name = "Golang"

    l2 := &l1
    l3 := *l2
    return &l3, arg.Name == "Java"
}

该函数内变量形成的有向图如下:

其中 ~r1 与 ~r2 为编译器内部为函数返回值取的变量名。上图中我们为每条边加了一个权重,该权重的计算方式为: derefs = 引用解析次数(Dereferences)- 取地址次数(Addressing) ,即赋值语句右侧 * 操作减去 & 操作的数目。参见下面例子:

p = &q      // Derefs: -1
p = q       // Derefs: 0
p = *q      // Derefs: 1
p = **&**&q // Derefs: 2

由于 &x 本身是不可寻址(non-addressable)的,所以任何边的权重最小值只能是 -1. 上图体现的便是该函数内局部变量的数据流。

上一节我们讨论过造成局部变量逃逸的根本原因由指向该变量的指针引起,这也是上图中权重算法的根本原因:对任何变量A,以及直接指向该变量的任意顶点B, 我们都需要知道 A 是否持有的是 B 的指针。如果是的话,那么当 A 逃逸时,B 也必然需要逃逸。例如上图中的路径:l3 -> ~r1, 其中 ~r1 作为返回值需要逃逸,此时 l3 到 ~r1 边的权重为 -1, 意味着将 l3 赋值给 ~r1 时取了地址,即 ~r1 拿到的是 l3 的指针,因此 l3 也必须逃逸;但 l2 -> l3 的权重为 1, 所以即使 l3 逃逸了,l2 也不需要逃逸,由于 l2 不需要逃逸,即便 l1 -> l2 的权重为 -1, l1 也不需要逃逸。

我们再将该思路进行推广:在一条赋值链 A <- B <- … <- X <- Y 中,如果 A 逃逸,赋值链上各级可能应用了解析操作(*),也可能是取址操作(&),这样导致的结果可能是 A 最终持有的是 X 的指针,那么我们的算法就必须让 X 逃逸,而 X 与 A 之间的所有变量则可能并不需要逃逸。例如下列代码:

type T struct {
    Name string
}

func escapeAnalysis() **T {
    var t T
    l1 := &t
    l2 := &l1
    l3 := &l2
    l4 := *l3

    return l4
}

函数的数据流有向图为:

通过赋值链我们可以发现,返回值 ~r1 实际持有的是 l1 的指针,而 l1 又持有 t 的指针,所以该函数中最终逃逸变量是 l1 与 t, 而中间的 l4, l3, l2 则不会逃逸。在一节我们会详细分析实现细节。

逃逸分析
Escape Analysis Vars
Escape Analysis - Static Data Stream