[golang] 函数调用Go 通过栈传递函数的参数和返回值，在调用函数之前会在栈上为返回值分配合适的内存空间，随后将入

概述

调用惯例

package main

func myFunction(a, b int) (int, int) {
    return a + b, a - b
}

func main() {
    myFunction(66, 77)
}

上述的 myFunction 函数接受两个整数并返回两个整数，main 函数在调用 myFunction 时将 66 和 77 两个参数传递到当前函数中，使用 go tool compile -S -N -l main.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

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

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

myFunction 入参的压栈顺序和 C 语言一样，都是从右到左，即第一个参数 66 在栈顶的 SP ~ SP+8，第二个参数存储在 SP+8 ~ SP+16 的空间中。
当准备好函数的入参之后，会调用汇编指令 CALL "".myFunction(SB)，这个指令首先会将 main 的返回地址存入栈中，然后改变当前的栈指针 SP 并执行 myFunction 的汇编指令。

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

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

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

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

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

参数传递

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

传值：函数调用时会对参数进行拷贝，被调用方和调用方两者持有不相关的两份数据；
传引用：函数调用时会传递参数的指针，被调用方和调用方两者持有相同的数据，任意一方做出的修改都会影响另一方。 Go 语言选择了传值的方式，无论是传递基本类型、结构体还是指针，都会对传递的参数进行拷贝。

整型和数组

如下所示的函数 myFunction 接收了两个参数，整型变量 i 和数组 arr，这个函数会将传入的两个参数的地址打印出来，在最外层的主函数也会在 myFunction 函数调用前后分别打印两个参数的地址。

package main

import "fmt"

func myFunction(i int, arr [2]int) {
    i = 29
    arr[1] = 88
    fmt.Printf("in my_funciton - i=(%d, %p) arr=(%v, %p)\n", i, &i, arr, &arr)
}

func main() {
    i := 30
    arr := [2]int{66, 77}
    fmt.Printf("before calling - i=(%d, %p) arr=(%v, %p)\n", i, &i, arr, &arr)
    myFunction(i, arr)
    fmt.Printf("after  calling - i=(%d, %p) arr=(%v, %p)\n", i, &i, arr, &arr)
}

go run main.go
before calling - i=(30, 0xc000016090) arr=([66 77], 0xc0000160a0)
in my_funciton - i=(29, 0xc000016098) arr=([66 88], 0xc0000160c0)
after  calling - i=(30, 0xc000016090) arr=([66 77], 0xc0000160a0)

通过命令运行这段代码时会发现，main 函数和被调用者 myFunction 中参数的地址是完全不同的。在 myFunction 中对参数的修改也仅仅影响了当前函数，并没有影响调用方 main 函数，所以能得出如下结论：Go 语言的整型和数组类型都是值传递的，也就是在调用函数时会对内容进行拷贝。需要注意的是如果当前数组的大小非常的大，这种传值的方式会对性能造成比较大的影响。

结构体和指针

package main

import "fmt"

type MyStruct struct {
    i int
}

func myFunction(a MyStruct, b *MyStruct) {
    a.i = 31
    b.i = 41
    fmt.Printf("in my_function - a=(%d, %p) b=(%v, %p)\n", a, &a, b, &b)
}

func main() {
    a := MyStruct{i: 30}
    b := &MyStruct{i: 40}
    fmt.Printf("before calling - a=(%d, %p) b=(%v, %p)\n", a, &a, b, &b)
    myFunction(a, b)
    fmt.Printf("after calling  - a=(%d, %p) b=(%v, %p)\n", a, &a, b, &b)
}

go run main.go
before calling - a=({30}, 0xc0000b4008) b=(&{40}, 0xc0000ae018)
in my_function - a=({31}, 0xc0000b4020) b=(&{41}, 0xc0000ae028)
after calling  - a=({30}, 0xc0000b4008) b=(&{41}, 0xc0000ae018)

从上述运行的结果可以得出如下结论：

传递结构体时：会拷贝结构体中的全部内容；
传递结构体指针时：会拷贝结构体指针；修改结构体指针是改变了指针指向的结构体，b.i 可以被理解成 (*b).i，也就是我们先获取指针 b 背后的结构体，再修改结构体的成员变量。

package main

import (
    "fmt"
    "unsafe"
)

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
[0xc0000b4010] 41
[0xc0000b4018] 52
[0xc0000b4010] &{41 52}

通过指针修改结构体中的成员变量，结构体在内存中是一片连续的空间，指向结构体的指针也是指向这个结构体的首地址。将 MyStruct 指针修改成 int 类型的，那么访问新指针就会返回整型变量 i，将指针移动 8 个字节之后就能获取下一个成员变量 j。
使用 go tool compile 进行编译会得到如下的结果。

type MyStruct struct {
    i int
    j int
}

func myFunction(ms *MyStruct) *MyStruct {
    return ms
}

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

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

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

小结

Go 通过栈传递函数的参数和返回值，在调用函数之前会在栈上为返回值分配合适的内存空间，随后将入参从右到左按顺序压栈并拷贝参数，返回值会被存储到调用方预留好的栈空间上，可以简单总结出以下几条规则：

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

参阅

Go 语言设计与实现