4.1 函数调用

函数是 Go 语言中的一等公民，理解和掌握函数的调用过程是我们深入学习 Go 无法跳过的，本节将从函数的调用惯例和参数的传递方法两个方面分别介绍函数的执行过程。

4.1.1 调用惯例

无论是系统级编程语言 C 和 Go，还是脚本语言 Ruby 和 Python，这些编程语言在调用函数时往往都使用相同的语法：

  1. somefunction(arg0, arg1)

虽然它们调用函数的语法很相似，但是它们的调用惯例却可能大不相同。调用惯例是调用方和被调用方对于参数和返回值传递的约定，我们将在这里为各位读者分别介绍 C 和 Go 语言的调用惯例。

C 语言

我们先来研究 C 语言的调用惯例，使用 GCC1 和 Clang2 编译器将 C 语言编译成汇编代码是分析它调用惯例的最好方法，从汇编语言中可以一窥函数调用的具体过程。

GCC 和 Clang 编译相同 C 语言代码可能会生成不同的汇编指令，不过生成的代码在结构上不会有太大的区别，所以对只想理解调用惯例的人来说没有太多影响。作者在本节中选择使用 GCC 编译器来编译 C 语言：

  1. $ gcc --version
  2. gcc (Ubuntu 4.8.2-19ubuntu1) 4.8.2
  3. Copyright (C) 2013 Free Software Foundation, Inc.
  4. This is free software; see the source for copying conditions.  There is NO
  5. warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

假设我们有以下的 C 语言代码，代码中只包含两个函数，其中一个是主函数 main，另一个是我们定义的函数 my_function：

  1. // ch04/my_function.c
  2. int my_function(int arg1, int arg2) {
  3.     return arg1 + arg2;
  4. }
  6. int main() {
  7.     int i = my_function(1, 2);
  8. }

我们可以使用 cc -S my_function.c 命令将上述文件编译成如下所示的汇编代码：

  1. main:
  2.     pushq    %rbp
  3.     movq    %rsp, %rbp
  4.     subq    $16, %rsp
  5.     movl    $2, %esi  // 设置第二个参数
  6.     movl    $1, %edi  // 设置第一个参数
  7.     call    my_function
  8.     movl    %eax, -4(%rbp)
  9. my_function:
  10.     pushq    %rbp
  11.     movq    %rsp, %rbp
  12.     movl    %edi, -4(%rbp)    // 取出第一个参数，放到栈上
  13.     movl    %esi, -8(%rbp)    // 取出第二个参数，放到栈上
  14.     movl    -8(%rbp), %eax    // eax = edi = 1
  15.     movl    -4(%rbp), %edx    // edx = esi = 2
  16.     addl    %edx, %eax        // eax = eax + edx = 1 + 2 = 3
  17.     popq    %rbp

我们按照 my_function 函数调用前、调用时以及调用后三个部分分析上述调用过程：

  • 在 my_function 调用之前，调用方 main 函数将 my_function 的两个参数分别存到 edi 和 esi 寄存器中；
  • 在 my_function 执行时，它会将寄存器 edi 和 esi 中的数据存储到 eax 和 edx 两个寄存器中，随后通过汇编指令 addl 计算两个入参之和；
  • 在 my_function 调用之后，使用寄存器 eax 传递返回值，main 函数将 my_function 的返回值存储到栈上的 i 变量中；

当 my_function 函数的入参增加至八个，这时重新编译当前的程序可以会得到不同的汇编语言：

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

main 函数调用 my_function 时，前六个参数是使用 edi、esi、edx、ecx、r8d 和 r9d 六个寄存器传递的。寄存器的使用顺序也是调用惯例的一部分，函数的第一个参数一定会使用 edi 寄存器，第二个参数使用 esi 寄存器，以此类推。

最后的两个参数与前面的完全不同，调用方 main 函数通过传递这两个参数，图 4-1 展示了 main 函数在调用 my_function 前的栈信息：

c-function-call-stack

图 4-1 C 语言 main 函数的调用栈

上图中 rbp 寄存器的作用是存储函数调用栈的基址指针，即属于 main 函数的栈空间的起始位置，而另一个寄存器 rsp 存储的是 main 函数调用栈结束的位置，这两个寄存器共同表示了一个函数的栈空间。

在调用 my_function 之前，main 函数通过 subq $16, %rsp 指令分配了 16 个字节的栈地址，随后将第六个以上的参数按照从右到左的顺序存入栈中，即第八个和第七个，余下的六个参数会通过寄存器传递，接下来运行的 call my_function 指令会调用 my_function 函数：

  1. my_function:
  2.     pushq    %rbp
  3.     movq    %rsp, %rbp
  4.     movl    %edi, -4(%rbp)    // rbp-4 = edi = 1
  5.     movl    %esi, -8(%rbp)    // rbp-8 = esi = 2
  6.     ...
  7.     movl    -8(%rbp), %eax    // eax = 2
  8.     movl    -4(%rbp), %edx    // edx = 1
  9.     addl    %eax, %edx        // edx = eax + edx = 3
  10.     ...
  11.     movl    16(%rbp), %eax    // eax = 7
  12.     addl    %eax, %edx        // edx = eax + edx = 28
  13.     movl    24(%rbp), %eax    // eax = 8
  14.     addl    %edx, %eax        // edx = eax + edx = 36
  15.     popq    %rbp

my_function 会先将寄存器中的全部数据转移到栈上，然后利用 eax 寄存器计算所有入参的和并返回结果。

我们可以将本节的发现和分析简单总结成 —— 当我们在 x86_64 的机器上使用 C 语言中调用函数时，参数都是通过寄存器和栈传递的，其中：

  • 六个以及六个以下的参数会按照顺序分别使用 edi、esi、edx、ecx、r8d 和 r9d 六个寄存器传递；
  • 六个以上的参数会使用栈传递，函数的参数会以从右到左的顺序依次存入栈中；

而函数的返回值是通过 eax 寄存器进行传递的，由于只使用一个寄存器存储返回值，所以 C 语言的函数不能同时返回多个值。

Go 语言

分析了 C 语言函数的调用惯例之后，我们再来剖析一下 Go 语言中函数的调用惯例。我们以下面这个非常简单的代码片段为例简要分析一下：

  1. package main
  3. func myFunction(a, b int) (int, int) {
  4.     return a + b, a - b
  5. }
  7. func main() {
  8.     myFunction(66, 77)
  9. }

上述的 myFunction 函数接受两个整数并返回两个整数，main 函数在调用 myFunction 时将 66 和 77 两个参数传递到当前函数中，使用 go tool compile -S -N -l main.go 命令编译上述代码可以得到如下所示的汇编指令：

注：如果编译时不使用 -N -l 参数，编译器会对汇编代码进行优化，编译结果会有较大差别。

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

根据 main 函数生成的汇编指令，我们可以分析出 main 函数调用 myFunction 之前的栈情况：

golang-function-call-stack-before-calling

图 4-2 Go 语言 main 函数的调用栈

main 函数通过 SUBQ $40, SP 指令一共在栈上分配了 40 字节的内存空间：

空间大小作用
SP+32 ~ BP8 字节main 函数的栈基址指针
SP+16 ~ SP+3216 字节函数 myFunction 的两个返回值
SP ~ SP+1616 字节函数 myFunction 的两个参数

myFunction 入参的压栈顺序和 C 语言一样，都是从右到左，即第一个参数 66 在栈顶的 SP ~ SP+8，第二个参数存储在 SP+8 ~ SP+16 的空间中。

当我们准备好函数的入参之后，会调用汇编指令 CALL "".myFunction(SB)，这个指令首先会将 main 的返回地址存入栈中，然后改变当前的栈指针 SP 并开始执行 myFunction 的汇编指令：

  1. "".myFunction STEXT nosplit size=49 args=0x20 locals=0x0
  2.     0x0000 00000 (main.go:3)    MOVQ    $0, "".~r2+24(SP) // 初始化第一个返回值
  3.     0x0009 00009 (main.go:3)    MOVQ    $0, "".~r3+32(SP) // 初始化第二个返回值
  4.     0x0012 00018 (main.go:4)    MOVQ    "".a+8(SP), AX    // AX = 66
  5.     0x0017 00023 (main.go:4)    ADDQ    "".b+16(SP), AX   // AX = AX + 77 = 143
  6.     0x001c 00028 (main.go:4)    MOVQ    AX, "".~r2+24(SP) // (24)SP = AX = 143
  7.     0x0021 00033 (main.go:4)    MOVQ    "".a+8(SP), AX    // AX = 66
  8.     0x0026 00038 (main.go:4)    SUBQ    "".b+16(SP), AX   // AX = AX - 77 = -11
  9.     0x002b 00043 (main.go:4)    MOVQ    AX, "".~r3+32(SP) // (32)SP = AX = -11
  10.     0x0030 00048 (main.go:4)    RET

从上述的汇编代码中我们可以看出，当前函数在执行时首先会将 main 函数中预留的两个返回值地址置成 int 类型的默认值 0，然后根据栈的相对位置获取参数并进行加减操作并将值存回栈中，在 myFunction 函数返回之间，栈中的数据如图 4-3 所示：

golang-function-call-stack-before-return

图 4-3 myFunction 函数返回前的栈

在 myFunction 返回之后，main 函数会通过以下的指令来恢复栈基址指针并销毁已经失去作用的 40 字节的栈空间：

  1.     0x0033 00051 (main.go:9)    MOVQ    32(SP), BP
  2.     0x0038 00056 (main.go:9)    ADDQ    $40, SP
  3.     0x003c 00060 (main.go:9)    RET

通过分析 Go 语言编译后的汇编指令，我们发现 Go 语言使用栈传递参数和接收返回值，所以它只需要在栈上多分配一些内存就可以返回多个值。

思考

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

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

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

4.1.2 参数传递

除了函数的调用惯例之外，Go 语言在传递参数时是传值还是传引用也是一个有趣的问题，这个问题影响的是当我们在函数中对入参进行修改时会不会影响调用方看到的数据。我们先来介绍一下传值和传引用两者的区别：

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

不同语言会选择不同的方式传递参数，Go 语言选择了传值的方式，无论是传递基本类型、结构体还是指针，都会对传递的参数进行拷贝。本节剩下的内容将会验证这个结论的正确性。

整型和数组

我们先来分析 Go 语言是如何传递基本类型和数组的。如下所示的函数 myFunction 接收了两个参数，整型变量 i 和数组 arr，这个函数会将传入的两个参数的地址打印出来，在最外层的主函数也会在 myFunction 函数调用前后分别打印两个参数的地址：

  1. func myFunction(i int, arr [2]int) {
  2.     fmt.Printf("in my_funciton - i=(%d, %p) arr=(%v, %p)\n", i, &i, arr, &arr)
  3. }
  5. func main() {
  6.     i := 30
  7.     arr := [2]int{66, 77}
  8.     fmt.Printf("before calling - i=(%d, %p) arr=(%v, %p)\n", i, &i, arr, &arr)
  9.     myFunction(i, arr)
  10.     fmt.Printf("after  calling - i=(%d, %p) arr=(%v, %p)\n", i, &i, arr, &arr)
  11. }
  13. $ go run main.go
  14. before calling - i=(30, 0xc00009a000) arr=([66 77], 0xc00009a010)
  15. in my_funciton - i=(30, 0xc00009a008) arr=([66 77], 0xc00009a020)
  16. after  calling - i=(30, 0xc00009a000) arr=([66 77], 0xc00009a010)

当我们通过命令运行这段代码我们会发现，main 函数和被调用者 myFunction 中参数的地址是完全不同的。

不过从 main 函数的角度来看，在调用 myFunction 前后，整数 i 和数组 arr 两个参数的地址都没有变化。那么如果我们在 myFunction 函数内部对参数进行修改是否会影响 main 函数中的变量呢？我们更新 myFunction 函数并重新执行这段代码：

  1. func myFunction(i int, arr [2]int) {
  2.     i = 29
  3.     arr[1] = 88
  4.     fmt.Printf("in my_funciton - i=(%d, %p) arr=(%v, %p)\n", i, &i, arr, &arr)
  5. }
  7. $ go run main.go
  8. before calling - i=(30, 0xc000072008) arr=([66 77], 0xc000072010)
  9. in my_funciton - i=(29, 0xc000072028) arr=([66 88], 0xc000072040)
  10. after  calling - i=(30, 0xc000072008) arr=([66 77], 0xc000072010)

你可以看到在 myFunction 中对参数的修改也仅仅影响了当前函数，并没有影响调用方 main 函数，所以我们能给出如下的结论 - Go 语言中对于整型和数组类型的参数都是值传递的，也就是在调用函数时会对内容进行拷贝，需要注意的是如果当前数组的大小非常的大，这种传值方式就会对性能造成比较大的影响。

结构体和指针

接下来我们继续分析 Go 语言另外两种常见类型 —— 结构体和指针。在这段代码中定义一个只包含一个成员变量的简单结构体 MyStruct 以及接受两个参数的 myFunction 方法：

  1. type MyStruct struct {
  2.     i int
  3. }
  5. func myFunction(a MyStruct, b *MyStruct) {
  6.     a.i = 31
  7.     b.i = 41
  8.     fmt.Printf("in my_function - a=(%d, %p) b=(%v, %p)\n", a, &a, b, &b)
  9. }
  11. func main() {
  12.     a := MyStruct{i: 30}
  13.     b := &MyStruct{i: 40}
  14.     fmt.Printf("before calling - a=(%d, %p) b=(%v, %p)\n", a, &a, b, &b)
  15.     myFunction(a, b)
  16.     fmt.Printf("after calling  - a=(%d, %p) b=(%v, %p)\n", a, &a, b, &b)
  17. }
  19. $ go run main.go
  20. before calling - a=({30}, 0xc000018178) b=(&{40}, 0xc00000c028)
  21. in my_function - a=({31}, 0xc000018198) b=(&{41}, 0xc00000c038)
  22. after calling  - a=({30}, 0xc000018178) b=(&{41}, 0xc00000c028)

从运行的结果我们可以得出如下结论：

  • 传递结构体时：会对结构体中的全部内容进行拷贝；
  • 传递结构体指针时：会对结构体指针进行拷贝；

对结构体指针的修改是改变了指针指向的结构体，b.i 可以被理解成 (*b).i，也就是我们先获取指针 b 背后的结构体，再修改结构体的成员变量。我们简单修改上述代码，分析一下 Go 语言结构体在内存中的布局：

  1. type MyStruct struct {
  2.     i int
  3.     j int
  4. }
  6. func myFunction(ms *MyStruct) {
  7.     ptr := unsafe.Pointer(ms)
  8.     for i := 0; i < 2; i++ {
  9.         c := (*int)(unsafe.Pointer((uintptr(ptr) + uintptr(8*i))))
  10.         *c += i + 1
  11.         fmt.Printf("[%p] %d\n", c, *c)
  12.     }
  13. }
  15. func main() {
  16.     a := &MyStruct{i: 40, j: 50}
  17.     myFunction(a)
  18.     fmt.Printf("[%p] %v\n", a, a)
  19. }
  21. $ go run main.go
  22. [0xc000018180] 41
  23. [0xc000018188] 52
  24. [0xc000018180] &{41 52}

在这段代码中，我们通过指针的方式修改结构体中的成员变量，结构体在内存中是一片连续的空间，指向结构体的指针也是指向这个结构体的首地址。将 MyStruct 指针修改成 int 类型的，那么访问新指针就会返回整型变量 i，将指针移动 8 个字节之后就能获取下一个成员变量 j。

如果我们将上述代码简化成如下所示的代码片段并使用 go tool compile 进行编译会得到如下的结果：

  1. type MyStruct struct {
  2.     i int
  3.     j int
  4. }
  6. func myFunction(ms *MyStruct) *MyStruct {
  7.     return ms
  8. }
  10. $ go tool compile -S -N -l main.go
  11. "".myFunction STEXT nosplit size=20 args=0x10 locals=0x0
  12.     0x0000 00000 (main.go:8)    MOVQ    $0, "".~r1+16(SP) // 初始化返回值
  13.     0x0009 00009 (main.go:9)    MOVQ    "".ms+8(SP), AX   // 复制引用
  14.     0x000e 00014 (main.go:9)    MOVQ    AX, "".~r1+16(SP) // 返回引用
  15.     0x0013 00019 (main.go:9)    RET

在这段汇编语言中我们发现当参数是指针时，也会使用 MOVQ "".ms+8(SP), AX 指令对引用进行复制，然后将复制后的指针作为返回值传递回调用方。

golang-pointer-as-argument

图 4-4 Go 语言指针参数

所以将指针作为参数传入某一个函数时，在函数内部会对指针进行复制，也就是会同时出现两个指针指向原有的内存空间，所以 Go 语言中『传指针』也是传值。

传值

当我们对 Go 语言中大多数常见的数据结构进行验证之后，其实就能够推测出 Go 语言在传递参数时其实使用的就是传值的方式，接收方收到参数时会对这些参数进行复制；了解到这一点之后，在传递数组或者内存占用非常大的结构体时，我们在一些函数中应该尽量使用指针作为参数类型来避免发生大量数据的拷贝而影响性能。

4.1.3 小结

这一节我们详细分析了 Go 语言的调用惯例，包括传递参数和返回值的过程和原理。Go 通过栈传递函数的参数和返回值，在调用函数之前会在栈上为返回值分配合适的内存空间，随后将入参从右到左按顺序压栈并拷贝参数，返回值会被存储到调用方预留好的栈空间上，我们可以简单总结出以下几条规则：

  • 通过堆栈传递参数，入栈的顺序是从右到左；
  • 函数返回值通过堆栈传递并由调用者预先分配内存空间；
  • 调用函数时都是传值，接收方会对入参进行复制再计算；

wechat-account-qrcode

本作品采用知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议进行许可。