Go 语言函数调用参数传递规则

1. 调试环境

Go 版本：1.19.3

Gdb 版本：12.1

CPU 架构：amd64

Linux 发行版：Ubuntu 22.04

Linux 内核版本：5.15.0-48

2. 函数调用参数传递规则版本变化

在 Go 中函数间进行调用时，主调（caller）在调用被调（callee）函数之前需要先将参数存储到某个地方，以供被调者使用。

在 Go 1.7 之前，函数入参都是存储在堆栈上。主调会先在堆栈上划出一块内存，然后将调用参数值存储到这块堆栈上，最后调用 call 指令跳转到被调函数执行，被调函数执行时，会从主调分配的那块堆栈上获取入参值。

在 Go 1.7 及以后版本对入参传递方式进行了优化，函数入参主要通过寄存器传递，寄存器不够用了才会将入参存储到栈上。这个优化将 Go 程序执行效率提高了 5%，生成的二进制文件大小减少了 2%。详见 Go 1.17 Release Notes。

在 amd64 的架构的 CPU 上，Go 使用了 RAX、RBX、RCX、RDI, RSI、R8、R9、R10 和 R11 共计 9 个整数寄存器来存储整型入参，同时通过 X0~X14 共计15个浮点数寄存器来存储浮点数入参。这些寄存器的顺序也依次对应函数入参从左到右的顺序。

如果入参是结构体，递归拆解其成员的类型最终也只会是整型或者浮点型，仍可以用寄存器传递其值。

3. 验证参数传递规则正确性

下面在 Go1.19.3 版本上，分别对入参类型为整数、浮点数、数组和结构体时参数的传递方式进行验证。

3.1. 注意事项

3.1.1. 关闭编译器内联

验证的被调函数非常简单，如果正常编译会被编译器内联到主调函数里面，就不会有参数的传递。为了达到验证效果，要关闭编译器内联。有两种方式来关闭编译器内联：

• 被调函数前加上 //go:noinline 编译标签。

• Go 编译命令中加上 -gcflags "-l" 标志。

3.1.2. 打开编译器优化

在编译时最好别使用禁止优化的选项，即不要在 build 时加 -gcflags "-N" 标志，如果禁止优化，入参的传递规则在某些场景下会有点混乱（没有理清楚），以下示例都是在打开编译器优化的情况下执行的。

3.2. 编译汇编代码

可用用 Go 自带的 objdump 工具会将二进制反汇编成 plan9 汇编，也可以使用 Linux 系统自带的 objdump 工具会将二进制反汇编成 at&t 汇编，两种不同的汇编语言在语法有一点差异，但并不会导致入参规则上的变化，因此任选一种自已熟悉的汇编语言学习即可，本文档使用 plan9 汇编。

命令语法：

go build -o main main.go
$GOROOT/pkg/tool/linux_amd64/objdump main > main.plan9.asm

3.3. 验证整数做为入参

整数寄存器有 9 个，分别对整数入参个数为小于等于 9 个 和大于 9 个两种情况进行验证。

3.3.1. 整数入参为 9 个

示例中定义了一个 add 函数，有 9 个入参，1 个返回值。如下：

//go:noinline
func add(a, b, c, d, e, f, g, h, i int) int {return a+b+c+d+e+f+g+h+i
}func main() {add(1, 2, 3, 4, 5, 6, 7, 8, 9)
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/int_less_ten.go...   int_less_ten.go:9 0x457c54        b801000000      MOVL $0x1, AX      int_less_ten.go:9 0x457c59        bb02000000      MOVL $0x2, BX      int_less_ten.go:9 0x457c5e        b903000000      MOVL $0x3, CX      int_less_ten.go:9 0x457c63        bf04000000      MOVL $0x4, DI      int_less_ten.go:9 0x457c68        be05000000      MOVL $0x5, SI      int_less_ten.go:9 0x457c6d        41b806000000    MOVL $0x6, R8      int_less_ten.go:9 0x457c73        41b907000000    MOVL $0x7, R9      int_less_ten.go:9 0x457c79        41ba08000000    MOVL $0x8, R10      int_less_ten.go:9 0x457c7f        41bb09000000    MOVL $0x9, R11      int_less_ten.go:9 0x457c85        e896ffffff      CALL main.add(SB) 

从 main.main 汇编指令 3~11 行可以看到， 分别将 0-9 这 9 个数字存储到 RAX、RBX、RCX、RDI, RSI、R8、R9、R10 和 R11 这 9 个寄存器中。在准备好入参后，会通过 call 指令跳转到 main.add 函数执行，main.add 汇编代码如下：

TEXT main.add(SB) /home/ubuntu/program/reg_demo/int_less_ten.goint_less_ten.go:5 0x457c20        488d1403        LEAQ 0(BX)(AX*1), DX    int_less_ten.go:5 0x457c24        4801d1          ADDQ DX, CX     int_less_ten.go:5 0x457c27        4801f9          ADDQ DI, CX     int_less_ten.go:5 0x457c2a        4801f1          ADDQ SI, CX     int_less_ten.go:5 0x457c2d        4c01c1          ADDQ R8, CX     int_less_ten.go:5 0x457c30        4c01c9          ADDQ R9, CX     int_less_ten.go:5 0x457c33        4c01d1          ADDQ R10, CX      int_less_ten.go:5 0x457c36        498d040b        LEAQ 0(R11)(CX*1), AX    int_less_ten.go:5 0x457c3a        c3              RET   

在 main.add 函数中，会直接从寄存器中取入参的值，并进行计算。

汇编代码第二行的指令 LEAQ 0(BX)(AX*1), DX 看着有复杂，但其作用就是将 RAX 与 RBX 寄存器的值相加并赋值给 RDX，可等价为如下指令：

MOVQ $0, DX; 
ADDQ AX, DX; 
ADDQ BX, DX

通过 LEAQ 的方式可以一条指令就代替下面 3 条指令，执行效率更高。这是编译器优化的结果，如果在编译程序时带上了禁止优化 -gcflags "-N" 标志，就会从栈上依次取出参数并相加。

验证结果表明，当入参为整数时，且入参个数小于等于 9 个时，全部通过寄存器传递。

3.3.2. 整数入参为 10 个

示例中定义了一个 add 函数，有 10 个入参，1 个返回值。如下：

//go:noinline
func add(a, b, c, d, e, f, g, h, i, j int) int {return a+b+c+d+e+f+g+h+i+j
}func main() {add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/int_more_ten.go...   int_more_ten.go:9 0x457c74        48c704240a000000    MOVQ $0xa, 0(SP)      int_more_ten.go:9 0x457c7c        b801000000      	MOVL $0x1, AX      int_more_ten.go:9 0x457c81        bb02000000      	MOVL $0x2, BX      int_more_ten.go:9 0x457c86        b903000000     	 	MOVL $0x3, CX      int_more_ten.go:9 0x457c8b        bf04000000      	MOVL $0x4, DI      int_more_ten.go:9 0x457c90        be05000000      	MOVL $0x5, SI      int_more_ten.go:9 0x457c95        41b806000000        MOVL $0x6, R8      int_more_ten.go:9 0x457c9b        41b907000000        MOVL $0x7, R9      int_more_ten.go:9 0x457ca1        41ba08000000        MOVL $0x8, R10      int_more_ten.go:9 0x457ca7        41bb09000000        MOVL $0x9, R11      int_more_ten.go:9 0x457cad        e86effffff      	CALL main.add(SB)

从上面编指令第 3 行可以看到，主调函数 main.man 会先将入参 10 放到堆栈 SP 处，然后 4~12 行依次将剩余的 0-9 九个入参放到寄存器中。在准备好入参后，会通过 call 指令跳转到 main.add 函数执行，main.add 汇编代码如下：

TEXT main.add(SB) /home/ubuntu/program/reg_demo/int_more_ten.goint_more_ten.go:5 0x457c20        488d1403        LEAQ 0(BX)(AX*1), DX    int_more_ten.go:5 0x457c24        4801d1          ADDQ DX, CX     int_more_ten.go:5 0x457c27        4801f9          ADDQ DI, CX     int_more_ten.go:5 0x457c2a        4801f1          ADDQ SI, CX     int_more_ten.go:5 0x457c2d        4c01c1          ADDQ R8, CX     int_more_ten.go:5 0x457c30        4c01c9          ADDQ R9, CX     int_more_ten.go:5 0x457c33        4c01d1          ADDQ R10, CX      int_more_ten.go:5 0x457c36        4c01d9          ADDQ R11, CX      int_more_ten.go:5 0x457c39        488b542408      MOVQ 0x8(SP), DX    int_more_ten.go:5 0x457c3e        488d040a        LEAQ 0(DX)(CX*1), AX    int_more_ten.go:5 0x457c42        c3          	RET  

在 main.add 的汇编代码第 2~9 行可以看到，会直接从寄存器中取前 9 个入参的值，并进行加运算，将运算结果放到 RCX 寄存器中。然后在第 10 行，会先将第 10 个参数从堆栈中取中，并放到寄存器 RDX 中，最后将 RDX 与 RCX 相加，并将结果赋给 RAX，并用 RET 指令返回。

验证结果表明，当入参个数大于 9 个时，前 0~9 个是通过寄存器传递，剩下的是通过堆栈传递。

3.4. 浮点数

首先验证入参中有浮点数时是否是通过浮点数寄存器传递，再验证入参中同时包含浮点数和整数时，是否同时通过浮点数寄存器和整数寄存器进行传递。

注：不做寄存器上限验证，上面的 [验证整数做为入参](#3. 验证参数传递规则正确性) 已经做过了。

3.4.1. 入参为浮点数

示例中定义了一个 add 函数，有 2 个浮点数入参，1 个返回值。如下：

//go:noinline
func add(x, y float64) float64 {return x+y 
}func main() {_ = add(1.1, 2.2)
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/float.go...   float.go:9        0x457c54        f20f10053c3b0200    MOVSD_XMM $f64.3ff199999999999a(SB), X0 float.go:9        0x457c5c        f20f100d443b0200    MOVSD_XMM $f64.400199999999999a(SB), X1 float.go:9        0x457c64        e8b7ffffff      	CALL main.add(SB)  

从上面汇编指令 3~4 行可以看到， 主调函数 main.main 分别将两个浮点数入参存储到 X0 和 X1 两个寄存器中。在准备好入参后，会通过 call 指令跳转到 main.add 函数执行，main.add 汇编代码如下：

TEXT main.add(SB) /home/ubuntu/program/reg_demo/float.gofloat.go:5        0x457c20        f20f58c1        ADDSD X1, X0      float.go:5        0x457c24        c3          	RET  

在被调 main.add 的汇编代码中可以看到，直接对寄存器 X0 和 X1 进行计算。

验证结果表明，当入参为浮点数时，入参是通过 X0~X14 寄存器传递的。

3.4.2. 入参为浮点数和整数

示例中定义了一个 add 函数，有两个参数，一个为整数，一个为浮点数，1 个返回值。如下：

//go:noinline
func add(x int, y float64) int {return x+ int(y)
}func main() {_ = add(1, 2.2)
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/mixed.go...    mixed.go:10       0x457c54        b801000000      	MOVL $0x1, AX      mixed.go:10       0x457c59        f20f1005473b0200    MOVSD_XMM $f64.400199999999999a(SB), X0 mixed.go:10       0x457c61        e8baffffff      	CALL main.add(SB) 

从上面汇编指令 3~4 行可以看到，两个参数被分别存储到 RAX 整数寄存器和 X0 浮点数寄存器。准备好入参后，会通过 call 指令跳转到 main.add 函数执行，main.add 汇编代码如下：

TEXT main.add(SB) /home/ubuntu/program/reg_demo/mixed.gomixed.go:6        0x457c20        f2480f2cc8      CVTTSD2SIQ X0, CX    mixed.go:6        0x457c25        4801c8          ADDQ CX, AX     mixed.go:6        0x457c28        c3          	RET 

在被调 main.add 的汇编代码中可以看到，直接对寄存器 RAX 和 X1 进行计算，并将结果存入 RAX，并返回。

验证结果表明，当入参同时有整数和浮点数时，整数入参通过 RAX、RBX、RCX、RDI, RSI、R8、R9、R10 和 R11 寄存器传递，浮点数入参通过 X0~X14 寄存器传递。

3.5. 数组

验证当数组大小未超过9个时，入参是否通过寄存器传递。

3.5.1. 入参为大小小于9的数组

示例中定义了一个 add 函数，有一个类型为数组的参数，1 个返回值。如下：

//go:noinline
func add(x [5]int) int {return x[0] + x[3]
}func main() {_ = add([5]int{1, 2, 3, 4, 5})
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/array.go... array.go:10       0x457c54        48c7042401000000    MOVQ $0x1, 0(SP)      array.go:10       0x457c5c        48c744240802000000  MOVQ $0x2, 0x8(SP)      array.go:10       0x457c65        48c744241003000000  MOVQ $0x3, 0x10(SP)      array.go:10       0x457c6e        48c744241804000000  MOVQ $0x4, 0x18(SP)      array.go:10       0x457c77        48c744242005000000  MOVQ $0x5, 0x20(SP)      array.go:10       0x457c80        e89bffffff      	CALL main.add(SB)  

从上面汇编指令 3~7 行可以看到，入参被放在堆栈中。准备好入参后，会通过 call 指令跳转到 main.add 函数执行，main.add 汇编代码如下：

TEXT main.add(SB) /home/ubuntu/program/reg_demo/array.goarray.go:6        0x457c20        488b442408      MOVQ 0x8(SP), AX    array.go:6        0x457c25        4803442420      ADDQ 0x20(SP), AX    array.go:6        0x457c2a        c3          	RET  

在被调 main.add 的汇编代码中可以看到，从堆栈中取值放到寄存器，然后进行计算，并返回。

验证结果表明，当入参的类型为数组时，无论数组大小是否超过寄存器数量，总是通过堆栈来传递。

3.6. 结构体

验证重点：

• 结构体中只含有整数成员，且成员个数小于等于 9 个时，结构体如何传递；

• 结构体中只含有整数成员，且成员个数大于 9 个时，结构体如何传递；

• 结构体中包含数组成员，结构体如何传递；

• 结构体中同时包含整数和浮点数成员，且整数成员个数小于等于 9 个，浮点数成员小于等于 15 个，结构体如何传递。

• 结构体中同时包含整数和浮点数成员，且整数成员个数小于等于 9 个，浮点数成员大于 15 个，结构体如何传递。

3.6.1. 结构体基本整数成员小于等于9个

示例中定义了一个 addStruct 函数，有一个类型为 Elem 结构体的参数，其下有 3 个 byte 类型的成员，6 个 int 类型的成员。如下：

type Elem struct {a, b, c byted, e, f, g, h, i int
}//go:noinline
func addStruct(e Elem) int {return int(e.a)+e.i
}func main() {_ = addStruct(Elem{1, 2, 3, 4, 5, 6, 7, 8, 9})
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/struct.go...    struct.go:13      0x457c74        b801000000      MOVL $0x1, AX      struct.go:13      0x457c79        bb02000000      MOVL $0x2, BX      struct.go:13      0x457c7e        b903000000      MOVL $0x3, CX      struct.go:13      0x457c83        bf04000000      MOVL $0x4, DI      struct.go:13      0x457c88        be05000000      MOVL $0x5, SI      struct.go:13      0x457c8d        41b806000000    MOVL $0x6, R8      struct.go:13      0x457c93        41b907000000    MOVL $0x7, R9      struct.go:13      0x457c99        41ba08000000    MOVL $0x8, R10      struct.go:13      0x457c9f        41bb09000000    MOVL $0x9, R11      struct.go:13      0x457ca5        e876ffffff      CALL main.addStruct(SB)

从上面汇编指令 3~11 行可以看到，结构体的 9 个成员值分别被放到 9 个整数寄存器中。准备好入参后，会通过 call 指令跳转到 main.addStruct 函数执行，main.addStruct汇编代码如下：

  struct_align.go:9	 	0x457c20        88442408        MOVB AL, 0x8(SP)    struct_align.go:9 	0x457c24        885c2409        MOVB BL, 0x9(SP)    struct_align.go:9 	0x457c28        884c240a        MOVB CL, 0xa(SP)    struct_align.go:9 	0x457c2c        48897c2410      MOVQ DI, 0x10(SP)   struct_align.go:9 	0x457c31        4889742418      MOVQ SI, 0x18(SP)   struct_align.go:9 	0x457c36        4c89442420      MOVQ R8, 0x20(SP)   struct_align.go:9 	0x457c3b        4c894c2428      MOVQ R9, 0x28(SP)   struct_align.go:9 	0x457c40        4c89542430      MOVQ R10, 0x30(SP)  struct_align.go:9 	0x457c45        4c895c2438      MOVQ R11, 0x38(SP)  struct_align.go:10    0x457c4a        0fb64c2408      MOVZX 0x8(SP), CX    struct_align.go:10    0x457c4f        4a8d0419        LEAQ 0(CX)(R11*1), AX    struct_align.go:10    0x457c53        c3          	RET 

从上面汇编代码可以看到，从寄存器中取出入参值，并放到堆栈上，需要特别注意的是，这里放在堆栈上并不是按地址总线宽度，而是以内存对齐的规则来放置的，如 a，b，c 这三个变量是 byte 类型，在内存对齐的规则中是会放在一个 8 字节的内存中，上面 1~3 行汇编代码也印证了这点。

验证结果表明，当结构体做为入参，且结构体成员个数小于 10 个时，会通过寄存器传递结构体成员值。同时在被调函数中，会将寄存器中的值以内存对齐的方式转存在堆栈上，方便后续计算。

同理，当结构体成员中，浮点数个数不超过15个时，会通过寄存器传递。

3.6.2. 结构体基本整数成员大于 9 个

示例中定义了一个 addStruct 函数，有一个类型为 Elem 结构体的参数，其下有 3 个 byte 类型的成员，7 个 int 类型的成员。如下：

type Elem struct {a, b, c byted, e, f, g, h, i, j int
}//go:noinline
func addStruct(e Elem) int {return int(e.a)+e.i
}func main() {_ = addStruct(Elem{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/struct_more_ten.go..    struct_more_ten.go:14 0x457c54        48c7042401020300    MOVQ $0x30201, 0(SP)      struct_more_ten.go:14 0x457c5c        48c744240804000000  MOVQ $0x4, 0x8(SP)      struct_more_ten.go:14 0x457c65        48c744241005000000  MOVQ $0x5, 0x10(SP)      struct_more_ten.go:14 0x457c6e        48c744241806000000  MOVQ $0x6, 0x18(SP)      struct_more_ten.go:14 0x457c77        48c744242007000000  MOVQ $0x7, 0x20(SP)      struct_more_ten.go:14 0x457c80        48c744242808000000  MOVQ $0x8, 0x28(SP)      struct_more_ten.go:14 0x457c89        48c744243009000000  MOVQ $0x9, 0x30(SP)      struct_more_ten.go:14 0x457c92        48c74424380a000000  MOVQ $0xa, 0x38(SP)      struct_more_ten.go:14 0x457c9b        0f1f440000      	NOPL 0(AX)(AX*1)      struct_more_ten.go:14 0x457ca0        e87bffffff      	CALL main.addStruct(SB)    

从上面汇编指令 3~10 行可以看到，结构体的 10 个成员值分别被堆栈中。准备好入参后，会通过 call 指令跳转到 main.addStruct 函数执行，main.addStruct汇编代码如下：

TEXT main.addStruct(SB) /home/ubuntu/program/reg_demo/struct_more_ten.gostruct_more_ten.go:10 0x457c20        0fb6442408      MOVZX 0x8(SP), AX    struct_more_ten.go:10 0x457c25        4803442438      ADDQ 0x38(SP), AX    struct_more_ten.go:10 0x457c2a        c3          	RET  

从上面汇编代码可以看到，直接从堆栈中取出入参值进行计算。

验证结果表明，当结构体做为入参，且结构体成员个数大于 9 个时，整个结构体的所有成员都通过堆栈传递。

同理，当结构体成员中，浮点数个数超过15个时，整个结构体的所有成员也都通过堆栈传递。

3.6.3. 结构体成员含有数组时

示例中定义了一个 addStruct 函数，其入参类型为 Elem 结构体，该结构体成员含有数组。如下：

type Elem struct {a [4]int
}//go:noinline
func addStruct(e Elem) int {return e.a[0] + e.a[3]
}func main() {_ = addStruct(Elem{a: [4]int{1,2,3,4}})
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/struct_array.go..struct_array.go:13    0x457c54        48c7042401000000    MOVQ $0x1, 0(SP)      struct_array.go:13    0x457c5c        48c744240802000000  MOVQ $0x2, 0x8(SP)      struct_array.go:13    0x457c65        48c744241003000000  MOVQ $0x3, 0x10(SP)      struct_array.go:13    0x457c6e        48c744241804000000  MOVQ $0x4, 0x18(SP)      struct_array.go:13    0x457c77        e8a4ffffff      	CALL main.addStruct(SB)      TEXT main.addStruct(SB) /home/ubuntu/program/reg_demo/struct_array.gostruct_array.go:9 0x457c20        488b442408      MOVQ 0x8(SP), AX    struct_array.go:9 0x457c25        4803442420      ADDQ 0x20(SP), AX    struct_array.go:9 0x457c2a        c3          	RET      

从上面汇编代码中可以看到，主调 main.main 在调用 main.addStruct 函数前，先将参数存放在堆栈，被调会从堆栈中取出参数值进行计算。

验证结果表明，当结构体成员有数组时，只能通过堆栈传递。

3.6.4. 结构体整数成员 9 个，浮点数成员 15 个

示例中定义了一个 addStruct 函数，其入参类型为 Elem 结构体，该结构体有 9 个整数类型成员，15 个浮点数类型成员。如下：

type Elem struct {a, b, c, d, e, f, g, h, i intj, k, l, m, n, o, p, q, r, s, t, u, v, w, x float64
}//go:noinline
func addStruct(e Elem) int {return e.a+int(e.m)
}func main() {_ = addStruct(Elem{1, 2, 3, 4, 5, 6, 7, 8, 9, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.1, 11.11, 12.12, 13.13, 14.14, 15.15})
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.main(SB) /home/ubuntu/program/reg_demo/struct_mixed.go.. struct_mixed.go:14    0x457d06        f20f100512400200    MOVSD_XMM 0x24012(IP), X0       struct_mixed.go:14    0x457d0e        f20f100d12400200    MOVSD_XMM 0x24012(IP), X1       ..struct_mixed.go:14    0x457d7c        f2440f10350b400200  MOVSD_XMM 0x2400b(IP), X14     struct_mixed.go:14    0x457d85        b801000000      	MOVL $0x1, AX               struct_mixed.go:14    0x457d8a        bb02000000      	MOVL $0x2, BX               ..        struct_mixed.go:14    0x457db0        41bb09000000        MOVL $0x9, R11              struct_mixed.go:14    0x457db6        e865feffff      	CALL main.addStruct(SB)      TEXT main.addStruct(SB) /home/ubuntu/program/reg_demo/struct_mixed.gostruct_mixed.go:9 0x457c20        4889442408      	    MOVQ AX, 0x8(SP)    struct_mixed.go:9 0x457c25        48895c2410      		MOVQ BX, 0x10(SP)   ...struct_mixed.go:9 0x457c48        4c895c2448      		MOVQ R11, 0x48(SP) struct_mixed.go:9 0x457c4d        f20f11442450        	MOVSD_XMM X0, 0x50(SP)  struct_mixed.go:9 0x457c53        f20f114c2458        	MOVSD_XMM X1, 0x58(SP)  struct_mixed.go:9 0x457c59        f20f11542460        	MOVSD_XMM X2, 0x60(SP)  ...struct_mixed.go:9 0x457cbf        f2440f11b424c0000000    MOVSD_XMM X14, 0xc0(SP) struct_mixed.go:10    0x457cc9    f20f10442468        	MOVSD_XMM 0x68(SP), X0  struct_mixed.go:10    0x457ccf    f2480f2cc0      		CVTTSD2SIQ X0, AX    struct_mixed.go:10    0x457cd4    4803442408      		ADDQ 0x8(SP), AX    struct_mixed.go:10    0x457cd9    c3          			RET     

从上面汇编代码中可以看到（代码有省略），主调 main.main 先将结构体成员值放入寄存器， 被调函数执行时，再从寄存器上将值取出并计算。

验证结果表明，结构体中同时包含整数和浮点数成员，且整数成员个数小于等于 9 个，浮点数成员小于等于 15 个，结构体通过寄存器传递。

3.6.5. 结构体整数成员 9 个，浮点数成员 16 个

示例中定义了一个 addStruct 函数，其入参类型为 Elem 结构体，该结构体有 9 个整数类型成员，16 个浮点数类型成员。如下：

type Elem struct {a, b, c, d, e, f, g, h, i intj, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y float64
}//go:noinline
func addStruct(e Elem) int {return e.a+int(e.m)
}func main() {_ = addStruct(Elem{1, 2, 3, 4, 5, 6, 7, 8, 9, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.1, 11.11, 12.12, 13.13, 14.14, 15.15, 16.16})
}

编译程序，并将编译成的二进制反汇编成汇编语言。

TEXT main.addStruct(SB) /home/ubuntu/program/reg_demo/struct_mixed_more.gostruct_mixed_more.go:10   0x457c20        f20f10442468    MOVSD_XMM 0x68(SP), X0  struct_mixed_more.go:10   0x457c26        f2480f2cc0      CVTTSD2SIQ X0, AX    struct_mixed_more.go:10   0x457c2b        4803442408      ADDQ 0x8(SP), AX    struct_mixed_more.go:10   0x457c30        c3          	RET      TEXT main.main(SB) /home/ubuntu/program/reg_demo/struct_mixed_more.go...    struct_mixed_more.go:14   0x457c62        48c7042401000000    MOVQ $0x1, 0(SP)      struct_mixed_more.go:14   0x457c6a        488d7c2408      	LEAQ 0x8(SP), DI      struct_mixed_more.go:14   0x457c6f        488d3532410200      LEAQ 0x24132(IP), SI      struct_mixed_more.go:14   0x457c76        660f1f840000000000  NOPW 0(AX)(AX*1)      struct_mixed_more.go:14   0x457c7f        90          		NOPL      struct_mixed_more.go:14   0x457c80        48896c24f0      	MOVQ BP, -0x10(SP)      struct_mixed_more.go:14   0x457c85        488d6c24f0      	LEAQ -0x10(SP), BP      struct_mixed_more.go:14   0x457c8a        e8c9d9ffff      	CALL 0x455658      struct_mixed_more.go:14   0x457c8f        488b6d00        	MOVQ 0(BP), BP      struct_mixed_more.go:14   0x457c93        e888ffffff      	CALL main.addStruct(SB)  

从上面汇编代码中可以看到，主调 main.main 在调用 main.addStruct 函数前，先将结构体值从只读数据段（0x24132(IP)）处拷贝到堆栈上，被调会从堆栈中取出参数值进行计算。

验证结果表明，结构体中同时包含整数和浮点数成员，且整数成员个数小于等于 9 个，浮点数成员大于 15 个，结构体通过堆栈传递。

进一步可得出结论，当结构体成员中整数成员超过整数寄存器个数或浮点数成员超过浮点数寄存器个数时，都会通过堆栈传递。

总结

• RAX、RBX、RCX、RDI, RSI、R8、R9、R10 和 R11 为整数寄存器，这 9 个寄存器的顺序也依次对应函数入参从左到右的顺序。

• X0~X14 为浮点数寄存器，X0、X1、X2 ... 的顺序也依次对应函数入参从左到右的顺序。

• 入参为整数时，会优先通过整数寄存器传递，当整数寄存器不够时，通过堆栈传递。

• 入参为浮点数时，会优先通过浮点数寄存器传递，当浮点数寄存器不够时，通过堆栈传递。

• 入参为数组时，只能通过堆栈传递。

• 当结构体做为函数入参时，结构体所包含的基本成员，要么全部通过寄存器传递，要么全部通过栈传递；不能一部分通过寄存器传递，一部分通过栈传递。

• 入参为结构体时，当结构体成员有数组时，整个结构体只能通过堆栈传递。

• 入参为结构体时，当整数成员小于9个，且浮点数成员小于15个时，整个结构体通过寄存器传递。

• 入参为结构体时，当整数成员大于9个，或浮点数成员大于15个时，整个结构体通过堆栈传递。