知识点

bare return

如果一个函数将所有的返回值都显示的变量名，那么该函数的return语句可以省略操作数。这称之为bare return
如：

func main(url string) (words, images int, err error) {
    resp, err := http.Get(url)
    if err != nil {
        return
    }
    doc, err := html.Parse(resp.Body)
    resp.Body.Close()
    if err != nil {
        err = fmt.Errorf("parsing HTML: %s", err)
        return
    }
    words, images = countWordsAndImages(doc)
    return
}

闭包和逃逸

• 匿名函数可以访问完整的词法环境（lexical environment），这意味着在函数中定义的内部函数可以引用该函数的变量

逃逸是个啥？举个栗子

package main

import "fmt"

func Fibonacci() func int {
    a, b  := 0, 1
    return func() int {
        a, b = b, a+b
    }
}

func main() {
    f := Fibonacci()
    for i := 0; i < 10; i++ {
        fmt.printfln("FibonacciL %d\n", f())
    }
}

此时，原本在Fibonacci()中声明的变量，在main函数中因为闭包带回了ab的访问地址，此时就叫他们发生了逃逸，确切说是闭包引用逃逸

为什么要分析逃逸？

对于一个对象来说，

• 如果分配到栈上，待函数返回资源就被回收了
• 如果分配到堆上，函数返回后交给gc来管理该对象资源

而那些发生逃逸的对象，从原本的栈空间跑到了堆空间，这样就增加了gc的负担

常见的逃逸还有哪些？

• 指针逃逸
  函数返回局部变量的指针。
• 栈空间不足逃逸
  当对象大小超过的栈帧大小时，变量对象发生逃逸被分配到堆上。
• 动态类型逃逸
  当对象不确定大小或者被作为不确定大小的参数时发生逃逸。
• 切片或map赋值逃逸
  因为切片和map是引用传递（其实是复制了指向原空间的指针，并不是真的直接传递了指针），如果对象指针被存入切片或者map返回的话，类似于指针逃逸，外部就可以访问到原本的变量了

捕获迭代变量

来个例子：如果没有necessary这一行，会怎样？

var rmdirs []func()
for _, d := range tempDirs() {
    dir := d // NOTE: necessary!
    os.MkdirAll(dir, 0755) // creates parent directories too
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dir)
    })
}
// ...do some work…
for _, rmdir := range rmdirs {
    rmdir() // clean up
}

这里是错误代码：

var rmdirs []func()
for _, dir := range tempDirs() {
    os.MkdirAll(dir, 0755)
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dir) // NOTE: incorrect!
    })
}

问题的原因在于循环变量的作用域。在上面的程序中，for循环语句引入了新的词法块，循环变量dir在这个词法块中被声明。在该循环中生成的所有函数值都共享相同的循环变量。需要注意，函数值中记录的是循环变量的内存地址，而不是循环变量某一时刻的值。以dir为例，后续的迭代会不断更新dir的值，当删除操作执行时，for循环已完成，dir中存储的值等于最后一次迭代的值。这意味着，每次对os.RemoveAll的调用删除的都是相同的目录。

函数调用

调用惯例

我们来对比下C和go的调用惯例：

• C语言
  当参数两个时

main:
    pushq   %rbp
    movq    %rsp, %rbp
    subq    $16, %rsp
    movl    $2, %esi  // 设置第二个参数
    movl    $1, %edi  // 设置第一个参数
    call    my_function
    movl    %eax, -4(%rbp)
my_function:
    pushq   %rbp
    movq    %rsp, %rbp
    movl    %edi, -4(%rbp)    // 取出第一个参数，放到栈上
    movl    %esi, -8(%rbp)    // 取出第二个参数，放到栈上
    movl    -8(%rbp), %eax    // eax = esi = 1
    movl    -4(%rbp), %edx    // edx = edi = 2
    addl    %edx, %eax        // eax = eax + edx = 1 + 2 = 3
    popq    %rbp

当参数八个时

main:
    pushq   %rbp
    movq    %rsp, %rbp
    subq    $16, %rsp     // 为参数传递申请 16 字节的栈空间
    movl    $8, 8(%rsp)   // 传递第 8 个参数
    movl    $7, (%rsp)    // 传递第 7 个参数
    movl    $6, %r9d
    movl    $5, %r8d
    movl    $4, %ecx
    movl    $3, %edx
    movl    $2, %esi
    movl    $1, %edi
    call    my_function

我们可以将本节的发现和分析简单总结成 —— 当我们在 x86_64 的机器上使用 C 语言中调用函数时，参数都是通过寄存器和栈传递的，其中：
1、六个以及六个以下的参数会按照顺序分别使用 edi、esi、edx、ecx、r8d 和 r9d 六个寄存器传递；
2、六个以上的参数会使用栈传递，函数的参数会以从右到左的顺序依次存入栈中；
而函数的返回值是通过 eax 寄存器进行传递的，由于只使用一个寄存器存储返回值，所以 C 语言的函数不能同时返回多个值。

• Go 语言

"".main STEXT size=68 args=0x0 locals=0x28
    0x0000 00000 (main.go:7)    MOVQ    (TLS), CX
    0x0009 00009 (main.go:7)    CMPQ    SP, 16(CX)
    0x000d 00013 (main.go:7)    JLS 61
    0x000f 00015 (main.go:7)    SUBQ    $40, SP      // 分配 40 字节栈空间
    0x0013 00019 (main.go:7)    MOVQ    BP, 32(SP)   // 将基址指针存储到栈上
    0x0018 00024 (main.go:7)    LEAQ    32(SP), BP
    0x001d 00029 (main.go:8)    MOVQ    $66, (SP)    // 第一个参数
    0x0025 00037 (main.go:8)    MOVQ    $77, 8(SP)   // 第二个参数
    0x002e 00046 (main.go:8)    CALL    "".myFunction(SB)
    0x0033 00051 (main.go:9)    MOVQ    32(SP), BP
    0x0038 00056 (main.go:9)    ADDQ    $40, SP
    0x003c 00060 (main.go:9)    RET

可以看到，go中的参数直接就是保存在栈上的

• 思考

C 语言和 Go 语言在设计函数的调用惯例时选择也不同的实现。C 语言同时使用寄存器和栈传递参数，使用 eax 寄存器传递返回值；而 Go 语言使用栈传递参数和返回值。我们可以对比一下这两种设计的优点和缺点：

• C 语言的方式能够极大地减少函数调用的额外开销，但是也增加了实现的复杂度；
  • CPU 访问栈的开销比访问寄存器高几十倍
  • 需要单独处理函数参数过多的情况；
• Go 语言的方式能够降低实现的复杂度并支持多返回值，但是牺牲了函数调用的性能；
  • 不需要考虑超过寄存器数量的参数应该如何传递；
  • 不需要考虑不同架构上的寄存器差异；
  • 函数入参和出参的内存空间需要在栈上进行分配；

Go 语言使用栈作为参数和返回值传递的方法是综合考虑后的设计，选择这种设计意味着编译器会更加简单、更容易维护。

参数传递

传值：函数调用时会对参数进行拷贝，被调用方和调用方两者持有不相关的两份数据；
传引用：函数调用时会传递参数的指针，被调用方和调用方两者持有相同的数据，任意一方做出的修改都会影响另一方。

我们重点看一下传引用是不是真的“传引用”

type MyStruct struct {
    i int
    j int
}

func myFunction(ms *MyStruct) {
    ptr := unsafe.Pointer(ms)
    for i := 0; i < 2; i++ {
        c := (*int)(unsafe.Pointer((uintptr(ptr) + uintptr(8*i))))
        *c += i + 1
        fmt.Printf("[%p] %d\n", c, *c)
    }
}

func main() {
    a := &MyStruct{i: 40, j: 50}
    myFunction(a)
    fmt.Printf("[%p] %v\n", a, a)
}

$ go run main.go
[0xc000018180] 41
[0xc000018188] 52
[0xc000018180] &{41 52}


$ go tool compile -S -N -l main.go
"".myFunction STEXT nosplit size=20 args=0x10 locals=0x0
    0x0000 00000 (main.go:8)    MOVQ    $0, "".~r1+16(SP) // 初始化返回值
    0x0009 00009 (main.go:9)    MOVQ    "".ms+8(SP), AX   // 复制引用
    0x000e 00014 (main.go:9)    MOVQ    AX, "".~r1+16(SP) // 返回引用
    0x0013 00019 (main.go:9)    RET

可以看到，底层值确实是改变了，但是结合下面的汇编代码，可以得到一个结论：将指针作为参数传入某一个函数时，在函数内部会对指针进行复制，也就是会同时出现两个指针指向原有的内存空间，所以 Go 语言中传指针其实也是传值。

引用

• go语言圣经 - 函数
• GO语言变量逃逸分析
• 函数调用

---

欢迎大家关注我的公众号

半亩房顶