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.2 Go 的逃逸分析

全局变量的内存区域毫无疑问需要分配到堆上,我们仅对函数的局部变量进行分析。

我们知道 Go 语言遵循 copy-by-value(按值拷贝) 规则, 即程序在赋值、传递函数的参数、以及返回值的过程中,会完全拷贝一份对应类型的数据,然后将拷贝传递给对方。例如如下代码:

type Lang struct {
    Name string
}

func copyLang(arg Lang) (result Lang) {
    l := arg          // 以 arg 的内容重新创建一个 Lang 实例,并将新实例赋值给 l
    l.Name = "Golang" // 修改 l.Name 的属性不会改变 arg 中的内容

    defer func() {
        fmt.Printf("In copyLang: arg.Name: %s, l.Name: %s, result.Name: %s. Add: %p\n", arg.Name, l.Name, result.Name, &result)
    }()

    return l // 同理,此处复制一份 l 赋值给返回值 result
}

func main() {
    l1 := Lang{"Java"}

    fmt.Printf("In main before copyLang: l1.Name: %s\n", l1.Name)
    // 1. 此处复制一份 l1, 然后作为参数传递给函数 copyLang, 即使函数修改了参数的内部属性,也不会影响 l1
    // 2. 将函数 copyLang 的返回值变量 result 复制一份,赋值给 l3
    l3 := copyLang(l1)

    fmt.Printf("In main after copyLang: l1.Name: %s, l3.Name: %s\n", l1.Name, l3.Name)
}

特别指出的是:在 l3 := copyLang(l1) 语句中,函数的返回值变量 result 与 l3 也指向不同的内存区域。对于没有命名的函数返回值,编译器会为其生成一个内部变量名,例如对于代码:

func copyLang(arg Lang) Lang {
    return arg
}

编译器处理之后的代码相当于:

func copyLang(arg Lang) (r0 Lang) {
    return arg
}

因此效果是一样的。可以发现由于规则 copy-by-value, 上述代码中所涉及的所有局部变量都指向自己单独的内存区域。既然如此,那么局部变量怎么可能需要逃逸呢?答案是指针!例如如下代码:

func copyLang(arg Lang) *Lang {
    l2 := arg

    return &l2
}
  1. 指向栈上对象的指针不能分配到堆上

  2. 指向栈上对象的指针,其生命周期不能长于该对象

换而言之,如果一个指针被分配到了堆上,那么其指向的对象一定要分配到堆上;如果一个指针的生命周期长于其指向的对象,那么该对象一定要分配到堆上。上例中返回值指针的生命周期长于 l2, 因此 l2 会逃逸到堆上。

除此之外,为了避免栈过于庞大,编译器会直接将大对象分配到堆上。

当函数返回一个指针时,程序也会根据 copy-by-value 规则拷贝一个新的指针对象并返回,但这两个指针对象所指向的是同一块内存地址。

上一页9.1 什么是逃逸分析下一页9.3 算法思路

最后更新于3年前

这有帮助吗?

因为函数返回的是 l2 的指针,所以程序在拷贝时必须将其内存分配到堆上,否则会造成悬挂指针()问题。因此 Go 的逃逸分析都是围绕着指针展开的,其核心思路基于如下两点:

Dangling Pointer