转载请声明出处哦~，本篇文章发布于luozhiyun的博客：https://www.luozhiyun.com/archives/518

本文使用的go的源码 1.15.7

前言

函数调用类型

这篇文章中函数调用（Function Calls）中的函数指的是 Go 中的任意可执行代码块。在 《Go 1.1 Function Calls》中提到了，在 Go 中有这四类函数：

  • top-level func
  • method with value receiver
  • method with pointer receiver
  • func literal

top-level func 就是我们平常写的普通函数：

func TopLevel(x int) {}

而 method with value receiver & method with pointer receiver 指的是结构体方法的值接收者方法与指针接收者方法。

结构体方法能给用户自定义的类型添加新的行为。它和函数的区别在于方法有一个接收者，给一个函数添加一个接收者，那么它就变成了方法。接收者可以是值接收者 value receiver，也可以是指针接收者 pointer receiver。

我们拿Man和Woman两个简单的结构体举例：

type Man struct {

}

type Woman struct {

}

func (*Man) Say() {

}

func (Woman) Say() {

}

上面的例子中：(*Man).Say()使用的是指针接收者 pointer receiver；(Woman) Say()是值接收者 value receiver；

function literal 的定义如下：

A function literal represents an anonymous function.

也就是说包含匿名函数和闭包。

下面在分析的时候也是按照这几种类型进行展开。

基础知识

在 《一文教你搞懂 Go 中栈操作 https://www.luozhiyun.com/archives/513 》中讲解了栈操作，但是对于栈上的函数调用来说还有很多知识点直接被忽略了，所以在这里继续看看函数调用相关知识。

如果没有看过上面提到这篇文章，我这边也写一下基础知识，看过的同学可以跳过。

在现代主流机器架构上（例如x86）中，栈都是向下生长的。栈的增长方向是从高位地址到地位地址向下进行增长。

我们先来看看 plan9 的汇编函数的定义：

汇编函数

我们先来看看 plan9 的汇编函数的定义：

stack frame size：包含局部变量以及额外调用函数的参数空间；

arguments size：包含参数以及返回值大小，例如入参是 3 个 int64 类型，返回值是 1 个 int64 类型，那么返回值就是 sizeof(int64) * 4；

栈调整

栈的调整是通过对硬件 SP 寄存器进行运算来实现的，例如:

SUBQ    $24, SP  // 对 sp 做减法，为函数分配函数栈帧

...

ADDQ    $24, SP  // 对 sp 做加法 ，清除函数栈帧

由于栈是往下增长的，所以 SUBQ 对 SP 做减法的时候实际上是为函数分配栈帧，ADDQ 则是清除栈帧。

常见指令

加减法操作：

ADDQ  AX, BX   // BX += AX

SUBQ  AX, BX   // BX -= AX

数据搬运：

常数在 plan9 汇编用 $num 表示，可以为负数，默认情况下为十进制。搬运的长度是由 MOV 的后缀决定。

MOVB $1, DI      // 1 byte

MOVW $0x10, BX   // 2 bytes

MOVD $1, DX      // 4 bytes

MOVQ $-10, AX     // 8 bytes

还有一点区别是在使用 MOVQ 的时候会看到带括号和不带括号的区别。

// 加括号代表是指针的引用

MOVQ (AX), BX   // => BX = *AX 将AX指向的内存区域8byte赋值给BX

MOVQ 16(AX), BX // => BX = *(AX + 16)

// 不加括号是值的引用

MOVQ AX, BX     // => BX = AX 将AX中存储的内容赋值给BX，注意区别

地址运算：

LEAQ (AX)(AX*2), CX // => CX = AX + (AX * 2) = AX * 3

上面代码中的 2 代表 scale，scale 只能是 0、2、4、8。

函数调用分析

直接函数调用

我们这里定义一个简单的函数：

package main

func main() {

	add(1, 2)

}

func add(a, b int) int {

	return a + b

}

然后使用命令打印出汇编：

GOOS=linux GOARCH=amd64 go tool compile -S -N -l main.go

下面我们分段来看一下汇编指令以及栈的情况。先从 main 方法的调用开始：

"".main STEXT size=71 args=0x0 locals=0x20

0x0000 00000 (main.go:3)        TEXT    "".main(SB), ABIInternal, $32-0

0x0000 00000 (main.go:3)        MOVQ    (TLS), CX

0x0009 00009 (main.go:3)        CMPQ    SP, 16(CX)   ; 栈溢出检测

0x000d 00013 (main.go:3)        PCDATA  $0, $-2      ; GC 相关

0x000d 00013 (main.go:3)        JLS     64

0x000f 00015 (main.go:3)        PCDATA  $0, $-1      ; GC 相关

0x000f 00015 (main.go:3)        SUBQ    $32, SP      ; 分配了 32bytes 的栈地址

0x0013 00019 (main.go:3)        MOVQ    BP, 24(SP)   ; 将 BP 的值存储到栈上

0x0018 00024 (main.go:3)        LEAQ    24(SP), BP   ; 将刚分配的栈空间 8bytes 的地址赋值给BP

0x001d 00029 (main.go:3)        FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) ; GC 相关

0x001d 00029 (main.go:3)        FUNCDATA        $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) ; GC 相关

0x001d 00029 (main.go:4)        MOVQ    $1, (SP)     ; 将给add函数的第一个参数1，写到SP

0x0025 00037 (main.go:4)        MOVQ    $2, 8(SP)    ; 将给add函数的第二个参数2，写到SP

0x002e 00046 (main.go:4)        PCDATA  $1, $0

0x002e 00046 (main.go:4)        CALL    "".add(SB)   ; 调用 add 函数

0x0033 00051 (main.go:5)        MOVQ    24(SP), BP   ; 将栈上储存的值恢复BP

0x0038 00056 (main.go:5)        ADDQ    $32, SP      ; 增加SP的值，栈收缩，收回 32 bytes的栈空间

0x003c 00060 (main.go:5)        RET

下面来具体看看上面的汇编做了些什么：

0x0000 00000 (main.go:3)        TEXT    "".main(SB), ABIInternal, $32-0

0x0000: 当前指令相对于当前函数的偏移量；

TEXT:由于程序代码在运行期会放在内存的 .text 段中，所以TEXT 是一个指令，用来定义一个函数；

"".main(SB): 表示的是包名.函数名，这里省略了包名。SB是一个虚拟寄存器，保存了静态基地址(static-base) 指针，即我们程序地址空间的开始地址；

$32-0:$32表即将分配的栈帧大小；0指定了调用方传入的参数大小。

0x000d 00013 (main.go:3)        PCDATA  $0, $-2      ; GC 相关

0x000f 00015 (main.go:3)        PCDATA  $0, $-1      ; GC 相关

0x001d 00029 (main.go:3)        FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) ; GC 相关

0x001d 00029 (main.go:3)        FUNCDATA        $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) ; GC 相关

The FUNCDATA and PCDATA directives contain information for use by the garbage collector; they are introduced by the compiler.

FUNCDATA以及PCDATA指令包含有被垃圾回收所使用的信息；这些指令是被编译器加入的。

0x000f 00015 (main.go:3)        SUBQ    $32, SP

在执行栈上调用的时候由于栈是从内存地址高位向低位增长的，所以会根据当前的栈帧大小调用SUBQ $32, SP表示分配 32bytes 的栈内存；

0x0013 00019 (main.go:3)        MOVQ    BP, 24(SP)   ; 将 BP 的值存储到栈上

0x0018 00024 (main.go:3)        LEAQ    24(SP), BP   ; 将刚分配的栈空间 8bytes 的地址赋值给BP

这里会用8 个字节(24(SP)-32(SP)) 来存储当前帧指针 BP。

0x001d 00029 (main.go:4)        MOVQ    $1, (SP)     ; 将给add函数的第一个参数1，写到SP

0x0025 00037 (main.go:4)        MOVQ    $2, 8(SP)    ; 将给add函数的第二个参数2，写到SP

参数值1会被压入到栈的(0(SP)-8(SP)) 位置；

参数值2会被压入到栈的(8(SP)-16(SP)) 位置；

需要注意的是我们这里的参数类型是 int，在 64 位中 int 是 8byte 大小。虽然栈的增长是从高地址位到低地址位，但是栈内的数据块的存放还是从低地址位到高地址位，指针指向的位置也是数据块的低地址位的起始位置。

综上在函数调用中，关于参数的传递我们可以知道两个信息：

  1. 参数完全通过栈传递
  2. 从参数列表的右至左压栈

下面是调用 add 函数之前的调用栈的调用详情：

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

下面我们进入到 add 函数：

"".add STEXT nosplit size=25 args=0x18 locals=0x0

0x0000 00000 (main.go:7)        TEXT    "".add(SB), NOSPLIT|ABIInternal, $0-24

0x0000 00000 (main.go:7)        FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) ; GC 相关

0x0000 00000 (main.go:7)        FUNCDATA        $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) ; GC 相关

0x0000 00000 (main.go:7)        MOVQ    $0, "".~r2+24(SP)   ; 初始化返回值

0x0009 00009 (main.go:8)        MOVQ    "".a+8(SP), AX      ; AX = 1

0x000e 00014 (main.go:8)        ADDQ    "".b+16(SP), AX     ; AX = AX + 2

0x0013 00019 (main.go:8)        MOVQ    AX, "".~r2+24(SP)   ; (24)SP = AX = 3

0x0018 00024 (main.go:8)        RET

由于会改变当前的栈指针 SP，所以在看这个函数的汇编代码之前我们先看一下栈中的数据情况，这里我们可以实际 dlv 操作一下：

在进入到 add 函数之前的时候我们可以用 regs 打印一下当前的 Rsp 和 Rbp 寄存器：

(dlv) regs

   Rsp = 0x000000c000044760

   Rbp = 0x000000c000044778

 	 ...

(dlv)  print uintptr(0x000000c000044778)

824634001272

(dlv)  print uintptr(0x000000c000044760)

824634001248

Rsp 和 Rbp 的地址值是相差 24 bytes ，是符合我们上面图例的。

然后进入到 add 函数之后，我们可以用 regs 打印一下当前的 Rsp 和 Rbp 寄存器：

(dlv) regs

   Rsp = 0x000000c000044758

   Rbp = 0x000000c000044778

   ...

(dlv)  print uintptr(0x000000c000044778)

824634001272

(dlv)  print uintptr(0x000000c000044758)

824634001240

Rsp 和 Rbp 的地址值是相差 32 bytes。因为在调用 CALL 指令的时候将函数的返回地址(8 字节值)推到栈顶。

那么这个时候，本来参数值1和参数值2的位置也会改变：

本来参数值1在栈的(0(SP)-8(SP)) 位置，会移动到栈的(8(SP)-16(SP)) 位置；

本来参数值2在栈的(8(SP)-16(SP)) 位置，会移动到栈的(16(SP)-24(SP)) 位置；

我们也可以通过 dlv 将参数值打印出来：

(dlv) print *(*int)(uintptr(0x000000c000044758)+8)

1

(dlv) print *(*int)(uintptr(0x000000c000044758)+16)

2

下面是调用 add 函数之后的调用栈的调用详情：

从上面的 add 函数调用分析我们也可以得出以下结论：

  • 返回值通过栈传递，返回值的栈空间在参数之前

调用完毕之后我们看一下 add 函数的返回：

0x002e 00046 (main.go:4)        CALL    "".add(SB)   ; 调用 add 函数

0x0033 00051 (main.go:5)        MOVQ    24(SP), BP   ; 将栈上储存的值恢复BP

0x0038 00056 (main.go:5)        ADDQ    $32, SP      ; 增加SP的值，栈收缩，收回 32 bytes的栈空间

0x003c 00060 (main.go:5)        RET

在调用完 add 函数之后会恢复 BP 指针，然后调用 ADDQ 指令将增加SP的值，执行栈收缩。从这里可以看出最后调用方（caller）会负责栈的清理工作。

小结以下栈的调用规则：

  1. 参数完全通过栈传递
  2. 从参数列表的右至左压栈
  3. 返回值通过栈传递，返回值的栈空间在参数之前
  4. 函数调用完毕后，调用方（caller）会负责栈的清理工作

结构体方法：值接收者与指针接收者

上面我们也讲到了，Go 的方法接收者有两种，一种是值接收者(value receiver)，一种是指针接收者(pointer receiver)。下面我们通过一个例子来进行说明：

package main

func main() {

	p := Point{2, 5}

	p.VIncr(10)

	p.PIncr(10)

}

type Point struct {

	X int

	Y int

}

func (p Point) VIncr(factor int) {

	p.X += factor

	p.Y += factor

}

func (p *Point) PIncr(factor int) {

	p.X += factor

	p.Y += factor

}

自己可以手动的汇编输出结合文章一起看。

调用值接收者(value receiver)方法

在汇编中，我们的结构体在汇编层面实际上就是一段连续内存，所以p := Point{2, 5} 初始化如下：

0x001d 00029 (main.go:5)        XORPS   X0, X0                  ;; 初始化寄存器 X0

0x0020 00032 (main.go:5)        MOVUPS  X0, "".p+24(SP)         ;; 初始化大小为16bytes连续内存块

0x0025 00037 (main.go:5)        MOVQ    $2, "".p+24(SP)         ;; 初始化结构体 p 参数 x

0x002e 00046 (main.go:5)        MOVQ    $5, "".p+32(SP)         ;; 初始化结构体 p 参数 y

我们这里的结构体 Point 参数是两个 int 组成，int 在 64 位机器上是 8bytes，所以这里使用 XORPS 先初始化 128-bit 大小的 X0 寄存器，然后使用 MOVUPS 将 128-bit 大小的 X0 赋值给 24(SP) 申请一块 16bytes 内存块。然后初始化 Point 的两个参数 2 和 5。

接下来就是初始化变量，然后调用 p.VIncr 方法：

0x0037 00055 (main.go:7)        MOVQ    $2, (SP)                ;; 初始化变量2

0x003f 00063 (main.go:7)        MOVQ    $5, 8(SP)               ;; 初始化变量5

0x0048 00072 (main.go:7)        MOVQ    $10, 16(SP)             ;; 初始化变量10

0x0051 00081 (main.go:7)        PCDATA  $1, $0

0x0051 00081 (main.go:7)        CALL    "".Point.VIncr(SB)      ;; 调用 value receiver 方法

到这里，调用前的栈帧结构大概是这样：

再看 p.VIncr的汇编代码：：

"".Point.VIncr STEXT nosplit size=31 args=0x18 locals=0x0

        0x0000 00000 (main.go:16)       TEXT    "".Point.VIncr(SB), NOSPLIT|ABIInternal, $0-24

        0x0000 00000 (main.go:16)       FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)

        0x0000 00000 (main.go:16)       FUNCDATA        $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)

        0x0000 00000 (main.go:17)       MOVQ    "".p+8(SP), AX          ;; AX = 8(SP) = 2

        0x0005 00005 (main.go:17)       ADDQ    "".factor+24(SP), AX    ;; AX = AX + 24(SP) = 2+10

        0x000a 00010 (main.go:17)       MOVQ    AX, "".p+8(SP)          ;; 8(SP) = AX = 12

        0x000f 00015 (main.go:18)       MOVQ    "".p+16(SP), AX         ;; AX = 16(SP) = 5

        0x0014 00020 (main.go:18)       ADDQ    "".factor+24(SP), AX    ;; AX = AX + 24(SP) = 5+10

        0x0019 00025 (main.go:18)       MOVQ    AX, "".p+16(SP)         ;; 16(SP) = AX  = 15

        0x001e 00030 (main.go:19)       RET

到这里调用后的栈帧结构大概是这样：

从这上面的分析我们可以看到，caller 在调用 VIncr 方法的时候实际上是将值赋值到栈上给 VIncr 当作参数在调用，对于在 VIncr 中的修改实际上都是修改栈上最后两个参数值。

调用指针接收者(pointer receiver)方法

在main里面，调用的指令是：

0x0056 00086 (main.go:8)        LEAQ    "".p+24(SP), AX         ;; 将 24(SP) 地址值赋值到 AX

0x005b 00091 (main.go:8)        MOVQ    AX, (SP)                ;; 将AX的值作为第一个参数,参数值是 2

0x005f 00095 (main.go:8)        MOVQ    $10, 8(SP)              ;; 将 10 作为第二个参数

0x0068 00104 (main.go:8)        CALL    "".(*Point).PIncr(SB)   ;; 调用 pointer receiver 方法

从上面的汇编我们知道，AX 里面实际上是存放的 24(SP) 的地址值，并且将 AX 存放的指针也赋值给了 SP 的第一个参数。也就是 AX 和 SP 的第一个参数的值都是 24(SP) 的地址值。

整个栈帧结构应该如下图所示：

再看 p.PIncr的汇编代码：

"".(*Point).PIncr STEXT nosplit size=53 args=0x10 locals=0x0

        0x0000 00000 (main.go:21)       TEXT    "".(*Point).PIncr(SB), NOSPLIT|ABIInternal, $0-16

        0x0000 00000 (main.go:21)       FUNCDATA        $0, gclocals·1a65e721a2ccc325b382662e7ffee780(SB)

        0x0000 00000 (main.go:21)       FUNCDATA        $1, gclocals·69c1753bd5f81501d95132d08af04464(SB)

        0x0000 00000 (main.go:22)       MOVQ    "".p+8(SP), AX          ;; 将8(SP) 处存放地址值赋值到 AX

        0x0005 00005 (main.go:22)       TESTB   AL, (AX)

        0x0007 00007 (main.go:22)       MOVQ    "".p+8(SP), CX          ;; 将8(SP) 处存放地址值赋值到 CX

        0x000c 00012 (main.go:22)       TESTB   AL, (CX)

        0x000e 00014 (main.go:22)       MOVQ    (AX), AX                ;; 从 AX 里读到内存地址，从内存地址里拿到值，再读到AX

        0x0011 00017 (main.go:22)       ADDQ    "".factor+16(SP), AX    ;; 将参数值 10 加到 AX 里, AX = AX + 10 =12

        0x0016 00022 (main.go:22)       MOVQ    AX, (CX)                ;; 将计算结果写入到 CX 的内存地址

        0x0019 00025 (main.go:23)       MOVQ    "".p+8(SP), AX          ;; 将 8(SP) 处的地址值赋值给 AX

        0x001e 00030 (main.go:23)       TESTB   AL, (AX)

        0x0020 00032 (main.go:23)       MOVQ    "".p+8(SP), CX          ;; 将 8(SP) 处的地址值赋值给 CX

        0x0025 00037 (main.go:23)       TESTB   AL, (CX)

        0x0027 00039 (main.go:23)       MOVQ    8(AX), AX               ;; 从 AX 里读到内存地址值+8 ，然后从内存地址里拿到值，再读到AX

        0x002b 00043 (main.go:23)       ADDQ    "".factor+16(SP), AX    ;; AX = 5+10

        0x0030 00048 (main.go:23)       MOVQ    AX, 8(CX)               ;; 将计算结果 15 写入到 CX+8 的内存地址

        0x0034 00052 (main.go:24)       RET

在这个方法里面实际上还是有点意思的，并且有点绕，因为很多地方实际上都是对指针的操作，从而做到任意一方做出的修改都会影响另一方。

下面我们一步步分析：

0x0000 00000 (main.go:22)       MOVQ    "".p+8(SP), AX

0x0007 00007 (main.go:22)       MOVQ    "".p+8(SP), CX

0x000e 00014 (main.go:22)       MOVQ    (AX), AX

这两句指令分别是将 8(SP) 里面存放的指针赋值给了 AX 和 CX，然后从 AX内存地址里拿到值，再写到 AX。

0x0011 00017 (main.go:22)       ADDQ    "".factor+16(SP), AX

0x0016 00022 (main.go:22)       MOVQ    AX, (CX)

这里会将传入的 16(SP) 参数与 AX 相加，那么这个时候 AX 存放的值应该是 12。然后将 AX 赋值给 CX 的内存地址指向的值，通过上面的汇编我们可以知道 CX 指向的是 8(SP) 存放的指针，所以这里会同时将 8(SP) 指针指向的值也修改了。

我们可以使用使用 dlv 输出 regs 进行验证一下：

(dlv) regs

	Rsp = 0x000000c000056748

	Rax = 0x000000000000000c

	Rcx = 0x000000c000056768

然后我们可以查看 8(SP) 和 CX 所存放的值：

(dlv) print *(*int)(uintptr(0x000000c000056748) +8  )

824634074984

(dlv) print uintptr(0x000000c000056768)

824634074984

可以看到它们都指向了同一个 32(SP) 的指针：

(dlv) print uintptr(0x000000c000056748) +32

824634074984

然后我们可以打印出这个指针具体指向的值：

(dlv) print *(*int)(824634074984)

12

这个时候栈帧的情况如下所示：

我们继续往下：

0x0019 00025 (main.go:23)       MOVQ    "".p+8(SP), AX

0x0020 00032 (main.go:23)       MOVQ    "".p+8(SP), CX

这里会将将 8(SP) 处存放的地址值赋值给 AX 和 CX；

这里我们通过单步的 step-instruction 命令让代码运行到 MOVQ "".p+8(SP), CX执行行之后，然后再查看 AX 指针位置：

(dlv) disassemble

		...

        main.go:21      0x467980        488b4c2408      mov rcx, qword ptr [rsp+0x8]

=>      main.go:21      0x467985        8401            test byte ptr [rcx], al

        main.go:21      0x467987        488b4008        mov rax, qword ptr [rax+0x8]

        ...

(dlv) regs

    Rsp = 0x000000c000056748

    Rax = 0x000000c000056768

    Rcx = 0x000000c000056768

(dlv) print uintptr(0x000000c000056768)

824634074984

可以看到 AX 与 CX 指向了同一个内存地址位置。然后我们进入到下面：

0x0027 00039 (main.go:23)       MOVQ    8(AX), AX

在前面也说过，对于结构体来说分配的是连续的代码块，在栈上 32(SP)~48(SP)都是指向变量 p 所实例化的结构体，所以在上面的打印结果中 824634074984 代表的是 变量 p.X 的值，那么 p.Y 的地址值就是 824634074984+8，我们也可以通过 dlv 打印出地址代表的值：

(dlv) print *(*int)(824634074984+8)

5

所以MOVQ 8(AX), AX实际上就是做了将地址值加 8，然后取出结果 5 赋值到 AX 上。

0x002b 00043 (main.go:23)       ADDQ    "".factor+16(SP), AX ;; AX = AX +10

0x0030 00048 (main.go:23)       MOVQ    AX, 8(CX)

到这里其实就是计算出 AX 等于 15，然后将计算结果 15 写入到 CX+8 的内存地址值指向的空间，也就做到了同时修改了 40(SP) 处指针指向的值。

到这个方法结束的时候，栈帧如下：

从上面的分析我们可以看到一件有趣的事情，在进行调用指针接收者(pointer receiver)方法调用的时候，实际上是先复制了结构体的指针到栈中，然后在方法调用中全都是基于指针的操作。

小结

通过分析我们知道在调用值接收者(value receiver)方法的时候，调用者 caller 会将参数值写入到栈上，调用函数 callee 实际上操作的是调用者 caller 栈帧上的参数值。

进行调用指针接收者(pointer receiver)方法调用的时候，和 value receiver 方法的区别是调用者 caller 写入栈的是参数的地址值，所以调用完之后可以直接体现在 receiver 的结构体中。

字面量方法 func literal

func literal 我也不知道怎么准确翻译，就叫字面量方法吧，在 Go 中这类方法主要包括匿名函数以及闭包。

匿名函数

我这里还是通过一个简单的例子来进行分析：

package main

func main() {

	f := func(x int) int {

		x += x

		return x

	}

	f(100)

}

下面我们看一下它的汇编：

        0x0000 00000 (main.go:3)        TEXT    "".main(SB), ABIInternal, $32-0

        ...

        0x001d 00029 (main.go:4)        LEAQ    "".main.func1·f(SB), DX

        0x0024 00036 (main.go:4)        MOVQ    DX, "".f+16(SP)

        0x0029 00041 (main.go:8)        MOVQ    $100, (SP)

        0x0031 00049 (main.go:8)        MOVQ    "".main.func1·f(SB), AX

        0x0038 00056 (main.go:8)        PCDATA  $1, $0

        0x0038 00056 (main.go:8)        CALL    AX

        0x003a 00058 (main.go:9)        MOVQ    24(SP), BP

        0x003f 00063 (main.go:9)        ADDQ    $32, SP

        0x0043 00067 (main.go:9)        RET

通过上面的分析相信大家应该都能看懂这段汇编是在做什么了，匿名函数实际上传递的是匿名函数的入口地址。

闭包

什么是闭包呢？在 Wikipedia 上有这么一段话形容闭包：

a closure is a record storing a function together with an environment.

闭包是由函数和与其相关的引用环境组合而成的实体，需要打起精神的是下面的闭包分析会复杂很多。

我这里还是通过一个简单的例子来进行分析：

package main

func test() func() {

	x := 100

	return func() {

		x += 100

	}

}

func main() {

	f := test()

	f() //x= 200

	f() //x= 300

	f() //x= 400

}

由于闭包是有上下文的，我们以测试例子为例，每调用一次 f() 函数，变量 x 都会发生变化。但是我们通过其他的方法调用都知道，如果变量保存在栈上那么变量会随栈帧的退出而失效，所以闭包的变量会逃逸到堆上。

我们可以进行逃逸分析进行证明：

[root@localhost gotest]$ go run -gcflags "-m -l" main.go

# command-line-arguments

./main.go:4:2: moved to heap: x

./main.go:5:9: func literal escapes to heap

可以看到变量 x 逃逸到了堆中。

下面我们直接来看看汇编：

先来看看 main 函数：

"".main STEXT size=88 args=0x0 locals=0x18

        0x0000 00000 (main.go:10)       TEXT    "".main(SB), ABIInternal, $24-0

        0x0000 00000 (main.go:10)       MOVQ    (TLS), CX

        0x0009 00009 (main.go:10)       CMPQ    SP, 16(CX)

        0x000d 00013 (main.go:10)       PCDATA  $0, $-2

        0x000d 00013 (main.go:10)       JLS     81

        0x000f 00015 (main.go:10)       PCDATA  $0, $-1

        0x000f 00015 (main.go:10)       SUBQ    $24, SP

        0x0013 00019 (main.go:10)       MOVQ    BP, 16(SP)

        0x0018 00024 (main.go:10)       LEAQ    16(SP), BP

        0x001d 00029 (main.go:10)       FUNCDATA        $0, gclocals·69c1753bd5f81501d95132d08af04464(SB)

        0x001d 00029 (main.go:10)       FUNCDATA        $1, gclocals·9fb7f0986f647f17cb53dda1484e0f7a(SB)

        0x001d 00029 (main.go:11)       PCDATA  $1, $0

        0x001d 00029 (main.go:11)       NOP

        0x0020 00032 (main.go:11)       CALL    "".test(SB)

        ...

其实这段汇编和其他的函数调用的汇编是一样的，没啥好讲的，在调用 test 函数之前就是做了一些栈的初始化工作。

下面直接看看 test 函数：

0x0000 00000 (main.go:3)        TEXT    "".test(SB), ABIInternal, $40-8

0x0000 00000 (main.go:3)        MOVQ    (TLS), CX

0x0009 00009 (main.go:3)        CMPQ    SP, 16(CX)

0x000d 00013 (main.go:3)        PCDATA  $0, $-2

0x000d 00013 (main.go:3)        JLS     171

0x0013 00019 (main.go:3)        PCDATA  $0, $-1

0x0013 00019 (main.go:3)        SUBQ    $40, SP

0x0017 00023 (main.go:3)        MOVQ    BP, 32(SP)

0x001c 00028 (main.go:3)        LEAQ    32(SP), BP

0x0021 00033 (main.go:3)        FUNCDATA        $0, gclocals·263043c8f03e3241528dfae4e2812ef4(SB)

0x0021 00033 (main.go:3)        FUNCDATA        $1, gclocals·568470801006e5c0dc3947ea998fe279(SB)

0x0021 00033 (main.go:3)        MOVQ    $0, "".~r0+48(SP)

0x002a 00042 (main.go:4)        LEAQ    type.int(SB), AX

0x0031 00049 (main.go:4)        MOVQ    AX, (SP)

0x0035 00053 (main.go:4)        PCDATA  $1, $0

0x0035 00053 (main.go:4)        CALL    runtime.newobject(SB)           ;; 申请内存

0x003a 00058 (main.go:4)        MOVQ    8(SP), AX                       ;; 将申请的内存地址写到 AX 中

0x003f 00063 (main.go:4)        MOVQ    AX, "".&x+24(SP)                ;; 将内存地址写到 24(SP) 中

0x0044 00068 (main.go:4)        MOVQ    $100, (AX)                      ;; 将100 写到 AX 保存的内存地址指向的内存中

0x004b 00075 (main.go:5)        LEAQ    type.noalg.struct { F uintptr; "".x *int }(SB), AX ;; 创建闭包结构体,并将函数地址写到 AX

0x0052 00082 (main.go:5)        MOVQ    AX, (SP)                        ;; 将 AX 中保存的函数地址写到 (SP)

0x0056 00086 (main.go:5)        PCDATA  $1, $1

0x0056 00086 (main.go:5)        CALL    runtime.newobject(SB)           ;; 申请内存

0x005b 00091 (main.go:5)        MOVQ    8(SP), AX                       ;; 将申请的内存地址写到 AX 中

0x0060 00096 (main.go:5)        MOVQ    AX, ""..autotmp_4+16(SP)        ;; 将内存地址写到 16(SP) 中

0x0065 00101 (main.go:5)        LEAQ    "".test.func1(SB), CX           ;; 将 test.func1 函数地址写到 CX

0x006c 00108 (main.go:5)        MOVQ    CX, (AX)                        ;; 将 CX 中保存的函数地址写到 AX 保存的内存地址指向的内存中

0x006f 00111 (main.go:5)        MOVQ    ""..autotmp_4+16(SP), AX        ;; 将 16(SP) 保存的内存地址写到 AX

0x0074 00116 (main.go:5)        TESTB   AL, (AX)

0x0076 00118 (main.go:5)        MOVQ    "".&x+24(SP), CX                ;; 将 24(SP) 保存的地址值写到 CX

0x007b 00123 (main.go:5)        LEAQ    8(AX), DI                       ;; 将 AX + 8 写到 DI

0x007f 00127 (main.go:5)        PCDATA  $0, $-2

0x007f 00127 (main.go:5)        CMPL    runtime.writeBarrier(SB), $0

0x0086 00134 (main.go:5)        JEQ     138

0x0088 00136 (main.go:5)        JMP     164

0x008a 00138 (main.go:5)        MOVQ    CX, 8(AX)                       ;; 将 CX 中保存的函数地址写到 AX+8

0x008e 00142 (main.go:5)        JMP     144

0x0090 00144 (main.go:5)        PCDATA  $0, $-1

0x0090 00144 (main.go:5)        MOVQ    ""..autotmp_4+16(SP), AX

0x0095 00149 (main.go:5)        MOVQ    AX, "".~r0+48(SP)

0x009a 00154 (main.go:5)        MOVQ    32(SP), BP

0x009f 00159 (main.go:5)        ADDQ    $40, SP

0x00a3 00163 (main.go:5)        RET

下面我们一步步看这段汇编：

0x002a 00042 (main.go:4)        LEAQ    type.int(SB), AX                ;; 将 type.int 函数地址值写到 AX

0x0031 00049 (main.go:4)        MOVQ    AX, (SP)                        ;; 将 AX 保存的函数地址值写到 (SP)

0x0035 00053 (main.go:4)        PCDATA  $1, $0

0x0035 00053 (main.go:4)        CALL    runtime.newobject(SB)           ;; 申请内存

0x003a 00058 (main.go:4)        MOVQ    8(SP), AX                       ;; 将申请的内存地址写到 AX 中

0x003f 00063 (main.go:4)        MOVQ    AX, "".&x+24(SP)                ;; 将内存地址写到 24(SP) 中

0x0044 00068 (main.go:4)        MOVQ    $100, (AX)

这一步其实就是将 type.int 函数地址值通过 AX 写到 (SP) 的位置，然后再调用 runtime.newobject 申请一段内存块，通过 AX 将内存地址值写到 24(SP) 相当于给变量 x 分配内存空间，最后将 x 的值设置为 100。

这个时候栈帧结构应该是这样：

0x004b 00075 (main.go:5)        LEAQ    type.noalg.struct { F uintptr; "".x *int }(SB), AX

这个结构体代表了一个闭包，然后将创建好的结构体的内存地址放到了 AX 寄存器中。

0x0052 00082 (main.go:5)        MOVQ    AX, (SP)

然后这一个汇编指令会将 AX 中保存的内存地址写入到 (SP)中。

0x0056 00086 (main.go:5)        CALL    runtime.newobject(SB)           ;; 申请内存

0x005b 00091 (main.go:5)        MOVQ    8(SP), AX                       ;; 将申请的内存地址写到 AX 中

0x0060 00096 (main.go:5)        MOVQ    AX, ""..autotmp_4+16(SP)        ;; 将内存地址写到 16(SP) 中

这里会重新申请一块内存，然后将内存地址由 AX 写入到 16(SP) 中。

0x0065 00101 (main.go:5)        LEAQ    "".test.func1(SB), CX           ;; 将 test.func1 函数地址写到 CX

0x006c 00108 (main.go:5)        MOVQ    CX, (AX)                        ;; 将 CX 中保存的函数地址写到 AX 保存的内存地址指向的内存中

0x006f 00111 (main.go:5)        MOVQ    ""..autotmp_4+16(SP), AX        ;; 将 16(SP) 保存的内存地址写到 AX

这里是将 test.func1 函数地址值写入到 CX，然后将 CX 存放的地址值写入到 AX 保存的内存地址所指向的内存。然后还将 16(SP) 保存的地址值写入 AX，其实这里 AX 保存的值并没有变，不知道为啥要生成一个这样的汇编指令。

由于 AX 内存地址是 8(SP) 写入的， 16(SP) 的内存地址是 AX 写入的，所以这一次性实际上修改了三个地方的值，具体的栈帧结构如下：

0x0076 00118 (main.go:5)        MOVQ    "".&x+24(SP), CX                ;; 将 24(SP) 保存的地址值写到 CX

0x007b 00123 (main.go:5)        LEAQ    8(AX), DI                       ;; 将 AX + 8 写到 DI

0x007f 00127 (main.go:5)        CMPL    runtime.writeBarrier(SB), $0	;; 写屏障

0x0086 00134 (main.go:5)        JEQ     138

0x0088 00136 (main.go:5)        JMP     164

0x008a 00138 (main.go:5)        MOVQ    CX, 8(AX)                       ;; 将 CX 中保存的地址写到 AX+8

24(SP) 实际上保存的是 x 变量的指针地址，这里会将这个指针地址写入到 CX 中。然后将 8(AX) 保存的值转移到 DI 中，最后将 CX 保存的值写入到 8(AX)。

到这里稍微再说一下 AX 此时的引用情况：

AX -> test.func1的地址值，也就是AX 此时指向的是 test.func1的地址值；

8(AX) -> 24(SP) 地址值 -> 100，也就是 8(AX) 保存的地址值指向的是 24(SP) 地址值， 24(SP) 地址值指向的内存保存的是100；

0x0090 00144 (main.go:5)        MOVQ    ""..autotmp_4+16(SP), AX        ;; 16(SP) 中保存的地址写入 AX

0x0095 00149 (main.go:5)        MOVQ    AX, "".~r0+48(SP)               ;; 将 AX 中保存的地址写到 48(SP)

0x009a 00154 (main.go:5)        MOVQ    32(SP), BP

0x009f 00159 (main.go:5)        ADDQ    $40, SP

这里最后会将 16(SP) 的值借 AX 写入到上 caller 的栈帧 48(SP) 上，最后做栈的收缩，callee 栈调用完毕。

调用完毕之后会回到 main 函数中，这个时候的栈帧如下：

下面再回到 main 函数的 test 函数调用后的位置：

0x0020 00032 (main.go:11)       CALL    "".test(SB)

0x0025 00037 (main.go:11)       MOVQ    (SP), DX                ;; 将(SP)保存的函数地址值写到 DX

0x0029 00041 (main.go:11)       MOVQ    DX, "".f+8(SP)          ;; 将 DX 保存的函数地址值写到 8(SP)

0x002e 00046 (main.go:12)       MOVQ    (DX), AX                ;; 将 DX 保存的函数地址值写到 AX

test 函数调用完毕之后会返回一个 test.func1 函数地址值存在栈 main 调用栈的栈顶，然后调用完 test 函数之后会将存放在 (SP) 的 test.func1 函数地址值写入到 AX 中，然后执行调用下面的指令进行调用：

0x0031 00049 (main.go:12)       CALL    AX

在进入到 test.func1 函数之前，我们现在应该知道 (SP) 里面保存的是指向 AX 的地址值。

test.func1 函数是 test 函数里封装返回的函数：

"".test.func1 STEXT nosplit size=36 args=0x0 locals=0x10

        0x0000 00000 (main.go:5)        TEXT    "".test.func1(SB), NOSPLIT|NEEDCTXT|ABIInternal, $16-0

        0x0000 00000 (main.go:5)        SUBQ    $16, SP

        0x0004 00004 (main.go:5)        MOVQ    BP, 8(SP)

        0x0009 00009 (main.go:5)        LEAQ    8(SP), BP

        0x000e 00014 (main.go:5)        MOVQ    8(DX), AX       ;; 这里实际上是获取变量 x 的地址值

        0x0012 00018 (main.go:5)        MOVQ    AX, "".&x(SP)

        0x0016 00022 (main.go:6)        ADDQ    $100, (AX)		;; 将x地址指向的值加100

        0x001a 00026 (main.go:7)        MOVQ    8(SP), BP

        0x001f 00031 (main.go:7)        ADDQ    $16, SP

        0x0023 00035 (main.go:7)        RET

由于 DX 保存的就是 AX 地址值，所以通过 8(DX) 可以获取到变量 x 的地址值写入到 AX 中。然后调用 ADDQ 指令将x地址指向的值加100。

小结

通过上面的分析，可以发现其实匿名函数就是闭包的一种，只是没有传递变量信息而已。而在闭包的调用中，会将上下文信息逃逸到堆上，避免因为栈帧调用结束而被回收。

在上面的例子闭包函数 test 的调用中，非常复杂的做了很多变量的传递，其实就是做了这几件事：

  1. 为上下文信息初始化内存块；
  2. 将上下文信息的地址值保存到 AX 寄存器中；
  3. 将闭包函数封装好的 test.func1 调用函数地址写入到 caller 的栈顶；

这里的上下文信息指的是 x 变量以及 test.func1 函数。将这两个信息地址写入到 AX 寄存器之后回到 main 函数，获取到栈顶的函数地址写入到 AX 执行 CALL AX 进行调用。

因为 x 变量地址是写入到 AX + 8 的位置上，所以在调用 test.func1 函数的时候是通过获取 AX + 8 的位置上的值从而获取到 x 变量地址从而做到改变闭包上下文信息的目的。

总结

这篇文章中，首先和大家分享了函数调用的过程是怎样的，包括参数的传递、参数压栈的顺序、函数返回值的传递。然后分析了结构体方法传递之间的区别以及闭包函数调用是怎样的。

在分析闭包的时候的时候 dlv 工具的 regs 命令和 step-instruction 命令帮助了很多，要不然指针在寄存器之间传递调用很容易绕晕，建议在看的时候可以动动手在纸上画画。

Reference

Go 函数调用 ━ 栈和寄存器视角 https://segmentfault.com/a/1190000019753885

函数 https://chai2010.cn/advanced-go-programming-book/ch3-asm/ch3-04-func.html

https://berryjam.github.io/2018/12/golang替换运行时函数体及其原理/

Go 汇编入门 https://github.com/go-internals-cn/go-internals/blob/master/chapter1_assembly_primer/README.md

plan9 assembly 完全解析 https://github.com/cch123/golang-notes/blob/master/assembly.md

Go Assembly by Example https://davidwong.fr/goasm/

https://golang.org/doc/asm

x86-64 下函数调用及栈帧原理 https://zhuanlan.zhihu.com/p/27339191

https://www.cnblogs.com/binHome/p/13034103.html

https://chai2010.cn/advanced-go-programming-book/ch3-asm/ch3-01-basic.html

Interfaces https://github.com/teh-cmc/go-internals/blob/master/chapter2_interfaces/README.md

Go 1.1 Function Calls https://docs.google.com/document/d/1bMwCey-gmqZVTpRax-ESeVuZGmjwbocYs1iHplK-cjo/pub

What is the difference between MOV and LEA? https://stackoverflow.com/questions/1699748/what-is-the-difference-between-mov-and-lea/1699778#1699778

Function literals https://golang.org/ref/spec#Function_literals

闭包 https://hjlarry.github.io/docs/go/closure/

从栈上理解 Go语言函数调用的更多相关文章

  1. 深入理解 C 语言的函数调用过程

    来源: wjlkoorey 链接:http://blog.chinaunix.net/uid-23069658-id-3981406.html 本文主要从进程栈空间的层面复习一下C语言中函数调用的具体 ...

  2. 深入理解C语言的函数调用过程

    本文主要从进程栈空间的层面复习一下C语言中函数调用的具体过程,以加深对一些基础知识的理解.     先看一个最简单的程序: 点击(此处)折叠或打开 /*test.c*/ #include stdio. ...

  3. 深入理解C语言的函数调用过程 【转】

    转自:http://blog.chinaunix.net/uid-25909619-id-4240084.html 原文地址:深入理解C语言的函数调用过程 作者:wjlkoorey258     本文 ...

  4. Linux Debugging（一）: 使用反汇编理解C++程序函数调用栈

    拿到CoreDump后,如果看到的地址都是????,那么基本上可以确定,程序的栈被破坏掉了.GDB也是使用函数的调用栈去还原"事故现场"的.因此理解函数调用栈,是使用GDB进行现场 ...

  5. C语言函数调用栈(一)

    程序的执行过程可看作连续的函数调用.当一个函数执行完毕时,程序要回到调用指令的下一条指令(紧接call指令)处继续执行.函数调用过程通常使用堆栈实现,每个用户态进程对应一个调用栈结构(call sta ...

  6. C语言函数调用栈(二)

    5 函数调用约定 创建一个栈帧的最重要步骤是主调函数如何向栈中传递函数参数.主调函数必须精确存储这些参数,以便被调函数能够访问到它们.函数通过选择特定的调用约定,来表明其希望以特定方式接收参数.此外, ...

  7. C语言函数调用栈(三)

    6 调用栈实例分析 本节通过代码实例分析函数调用过程中栈帧的布局.形成和消亡. 6.1 栈帧的布局 示例代码如下: //StackReg.c #include <stdio.h> //获取 ...

  8. C语言函数调用时候内存中栈的动态变化详细分析（彩图）

    版权声明:本文为博主原创文章,未经博主允许不得转载.欢迎联系我qq2488890051 https://blog.csdn.net/kangkanglhb88008/article/details/8 ...

  9. C语言函数调用栈

    C语言函数调用栈 栈溢出(stack overflow)是最常见的二进制漏洞,在介绍栈溢出之前,我们首先需要了解函数调用栈. 函数调用栈是一块连续的用来保存函数运行状态的内存区域,调用函数(calle ...

随机推荐

  1. JavaScript深拷贝与浅拷贝的区别和实现方式

    如何区分深拷贝和浅拷贝呢,简单来说对象B拷贝了对象A,如果对象A和对象B共用一个对象,对象B改变对象A跟着改变这就是浅拷贝:但如果对象B拷贝了对象A,但是对象A和对象B是分开的,那么就是深拷贝 基本数 ...

  2. 基于 Socket 的群聊聊天室（带图形界面，包含注册、登录、数据入库功能）

    代码下载 https://github.com/juno3550/GroupChatRoom 实现框架 Chat 包: server.py:服务器端执行代码(TCP 服务器,根据客户端消息调用 mod ...

  3. 光猫和路由器都支持ipv6，却无法使用ipv6？

    这些年很多地方的光猫都能获得ipv6地址了,而且新出的路由基本都支持ipv6,但是还是有很多人在http://test-ipv6.com看不到自己的ipv6地址,也上不了ipv6网站. 我也遇到这个问 ...

  4. animation几个比较好玩的属性(alternate,及animation-fill-mode)

    <!DOCTYPE html> <html> <head> <style> div { width:100px; height:100px; backg ...

  5. 怎样用SQL修改某个字段的部分内容

    方法:update dede_addonarticle set body = replace(body,'#p#分页标题#e#',' ') where body like '%#p#分页标题#e#%'

  6. 进程保护原理Hook函数Openprocess

    Win32子系统:                                                                                            ...

  7. 病毒木马查杀实战第024篇：MBR病毒之编程解析引导区

    前言 通过之前的学习,相信大家已经对磁盘的引导区有了充分的认识.但是我们之前的学习都是利用现成的工具来对引导区进行解析的,而对于一名反病毒工程师而言,不单单需要有扎实的逆向分析功底,同时也需要有很强的 ...

  8. Windows PE导出表编程3（暴力覆盖导出函数）

    今天要尝试的导出表相关编程内容是:覆盖函数地址部分的指令代码. 这种覆盖技术,是将AddressOfFunctions指向的地址空间指令字节码实施覆盖,这种技术又繁衍出两种: 暴力覆盖,即将所有的代码 ...

  9. 【JavaScript】【KMP】Leetcode每日一题-实现strStr()

    [JavaScript]Leetcode每日一题-实现strStr() [题目描述] 实现 strStr() 函数. 给你两个字符串 haystack 和 needle ,请你在 haystack 字 ...

  10. pyhive的基本使用

    安装 yum -y install cyrus-sasl cyrus-sasl-devel cyrus-sasl-lib  # 解决报错:sasl/sasl.h: No such file or di ...