• 3.4 函数
    • 3.4.1 基本语法
    • 3.4.2 函数参数和返回值
    • 3.4.3 参数和返回值的内存布局
    • 3.4.4 函数中的局部变量
    • 3.4.5 调用其它函数
    • 3.4.6 宏函数

    3.4 函数

    终于到函数了！因为Go汇编语言中，可以也建议通过Go语言来定义全局变量，那么剩下的也就是函数了。只有掌握了汇编函数的基本用法，才能真正算是Go汇编语言入门。本章将简单讨论Go汇编中函数的定义和用法。

    3.4.1 基本语法

    函数标识符通过TEXT汇编指令定义，表示该行开始的指令定义在TEXT内存段。TEXT语句后的指令一般对应函数的实现，但是对于TEXT指令本身来说并不关心后面是否有指令。因此TEXT和LABEL定义的符号是类似的，区别只是LABEL是用于跳转标号，但是本质上他们都是通过标识符映射一个内存地址。

    函数的定义的语法如下：

    1. TEXT symbol(SB), [flags,] $framesize[-argsize]

    函数的定义部分由5个部分组成：TEXT指令、函数名、可选的flags标志、函数帧大小和可选的函数参数大小。

    其中TEXT用于定义函数符号，函数名中当前包的路径可以省略。函数的名字后面是(SB)，表示是函数名符号相对于SB伪寄存器的偏移量，二者组合在一起最终是绝对地址。作为全局的标识符的全局变量和全局函数的名字一般都是基于SB伪寄存器的相对地址。标志部分用于指示函数的一些特殊行为，标志在textlags.h文件中定义，常见的NOSPLIT主要用于指示叶子函数不进行栈分裂。framesize部分表示函数的局部变量需要多少栈空间，其中包含调用其它函数时准备调用参数的隐式栈空间。最后是可以省略的参数大小，之所以可以省略是因为编译器可以从Go语言的函数声明中推导出函数参数的大小。

    我们首先从一个简单的Swap函数开始。Swap函数用于交互输入的两个参数的顺序，然后通过返回值返回交换了顺序的结果。如果用Go语言中声明Swap函数，大概这样的：

    1. package main
    3. //go:nosplit
    4. func Swap(a, b int) (int, int)

    下面是main包中Swap函数在汇编中两种定义方式：

    1. // func Swap(a, b int) (int, int)
    2. TEXT ·Swap(SB), NOSPLIT, $0-32
    4. // func Swap(a, b int) (int, int)
    5. TEXT ·Swap(SB), NOSPLIT, $0

    下图是Swap函数几种不同写法的对比关系图：

    3.4 函数 - 图1

    图 3-8 函数定义

    第一种是最完整的写法：函数名部分包含了当前包的路径，同时指明了函数的参数大小为32个字节（对应参数和返回值的4个int类型）。第二种写法则比较简洁，省略了当前包的路径和参数的大小。如果有NOSPLIT标注，会禁止汇编器为汇编函数插入栈分裂的代码。NOSPLIT对应Go语言中的//go:nosplit注释。

    目前可能遇到的函数标志有NOSPLIT、WRAPPER和NEEDCTXT几个。其中NOSPLIT不会生成或包含栈分裂代码，这一般用于没有任何其它函数调用的叶子函数，这样可以适当提高性能。WRAPPER标志则表示这个是一个包装函数，在panic或runtime.caller等某些处理函数帧的地方不会增加函数帧计数。最后的NEEDCTXT表示需要一个上下文参数，一般用于闭包函数。

    需要注意的是函数也没有类型，上面定义的Swap函数签名可以下面任意一种格式：

    1. func Swap(a, b, c int) int
    2. func Swap(a, b, c, d int)
    3. func Swap() (a, b, c, d int)
    4. func Swap() (a []int, d int)
    5. // ...

    对于汇编函数来说，只要是函数的名字和参数大小一致就可以是相同的函数了。而且在Go汇编语言中，输入参数和返回值参数是没有任何的区别的。

    3.4.2 函数参数和返回值

    对于函数来说，最重要的是函数对外提供的API约定，包含函数的名称、参数和返回值。当这些都确定之后，如何精确计算参数和返回值的大小是第一个需要解决的问题。

    比如有一个Swap函数的签名如下：

    1. func Swap(a, b int) (ret0, ret1 int)

    对于这个函数，我们可以轻易看出它需要4个int类型的空间，参数和返回值的大小也就是32个字节：

    1. TEXT ·Swap(SB), $0-32

    那么如何在汇编中引用这4个参数呢？为此Go汇编中引入了一个FP伪寄存器，表示函数当前帧的地址，也就是第一个参数的地址。因此我们以通过+0(FP)、+8(FP)、+16(FP)和+24(FP)来分别引用a、b、ret0和ret1四个参数。

    但是在汇编代码中，我们并不能直接以+0(FP)的方式来使用参数。为了编写易于维护的汇编代码，Go汇编语言要求，任何通过FP伪寄存器访问的变量必和一个临时标识符前缀组合后才能有效，一般使用参数对应的变量名作为前缀。

    下图是Swap函数中参数和返回值在内存中的布局图：

    3.4 函数 - 图2

    图 3-9 函数定义

    下面的代码演示了如何在汇编函数中使用参数和返回值：

    1. TEXT ·Swap(SB), $0
    2.     MOVQ a+0(FP), AX     // AX = a
    3.     MOVQ b+8(FP), BX     // BX = b
    4.     MOVQ BX, ret0+16(FP) // ret0 = BX
    5.     MOVQ AX, ret1+24(FP) // ret1 = AX
    6.     RET

    从代码可以看出a、b、ret0和ret1的内存地址是依次递增的，FP伪寄存器是第一个变量的开始地址。

    3.4.3 参数和返回值的内存布局

    如果是参数和返回值类型比较复杂的情况该如何处理呢？下面我们再尝试一个更复杂的函数参数和返回值的计算。比如有以下一个函数：

    1. func Foo(a bool, b int16) (c []byte)

    函数的参数有不同的类型，而且返回值中含有更复杂的切片类型。我们该如何计算每个参数的位置和总的大小呢？

    其实函数参数和返回值的大小以及对齐问题和结构体的大小和成员对齐问题是一致的，函数的第一个参数和第一个返回值会分别进行一次地址对齐。我们可以用诡代思路将全部的参数和返回值以同样的顺序分别放到两个结构体中，将FP伪寄存器作为唯一的一个指针参数，而每个成员的地址也就是对应原来参数的地址。

    用这样的策略可以很容易计算前面的Foo函数的参数和返回值的地址和总大小。为了便于描述我们定义一个Foo_args_and_returns临时结构体类型用于诡代原始的参数和返回值：

    1. type Foo_args struct {
    2.     a bool
    3.     b int16
    4.     c []byte
    5. }
    6. type Foo_returns struct {
    7.     c []byte
    8. }

    然后将Foo原来的参数替换为结构体形式，并且只保留唯一的FP作为参数：

    1. func Foo(FP *SomeFunc_args, FP_ret *SomeFunc_returns) {
    2.     // a = FP + offsetof(&args.a)
    3.     _ = unsafe.Offsetof(FP.a) + uintptr(FP) // a
    4.     // b = FP + offsetof(&args.b)
    6.     // argsize = sizeof(args)
    7.     argsize = unsafe.Offsetof(FP)
    9.     // c = FP + argsize + offsetof(&return.c)
    10.     _ = uintptr(FP) + argsize + unsafe.Offsetof(FP_ret.c)
    12.     // framesize = sizeof(args) + sizeof(returns)
    13.     _ = unsafe.Offsetof(FP) + unsafe.Offsetof(FP_ret)
    15.     return
    16. }

    代码完全和Foo函数参数的方式类似。唯一的差异是每个函数的偏移量，通过unsafe.Offsetof函数自动计算生成。因为Go结构体中的每个成员已经满足了对齐要求，因此采用通用方式得到每个参数的偏移量也是满足对齐要求的。序言注意的是第一个返回值地址需要重新对齐机器字大小的倍数。

    Foo函数的参数和返回值的大小和内存布局：

    3.4 函数 - 图3

    图 3-10 函数的参数

    下面的代码演示了Foo汇编函数参数和返回值的定位：

    1. TEXT ·Foo(SB), $0
    2.     MOVEQ a+0(FP),       AX // a
    3.     MOVEQ b+2(FP),       BX // b
    4.     MOVEQ c_dat+8*1(FP), CX // c.Data
    5.     MOVEQ c_len+8*2(FP), DX // c.Len
    6.     MOVEQ c_cap+8*3(FP), DI // c.Cap
    7.     RET

    其中a和b参数之间出现了一个字节的空洞，b和c之间出现了4个字节的空洞。出现空洞的原因是要保证每个参数变量地址都要对齐到相应的倍数。

    3.4.4 函数中的局部变量

    从Go语言函数角度讲，局部变量是函数内明确定义的变量，同时也包含函数的参数和返回值变量。但是从Go汇编角度看，局部变量是指函数运行时，在当前函数栈帧所对应的内存内的变量，不包含函数的参数和返回值（因为访问方式有差异）。函数栈帧的空间主要由函数参数和返回值、局部变量和被调用其它函数的参数和返回值空间组成。为了便于理解，我们可以将汇编函数的局部变量类比为Go语言函数中显式定义的变量，不包含参数和返回值部分。

    为了便于访问局部变量，Go汇编语言引入了伪SP寄存器，对应当前栈帧的底部。因为在当前栈帧时栈的底部是固定不变的，因此局部变量的相对于伪SP的偏移量也就是固定的，这可以简化局部变量的维护工作。SP真伪寄存器的区分只有一个原则：如果使用SP时有一个临时标识符前缀就是伪SP，否则就是真SP寄存器。比如a(SP)和b+8(SP)有a和b临时前缀，这里都是伪SP，而前缀部分一般用于表示局部变量的名字。而(SP)和+8(SP)没有临时标识符作为前缀，它们都是真SP寄存器。

    在X86平台，函数的调用栈是从高地址向低地址增长的，因此伪SP寄存器对应栈帧的底部其实是对应更大的地址。当前栈的顶部对应真实存在的SP寄存器，对应当前函数栈帧的栈顶，对应更小的地址。如果整个内存用Memory数组表示，那么Memory[0(SP):end-0(SP)]就是对应当前栈帧的切片，其中开始位置是真SP寄存器，结尾部分是伪SP寄存器。真SP寄存器一般用于表示调用其它函数时的参数和返回值，真SP寄存器对应内存较低的地址，所以被访问变量的偏移量是正数；而伪SP寄存器对应高地址，对应的局部变量的偏移量都是负数。

    为了便于对比，我们将前面Foo函数的参数和返回值变量改成局部变量：

    1. func Foo() {
    2.     var c []byte
    3.     var b int16
    4.     var a bool
    5. }

    然后通过汇编语言重新实现Foo函数，并通过伪SP来定位局部变量：

    1. TEXT ·Foo(SB), $32-0
    2.     MOVQ a-32(SP),      AX // a
    3.     MOVQ b-30(SP),      BX // b
    4.     MOVQ c_data-24(SP), CX // c.Data
    5.     MOVQ c_len-16(SP),  DX // c.Len
    6.     MOVQ c_cap-8(SP),   DI // c.Cap
    7.     RET

    Foo函数有3个局部变量，但是没有调用其它的函数，因为对齐和填充的问题导致函数的栈帧大小为32个字节。因为Foo函数没有参数和返回值，因此参数和返回值大小为0个字节，当然这个部分可以省略不写。而局部变量中先定义的变量c离伪SP寄存器对应的地址最远，最后定义的变量a离伪SP寄存器最近。有两个因素导致出现这种逆序的结果：一个从Go语言函数角度理解，先定义的c变量地址要比后定义的变量的地址更小；另一个是伪SP寄存器对应栈帧的底部，而X86中栈是从高向地生长的，所以最先定义有着更小地址的c变量离栈的底部伪SP更远。

    我们同样可以通过结构体来模拟局部变量的布局：

    1. func Foo() {
    2.     var local [1]struct{
    3.         a bool
    4.         b int16
    5.         c []byte
    6.     }
    7.     var SP = &local[1];
    9.     _ = -(unsafe.Sizeof(local)-unsafe.Offsetof(local.a)) + uintptr(&SP) // a
    10.     _ = -(unsafe.Sizeof(local)-unsafe.Offsetof(local.b)) + uintptr(&SP) // b
    11.     _ = -(unsafe.Sizeof(local)-unsafe.Offsetof(local.c)) + uintptr(&SP) // c
    12. }

    我们将之前的三个局部变量挪到一个结构体中。然后构造一个SP变量对应伪SP寄存器，对应局部变量结构体的顶部。然后根据局部变量总大小和每个变量对应成员的偏移量计算相对于伪SP的距离，最终偏移量是一个负数。

    通过这种方式可以处理复杂的局部变量的偏移，同时也能保证每个变量地址的对齐要求。当然，除了地址对齐外，局部变量的布局并没有顺序要求。对于汇编比较熟悉同学可以根据自己的习惯组织变量的布局。

    下面是Foo函数的局部变量的大小和内存布局：

    3.4 函数 - 图4

    图 3-11 函数的局部变量

    从图中可以看出Foo函数局部变量和前一个例子中参数和返回值的内存布局是完全一样的，这也是我们故意设计的结果。但是参数和返回值是通过伪FP寄存器定位的，FP寄存器对应第一个参数的开始地址（第一个参数地址较低），因此每个变量的偏移量是正数。而局部变量是通过伪SP寄存器定位的，而伪SP寄存器对应的是第一个局部变量的结束地址（第一个局部变量地址较大），因此每个局部变量的偏移量都是负数。

    3.4.5 调用其它函数

    常见的用Go汇编实现的函数都是叶子函数，也就是被其它函数调用的函数，但是很少调用其它函数。这主要是因为叶子函数比较简单，可以简化汇编函数的编写；同时一般性能或特性的瓶颈也处于叶子函数。但是能够调用其它函数和能够被其它函数调用同样重要，否则Go汇编就不是一个完整的汇编语言。

    在前文中我们已经学习了一些汇编实现的函数参数和返回值处理的规则。那么一个显然的问题是，汇编函数的参数是从哪里来的？答案同样明显，被调用函数的参数是由调用方准备的：调用方在栈上设置好空间和数据后调用函数，被调用方在返回前将返回值放在对应的位置，函数通过RET指令返回调用方函数之后，调用方再从返回值对应的栈内存位置取出结果。Go语言函数的调用参数和返回值均是通过栈传输的，这样做的优点是函数调用栈比较清晰，缺点是函数调用有一定的性能损耗（Go编译器是通过函数内联来缓解这个问题的影响）。

    为了便于展示，我们先使用Go语言来构造三个逐级调用的函数：

    1. func main() {
    2.     printsum(1, 2)
    3. }
    5. func printsum(a, b int) {
    6.     var ret = sum(a, b)
    7.     println(ret)
    8. }
    10. func sum(a, b int) int {
    11.     return a+b
    12. }

    其中main函数通过字面值常量直接调用printsum函数，printsum函数输出两个整数的和。而printsum函数内部又通过调用sum函数计算两个数的和，并最终调用打印函数进行输出。因为printsum既是被调用函数又是调用函数，所以它是我们要重点分析的函数。

    下图展示了三个函数逐级调用时内存中函数参数和返回值的布局：

    3.4 函数 - 图5

    图 3-12 函数帧

    为了便于理解，我们对真实的内存布局进行了简化。要记住的是调用函数时，被调用函数的参数和返回值内存空间都必须由调用者提供。因此函数的局部变量和为调用其它函数准备的栈空间总和就确定了函数帧的大小。调用其它函数前调用方要选择保存相关寄存器到栈中，并在调用函数返回后选择要恢复的寄存器进行保存。最终通过CALL指令调用函数的过程和调用我们熟悉的调用println函数输出的过程类似。

    Go语言中函数调用是一个复杂的问题，因为Go函数不仅仅要了解函数调用参数的布局，还会涉及到栈的跳转，栈上局部变量的生命周期管理。本节只是简单了解函数调用参数的布局规则，在后续的章节中会更详细的讨论函数的细节。

    3.4.6 宏函数

    宏函数并不是Go汇编语言所定义，而是Go汇编引入的预处理特性自带的特性。

    在C语言中我们可以通过带参数的宏定义一个交换2个数的宏函数：

    1. #define SWAP(x, y) do{ int t = x; x = y; y = t; }while(0)

    我们可以用类似的方式定义一个交换两个寄存器的宏：

    1. #define SWAP(x, y, t) MOVQ x, t; MOVQ y, x; MOVQ t, y

    因为汇编语言中无法定义临时变量，我们增加一个参数用于临时寄存器。下面是通过SWAP宏函数交换AX和BX寄存器的值，然后返回结果：

    1. // func Swap(a, b int) (int, int)
    2. TEXT ·Swap(SB), $0-32
    3.     MOVQ a+0(FP), AX // AX = a
    4.     MOVQ b+8(FP), BX // BX = b
    6.     SWAP(AX, BX, CX)     // AX, BX = b, a
    8.     MOVQ AX, ret0+16(FP) // return
    9.     MOVQ BX, ret1+24(FP) //
    10.     RET

    因为预处理器可以通过条件编译针对不同的平台定义宏的实现，这样可以简化平台带来的差异。