go 函数调用规则（三）

最新推荐文章于 2024-12-03 10:13:27 发布
原创 最新推荐文章于 2024-12-03 10:13:27 发布 · 601 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络安全

本文详细解析了Go函数如何处理大量参数，重点在于理解为何选择九个寄存器存放常用参数，其余存于栈顶，并揭示了返回值的处理方式。了解这些规则有助于编写高效可读的Go代码。

书接上回go 函数调用规则（二）
我们来解决最后一个问题
关于传参到底用哪些寄存器的问题

package main

func val(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t int) (a1 int, b1 int, c1 int, d1 int, e1 int, f1 int, g1 int, h1 int, i1 int, j1 int, k1 int, l1 int, m1 int, n1 int, o1 int, p1 int, q1 int, r1 int, s1 int, t1 int) {
	a1 = a + 2
	b1 = b * 2
	c1 = c + 3
	d1 = d * 3
	e1 = e + 4
	f1 = f * 4
	g1 = g + 1
	h1 = h + 1
	i1 = i + 1
	j1 = j + 1
	k1 = k + 1
	l1 = l + 1
	m1 = m + 1
	n1 = n + 1
	o1 = o + 1
	p1 = p + 1
	q1 = q + 1
	r1 = r + 1
	s1 = s + 1
	t1 = t + 1
	return
}

func test() {
	a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20 := val(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
	var c int = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 + a19 + a20
	c = c + 2
}

func main() {
	test()
}

丧心病狂的传了20个参数

依旧是无关紧要的main函数

sub     rsp, 8
mov     [rsp+8+var_8], rbp
lea     rbp, [rsp+8+var_8]
call    main_test
mov     rbp, [rsp+8+var_8]
add     rsp, 8
nop
retn

sub     rsp, 280h                     #开了0x280的栈
mov     [rsp+280h+var_8], rbp         #处理一下栈底指针
lea     rbp, [rsp+280h+var_8]
mov     [rsp+280h+var_280], 0Ah       #看的出来这是后十一个参数
mov     [rsp+280h+var_278], 0Bh       #直接就在栈顶
mov     [rsp+280h+var_270], 0Ch
mov     [rsp+280h+var_268], 0Dh
mov     [rsp+280h+var_260], 0Eh
mov     [rsp+280h+var_258], 0Fh
mov     [rsp+280h+var_250], 10h
mov     [rsp+280h+var_248], 11h
mov     [rsp+280h+var_240], 12h
mov     [rsp+280h+var_238], 13h
mov     [rsp+280h+var_230], 14h
mov     eax, 1                        #所以前九个是寄存器
mov     ebx, 2                        #eax  ebx  ecx  edi  esi  r8d  r9d  r10d  r11d
mov     ecx, 3
mov     edi, 4
mov     esi, 5
mov     r8d, 6
mov     r9d, 7
mov     r10d, 8
mov     r11d, 9
nop     dword ptr [rax+00h]
call    main_val                     #去看看val函数试试
mov     rdx, [rsp+280h+var_228]      #这是在处理返回的后十一个返回值
mov     r12, [rsp+280h+var_220]      #他们都被放在栈里的十一个传参参数的后面
mov     r13, [rsp+280h+var_218]
mov     r15, [rsp+280h+var_210]
mov     [rsp+280h+var_B0], r15
mov     r15, [rsp+280h+var_208]
mov     [rsp+280h+var_B8], r15
mov     r15, [rsp+280h+var_200]
mov     [rsp+280h+var_C0], r15
mov     r15, [rsp+280h+var_1F8]
mov     [rsp+280h+var_C8], r15
mov     r15, [rsp+280h+var_1F0]
mov     [rsp+280h+var_D0], r15
mov     r15, [rsp+280h+var_1E8]
mov     [rsp+280h+var_D8], r15
mov     r15, [rsp+280h+var_1E0]
mov     [rsp+280h+var_E0], r15
mov     r15, [rsp+280h+var_1D8]
mov     [rsp+280h+var_10], rax
mov     [rsp+280h+var_18], rbx
mov     [rsp+280h+var_20], rcx
mov     [rsp+280h+var_28], rdi
mov     [rsp+280h+var_30], rsi
mov     [rsp+280h+var_38], r8
mov     [rsp+280h+var_40], r9
mov     [rsp+280h+var_48], r10
mov     [rsp+280h+var_50], r11
mov     [rsp+280h+var_58], rdx
mov     [rsp+280h+var_60], r12
mov     [rsp+280h+var_68], r13
mov     rdx, [rsp+280h+var_B0]
mov     [rsp+280h+var_70], rdx
mov     rdx, [rsp+280h+var_B8]
mov     [rsp+280h+var_78], rdx
mov     rdx, [rsp+280h+var_C0]
mov     [rsp+280h+var_80], rdx
mov     rdx, [rsp+280h+var_C8]
mov     [rsp+280h+var_88], rdx
mov     rdx, [rsp+280h+var_D0]
mov     [rsp+280h+var_90], rdx
mov     rdx, [rsp+280h+var_D8]
mov     [rsp+280h+var_98], rdx
mov     rdx, [rsp+280h+var_E0]
mov     [rsp+280h+var_A0], rdx
mov     [rsp+280h+var_A8], r15
mov     rdx, [rsp+280h+var_10]
mov     [rsp+280h+var_E8], rdx
mov     rdx, [rsp+280h+var_18]
mov     [rsp+280h+var_140], rdx
mov     rdx, [rsp+280h+var_20]
mov     [rsp+280h+var_150], rdx
mov     rdx, [rsp+280h+var_28]
mov     [rsp+280h+var_158], rdx
mov     rdx, [rsp+280h+var_30]
mov     [rsp+280h+var_160], rdx
mov     rdx, [rsp+280h+var_38]
mov     [rsp+280h+var_168], rdx
mov     rdx, [rsp+280h+var_40]
mov     [rsp+280h+var_170], rdx
mov     rdx, [rsp+280h+var_48]
mov     [rsp+280h+var_178], rdx
mov     rdx, [rsp+280h+var_50]
mov     [rsp+280h+var_180], rdx
mov     rdx, [rsp+280h+var_58]
mov     [rsp+280h+var_F0], rdx
mov     rdx, [rsp+280h+var_60]
mov     [rsp+280h+var_F8], rdx
mov     rdx, [rsp+280h+var_68]
mov     [rsp+280h+var_100], rdx
mov     rdx, [rsp+280h+var_70]
mov     [rsp+280h+var_108], rdx
mov     rdx, [rsp+280h+var_78]
mov     [rsp+280h+var_110], rdx
mov     rdx, [rsp+280h+var_80]
mov     [rsp+280h+var_118], rdx
mov     rdx, [rsp+280h+var_88]
mov     [rsp+280h+var_120], rdx
mov     rdx, [rsp+280h+var_90]
mov     [rsp+280h+var_128], rdx
mov     rdx, [rsp+280h+var_98]
mov     [rsp+280h+var_130], rdx
mov     rdx, [rsp+280h+var_A0]
mov     [rsp+280h+var_138], rdx
mov     rdx, [rsp+280h+var_A8]
mov     [rsp+280h+var_148], rdx
mov     rdx, [rsp+280h+var_E8]
add     rdx, [rsp+280h+var_140]
add     rdx, [rsp+280h+var_150]
add     rdx, [rsp+280h+var_158]
add     rdx, [rsp+280h+var_160]
add     rdx, [rsp+280h+var_168]
add     rdx, [rsp+280h+var_170]
add     rdx, [rsp+280h+var_178]
add     rdx, [rsp+280h+var_180]
add     rdx, [rsp+280h+var_F0]
add     rdx, [rsp+280h+var_F8]
add     rdx, [rsp+280h+var_100]
add     rdx, [rsp+280h+var_108]
add     rdx, [rsp+280h+var_110]
add     rdx, [rsp+280h+var_118]
add     rdx, [rsp+280h+var_120]
add     rdx, [rsp+280h+var_128]
add     rdx, [rsp+280h+var_130]
add     rdx, [rsp+280h+var_138]
add     rdx, [rsp+280h+var_148]
mov     [rsp+280h+var_188], rdx
add     rdx, 2
mov     [rsp+280h+var_188], rdx
mov     rbp, [rsp+280h+var_8]
add     rsp, 280h
retn

val

var_50= qword ptr -50h
var_48= qword ptr -48h
var_40= qword ptr -40h
var_38= qword ptr -38h
var_30= qword ptr -30h
var_28= qword ptr -28h
var_20= qword ptr -20h
var_18= qword ptr -18h
var_10= qword ptr -10h
var_8= qword ptr -8
arg_0= qword ptr  8
arg_8= qword ptr  10h
arg_10= qword ptr  18h
arg_18= qword ptr  20h
arg_20= qword ptr  28h
arg_28= qword ptr  30h
arg_30= qword ptr  38h
arg_38= qword ptr  40h
arg_40= qword ptr  48h
arg_48= qword ptr  50h
arg_50= qword ptr  58h
arg_58= qword ptr  60h
arg_60= qword ptr  68h
arg_68= qword ptr  70h
arg_70= qword ptr  78h
arg_78= qword ptr  80h
arg_80= qword ptr  88h
arg_88= qword ptr  90h
arg_90= qword ptr  98h
arg_98= qword ptr  0A0h
arg_A0= qword ptr  0A8h
arg_A8= qword ptr  0B0h
arg_B0= qword ptr  0B8h
arg_B8= qword ptr  0C0h
arg_C0= qword ptr  0C8h
arg_C8= qword ptr  0D0h
arg_D0= qword ptr  0D8h
arg_D8= qword ptr  0E0h
arg_E0= qword ptr  0E8h
arg_E8= qword ptr  0F0h
arg_F0= qword ptr  0F8h

sub     rsp, 50h
mov     [rsp+50h+var_8], rbp
lea     rbp, [rsp+50h+var_8]
mov     [rsp+50h+arg_B0], rax        #可以看到前面九个参数放在了后面十一个参数的后面
mov     [rsp+50h+arg_B8], rbx
mov     [rsp+50h+arg_C0], rcx
mov     [rsp+50h+arg_C8], rdi
mov     [rsp+50h+arg_D0], rsi
mov     [rsp+50h+arg_D8], r8
mov     [rsp+50h+arg_E0], r9
mov     [rsp+50h+arg_E8], r10
mov     [rsp+50h+arg_F0], r11
mov     [rsp+50h+var_10], 0
mov     [rsp+50h+var_18], 0
mov     [rsp+50h+var_20], 0
mov     [rsp+50h+var_28], 0
mov     [rsp+50h+var_30], 0
mov     [rsp+50h+var_38], 0
mov     [rsp+50h+var_40], 0
mov     [rsp+50h+var_48], 0
mov     [rsp+50h+var_50], 0
mov     [rsp+50h+arg_58], 0           #但是两组参数中间隔了这么一段
mov     [rsp+50h+arg_60], 0
mov     [rsp+50h+arg_68], 0
mov     [rsp+50h+arg_70], 0
mov     [rsp+50h+arg_78], 0
mov     [rsp+50h+arg_80], 0
mov     [rsp+50h+arg_88], 0
mov     [rsp+50h+arg_90], 0
mov     [rsp+50h+arg_98], 0
mov     [rsp+50h+arg_A0], 0
mov     [rsp+50h+arg_A8], 0
mov     rdx, [rsp+50h+arg_B0]
add     rdx, 2
mov     [rsp+50h+var_10], rdx
mov     rdx, [rsp+50h+arg_B8]
shl     rdx, 1
mov     [rsp+50h+var_18], rdx
mov     rdx, [rsp+50h+arg_C0]
add     rdx, 3
mov     [rsp+50h+var_20], rdx
mov     rdx, [rsp+50h+arg_C8]
lea     rdx, [rdx+rdx*2]
mov     [rsp+50h+var_28], rdx
mov     rdx, [rsp+50h+arg_D0]
add     rdx, 4
mov     [rsp+50h+var_30], rdx
mov     rdx, [rsp+50h+arg_D8]
shl     rdx, 2
mov     [rsp+50h+var_38], rdx
mov     rdx, [rsp+50h+arg_E0]
inc     rdx
mov     [rsp+50h+var_40], rdx
mov     rdx, [rsp+50h+arg_E8]
inc     rdx
mov     [rsp+50h+var_48], rdx
mov     rdx, [rsp+50h+arg_F0]
inc     rdx
mov     [rsp+50h+var_50], rdx
mov     rdx, [rsp+50h+arg_0]
inc     rdx
mov     [rsp+50h+arg_58], rdx
mov     rdx, [rsp+50h+arg_8]
inc     rdx
mov     [rsp+50h+arg_60], rdx
mov     rdx, [rsp+50h+arg_10]
inc     rdx
mov     [rsp+50h+arg_68], rdx
mov     rdx, [rsp+50h+arg_18]
inc     rdx
mov     [rsp+50h+arg_70], rdx
mov     rdx, [rsp+50h+arg_20]
inc     rdx
mov     [rsp+50h+arg_78], rdx
mov     rdx, [rsp+50h+arg_28]
inc     rdx
mov     [rsp+50h+arg_80], rdx
mov     rdx, [rsp+50h+arg_30]
inc     rdx
mov     [rsp+50h+arg_88], rdx
mov     rdx, [rsp+50h+arg_38]
inc     rdx
mov     [rsp+50h+arg_90], rdx
mov     rdx, [rsp+50h+arg_40]
inc     rdx
mov     [rsp+50h+arg_98], rdx
mov     rdx, [rsp+50h+arg_48]
inc     rdx
mov     [rsp+50h+arg_A0], rdx
mov     rdx, [rsp+50h+arg_50]
inc     rdx
mov     [rsp+50h+arg_A8], rdx
mov     rax, [rsp+50h+var_10]       #返回的时候前面九个还是寄存器返回
mov     rbx, [rsp+50h+var_18]       #那十一个返回就放在两组参数中间隔着的那么一段中欧冠返回
mov     rcx, [rsp+50h+var_20]
mov     rdi, [rsp+50h+var_28]
mov     rsi, [rsp+50h+var_30]
mov     r8, [rsp+50h+var_38]
mov     r9, [rsp+50h+var_40]
mov     r10, [rsp+50h+var_48]
mov     r11, [rsp+50h+var_50]
mov     rbp, [rsp+50h+var_8]
add     rsp, 50h
retn
main_val endp

总结一下
这次就聚焦一个问题
函数传参比较多咋办？
可以看到传参的时候首先使用九个寄存器
分别是eax ebx ecx edi esi r8d r9d r10d r11d
剩下的都放在栈顶

返回的时候也是先使用那九个寄存器 剩下的要放在传参使用的栈之后的地方。

这就是go函数调用规则。

Go 1.17 的调用规约
cch1234的博客
08-31 405
Go 1.17 修改了用了很久的基于栈的调用规约，在了解 Go 的调用规约之前，我们得知道什么是调用规约。 x86 calling convention，简单概括一下，其实就是语言对于函数之间传参的一种约定。调用方要知道我要把参数按照什么形式，什么顺序传给被调用函数，被调用函数也遵守该规范去相应的位置找到传入的参数内容。 老版本的 Go 的参数传递图我们已经在很多很多地方见过了，这里贴一个我之前画的： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Pum18rH-16304
Golang语言基础—函数调用
ldxxxxll的博客
01-05 1769
所谓“调用惯例(calling convention)”是调用方和被调用方对于函数调用的一个明确的约定，包括：函数参数与返回值的传递方式、传递顺序。只有双方都遵守同样的约定，函数才能被正确地调用和执行。如果不遵守这个约定，函数将无法正确执行。可以看到：在调用my_function函数前，main函数将两个参数分别存到edi和esi两个寄存器中；在调用时，最后通过edx和eax接收到入参，并计算值存入eax寄存器（C语言的返回值都是存储在eax寄存器的），然后返回；如果参数过多会怎么样呢？
【go】函数调用
weixin_40660221的博客
02-21 654
go函数调用
Go 语言中的函数调用。
胤凯的博客
12-04 871
今天我们来学习一下 Go 语言中的函数调用
Go 函数的调用机制
baidu_41388533的博客
06-28 816
函数-调用过程 案例演示1 传入一个数+1 //一个函数 test func test(n1 int) { n1 = n1 + 1 fmt.Println("test() n1=", n1) //?输出结果= ? } func main() { n1 := 10 //调用test test(n1) fmt.Println("main() n1=", n1)//?输出结果= ? } 分析 输出 test() n1 = 11 main() n1 = 10 对上图说明
一文读懂Go函数调用
QcloudCommunity的博客
12-21 1286
导读｜Go的函数调用时参数是通过栈传递还是寄存器传递？使用哪个版本的Go语言能让程序运行性能提升5%？腾讯后台开发工程师涂明光将带你由浅入深了解函数调用，并结合不同版本Go进行实操解答。函数调用基本概念1）调用者caller与被调用者callee如果一个函数调用另外一个函数，那么该函数被称为调用者函数，也叫做caller，而被调用的函数称为被调用者函数，也叫做callee。比如函数main中调用s...
Go 语言函数编程指南：定义、调用技巧与返回值机制
博客虽小，世界尽在其中
12-03 1413
本文深入探讨了Go语言中函数的核心概念，从函数的定义、调用、参数传递到返回值，全面解析了Go语言函数的工作原理和实际应用。文章首先介绍了函数在编程中的基础地位，以及Go语言函数的基本语法和结构。随后，详细阐述了如何定义函数，包括函数名、参数列表、函数体等关键要素，并通过实例展示了不同类型的函数定义方式。 在函数调用部分，文章讲解了直接调用、嵌套调用和匿名函数调用等多种调用方式，帮助读者理解函数在不同场景下的使用方法。同时，文章还深入探讨了Go语言的参数传递机制，包括值传递和引用传递的区别，以及如何使用指针
go的函数调用
最新发布
10-18
解释Go语言中函数调用的基本概念，包括普通函数和方法的调用。 2. 结合之前的Employee结构体的例子，展示方法调用的例子。 3. 可以提及值接收者和指针接收者的调用区别（因为之前有值接收者的方法）。 4. 简单...
go语言中的函数详解
2302_79993788的博客
10-11 1288
/ 函数体// 可以包含一系列的语句和操作return value // 返回值（如果有）func: 关键字用于定义函数。: 函数名，用于唯一标识该函数。: 参数列表，函数可以接收零个或多个参数。每个参数由参数名和参数类型组成，多个参数之间使用逗号分隔。: 参数的类型，指定参数的数据类型。returnType: 返回类型，指定函数的返回值的数据类型。如果函数没有返回值，则返回类型为空。: 可选项，用于返回函数的结果。如果函数定义了返回类型，则需要使用return语句将结果返回给调用者。
Go 函数调用━栈和寄存器视角
leeright的博客
07-14 1405
函数的调用过程主要要点在于借助寄存器和内存帧栈传递参数和返回值。虽然同为编译型语言，Go 相较 C 对寄存器和栈的使用有一些差别，同时，Go 语言自带协程并引入 defer 等语句，在调用过程上显得更加复杂。 理解Go函数调用在CPU指令层的过程有助于编写高效的代码，在性能优化、Bug排查的时候，能更迅速的确定要点。本文以简短的示例代码和对应的汇编代码演示了Go的调用过程，展示了不同数据类型的参数...
go 函数调用规则（二）
yongbaoii的博客
04-28 536
gogogo
go语言函数的调用
CN_Eden
04-02 929
根据这个图，主函数main调用a函数，a函数调用b函数 package main import "fmt" func main() { A() //在go语言中最简单的调用这么写就可以，main主函数调用A函数 } func A(){ fmt.Println("开始执行A函数。。。") B() //A函数调用B函数 fmt.Println("B函数执行结束") //B函数执行完毕，继续执行 fmt.Printl
GO学习 --- 函数调用与注意事项
qq_46093575的博客
10-11 423
一、函数 传统解决方案 输入两个数，再输入一个运算符(+,-.*,/)，得到结果。 //goto入门练习 package main import ( "fmt" ) func main(){ //定义四个变量 var a1 float32 var a2 float32 var kay byte var a3 float32 fmt.Println("请输入") fmt.Scanln(&a1) fmt.Scanln(&a2) fmt.Scanf("%c",&a
go中函数的调用机制
实践求真知
04-11 288
一图解函数调用 程序员调用方法：给方法必要的输入，方法返回结果。 二 函数调用过程实战 1 传入一个数+1 说明 a 在调用一个函数时，会给该函数分配一个新的空间，编译器会通过自身的处理让这个新的空间和其它的栈的空间区分开来。 b 在每个函数对应的栈中，数据空间是独立的，不会混淆。 c 当一个函数调用完毕后，程序会销毁这个函数对应的栈空间。 2 计算两个数，并返回结果 代码 package main import ( "fmt" ) // 一个函数 getSum f.
go 函数调用规则（一）
yongbaoii的博客
04-28 1177
gogogo
go 普通函数调用流程
nostrud ipsum6
04-12 592
package main import "fmt" func main() { funca(3) //函数调用 fmt.Println("main") } func funca(a int){ funcb(a-1) fmt.Println("a=",a) } func funcb(b int) { ...
如何在Go中定义和调用函数
08-13 2110
介绍 (Introduction) A function is a section of code that, once defined, can be reused. Functions are used to make your code easier to understand by breaking it into small, understandable tasks that ca...
Go语言之函数使用(3)函数调用机制
Science Explorer
08-11 2235
一、函数调用的机制和原则: 当编译器执行调用函数时，就会开辟一个新的数据空间, 该空间的独立[是编译器处理] 各个数据空间在栈中。 二、通过案例，画出示意图理解函数调用过程 1、实现：函数使用传入一个数+1 package main import ( "fmt" ) func test(n1 int) { n1++ fmt.Println("n1=",...
Go 函数的使用
weixin_44719499的博客
11-04 876
func 函数名(参数列表) 返回值类型 {// 函数体return 返回值在Go语言中，type关键字用于定义新的类型。通过type，可以为现有类型创建别名、自定义结构体、定义接口等。type关键字在代码中非常有用，尤其是当需要提高代码的可读性、复用性和类型安全性时。以下是Go中type的主要用法和示例。type最常用的用途是定义结构体，用于将不同类型的数据组合在一起，创建一个复杂的数据类型。// 定义一个结构体PersonAge intGo语言是接口类型的组合编程语言，通过type。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值