go 函数调用规则（二）

最新推荐文章于 2023-12-04 12:27:53 发布
最新推荐文章于 2023-12-04 12:27:53 发布
阅读量424 收藏 1
点赞数 1
分类专栏： CTF 文章标签： 网络安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yongbaoii/article/details/123748333
版权

承接上文
go 函数调用规则（一）

我们试图改变这个源码

package main

func val(a, b, c, d, e, f int) (a1 int, b1 int, c1 int, d1 int, e1 int, f1 int) {
	a1 = a + 2
	b1 = b * 2
	c1 = c + 3
	d1 = d * 3
	e1 = e + 4
	f1 = f * 4
	return
}

func vall(a, b, c, d, e int) (a1 int, b1 int, c1 int, d1 int, e1 int) {
	a1 = a + 22
	b1 = b * 22
	c1 = c + 33
	d1 = d * 33
	e1 = e + 44
	return
}

func test() {
	a1, a2, a3, a4, a5, a6 := val(1, 2, 3, 4, 5, 6)
	b1, b2, b3, b4, b5 := vall(11, 22, 33, 44, 55)
	var c int = a1 + a2 + a3 + a4 + a5 + b1 + b2 + b3 + b4 + b5 + a6
	c = c + 2
}

func main() {
	test()
}

这个程序就要复杂一下了
我们慢慢看

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

test

var_98= qword ptr -98h
var_90= qword ptr -90h
var_88= qword ptr -88h
var_80= qword ptr -80h
var_78= qword ptr -78h
var_70= qword ptr -70h
var_68= qword ptr -68h
var_60= qword ptr -60h
var_58= qword ptr -58h
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


sub     rsp, 0C8h                   #栈直接拉了0xc8
mov     [rsp+0C8h+var_8], rbp       #栈底当然还是rbp栈底指针
lea     rbp, [rsp+0C8h+var_8]       
mov     eax, 1                      #这次把六个参数分别放在了eax  ebx  ecx  edi  esi  r8d
mov     ebx, 2
mov     ecx, 3
mov     edi, 4
mov     esi, 5
mov     r8d, 6
call    main_val                    #然后调函数
                                    #rax rbx rcx rdi rsi r8这六个寄存器里面是返回值
                                    #调用函数的时候栈顶六个直接是参数
mov     [rsp+0C8h+var_10], rax      #然后这六个返回值先放在栈指针上面六个
mov     [rsp+0C8h+var_18], rbx      #紧接着又往上再复制了一次
mov     [rsp+0C8h+var_20], rcx
mov     [rsp+0C8h+var_28], rdi
mov     [rsp+0C8h+var_30], rsi
mov     [rsp+0C8h+var_38], r8
mov     rdx, [rsp+0C8h+var_10]
mov     [rsp+0C8h+var_40], rdx
mov     rdx, [rsp+0C8h+var_18]
mov     [rsp+0C8h+var_48], rdx
mov     rdx, [rsp+0C8h+var_20]
mov     [rsp+0C8h+var_50], rdx
mov     rdx, [rsp+0C8h+var_28]
mov     [rsp+0C8h+var_58], rdx
mov     rdx, [rsp+0C8h+var_30]
mov     [rsp+0C8h+var_60], rdx
mov     rdx, [rsp+0C8h+var_38]
mov     [rsp+0C8h+var_68], rdx
mov     eax, 0Bh                   #调用另一个函数的时候直接传参
mov     ebx, 16h
mov     ecx, 21h ; '!'
mov     edi, 2Ch ; ','
mov     esi, 37h ; '7'
call    main_vall                  #调用vall
mov     [rsp+0C8h+var_38], rax     #用的是离栈进的五个  这没关系 之前的数据复制在了上面
mov     [rsp+0C8h+var_30], rbx
mov     [rsp+0C8h+var_28], rcx
mov     [rsp+0C8h+var_20], rdi
mov     [rsp+0C8h+var_18], rsi
mov     rdx, [rsp+0C8h+var_38]
mov     [rsp+0C8h+var_70], rdx     #他也把数据复制过来
mov     rdx, [rsp+0C8h+var_30]
mov     [rsp+0C8h+var_78], rdx
mov     rdx, [rsp+0C8h+var_28]
mov     [rsp+0C8h+var_80], rdx
mov     rdx, [rsp+0C8h+var_20]
mov     [rsp+0C8h+var_88], rdx
mov     rdx, [rsp+0C8h+var_18]
mov     [rsp+0C8h+var_90], rdx
mov     rdx, [rsp+0C8h+var_40]     
add     rdx, [rsp+0C8h+var_48]
add     rdx, [rsp+0C8h+var_50]
add     rdx, [rsp+0C8h+var_58]
add     rdx, [rsp+0C8h+var_60]
add     rdx, [rsp+0C8h+var_70]
add     rdx, [rsp+0C8h+var_78]
add     rdx, [rsp+0C8h+var_80]
add     rdx, [rsp+0C8h+var_88]
add     rdx, [rsp+0C8h+var_90]
add     rdx, [rsp+0C8h+var_68]
mov     [rsp+0C8h+var_98], rdx
add     rdx, 2
mov     [rsp+0C8h+var_98], rdx
mov     rbp, [rsp+0C8h+var_8]
add     rsp, 0C8h
retn

val

public main_val
main_val proc near

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

sub     rsp, 38h                   #栈
mov     [rsp+38h+var_8], rbp
lea     rbp, [rsp+38h+var_8]
mov     [rsp+38h+arg_0], rax       #六个参数分别归为
mov     [rsp+38h+arg_8], rbx       #顺序还是stdcall从右往左压栈顺序
mov     [rsp+38h+arg_10], rcx
mov     [rsp+38h+arg_18], rdi
mov     [rsp+38h+arg_20], rsi
mov     [rsp+38h+arg_28], r8
mov     [rsp+38h+var_10], 0        #六个临时变量清零
mov     [rsp+38h+var_18], 0
mov     [rsp+38h+var_20], 0
mov     [rsp+38h+var_28], 0
mov     [rsp+38h+var_30], 0
mov     [rsp+38h+var_38], 0
mov     rdx, [rsp+38h+arg_0]       #下面又是计算过程 可以不看
add     rdx, 2
mov     [rsp+38h+var_10], rdx
mov     rdx, [rsp+38h+arg_8]
shl     rdx, 1
mov     [rsp+38h+var_18], rdx
mov     rdx, [rsp+38h+arg_10]
add     rdx, 3
mov     [rsp+38h+var_20], rdx
mov     rdx, [rsp+38h+arg_18]
lea     rdx, [rdx+rdx*2]
mov     [rsp+38h+var_28], rdx
mov     rdx, [rsp+38h+arg_20]
add     rdx, 4
mov     [rsp+38h+var_30], rdx
mov     r8, [rsp+38h+arg_28]
shl     r8, 2
mov     [rsp+38h+var_38], r8
mov     rax, [rsp+38h+var_10]  #返回也是这六个寄存器返回的
mov     rbx, [rsp+38h+var_18]
mov     rcx, [rsp+38h+var_20]
mov     rdi, [rsp+38h+var_28]
mov     rsi, [rsp+38h+var_30]
mov     rbp, [rsp+38h+var_8]
add     rsp, 38h
retn
main_val endp

vall

public main_vall
main_vall proc near

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

sub     rsp, 30h
mov     [rsp+30h+var_8], rbp
lea     rbp, [rsp+30h+var_8]     #其他的没啥  重点是关注它的参数还是放在了栈下面
mov     [rsp+30h+arg_0], rax
mov     [rsp+30h+arg_8], rbx
mov     [rsp+30h+arg_10], rcx
mov     [rsp+30h+arg_18], rdi
mov     [rsp+30h+arg_20], rsi
mov     [rsp+30h+var_10], 0
mov     [rsp+30h+var_18], 0
mov     [rsp+30h+var_20], 0
mov     [rsp+30h+var_28], 0
mov     [rsp+30h+var_30], 0
mov     rdx, [rsp+30h+arg_0]
add     rdx, 16h
mov     [rsp+30h+var_10], rdx
mov     rdx, [rsp+30h+arg_8]
imul    rdx, 16h
mov     [rsp+30h+var_18], rdx
mov     rdx, [rsp+30h+arg_10]
add     rdx, 21h ; '!'
mov     [rsp+30h+var_20], rdx
mov     rdx, [rsp+30h+arg_18]
mov     r8, rdx
shl     rdx, 5
add     rdx, r8
mov     [rsp+30h+var_28], rdx
mov     rdx, [rsp+30h+arg_20]
lea     rsi, [rdx+2Ch]
mov     [rsp+30h+var_30], rsi
mov     rax, [rsp+30h+var_10]
mov     rbx, [rsp+30h+var_18]
mov     rcx, [rsp+30h+var_20]
mov     rdi, [rsp+30h+var_28]
mov     rbp, [rsp+30h+var_8]
add     rsp, 30h
retn
main_vall endp

总结一下
我们这次实验重点就是想解决两个问题
第一个传参 返回值使用寄存器是啥？
现在的结果是 rax rbx rcx rdi rsi r8

第二个问题是当一个函数调用两个参数不同返回值不同的函数时候函数的栈会怎么分布？
我们的结论是：栈顶是传参的参数 栈底是返回值
多个函数的时候这两块地方就是复用 取最大的来开空间

还有一个问题，我们现在函数的参数 返回值都是六个，那如果我们再多呢？

yongbaoii
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go语言之函数使用(3)函数调用机制
Science Explorer
08-11 2135
一、函数调用的机制和原则: 当编译器执行调用函数时，就会开辟一个新的数据空间, 该空间的独立[是编译器处理] 各个数据空间在栈中。 二、通过案例，画出示意图理解函数调用过程 1、实现：函数使用传入一个数+1 package main import ( "fmt" ) func test(n1 int) { n1++ fmt.Println("n1=",...
【go】函数调用
weixin_40660221的博客
02-21 578
go函数调用
Go 语言中的函数调用。
最新发布
胤凯的博客
12-04 648
今天我们来学习一下 Go 语言中的函数调用
go中函数的调用机制
实践求真知
04-11 241
一图解函数调用 程序员调用方法：给方法必要的输入，方法返回结果。 二 函数调用过程实战 1 传入一个数+1 说明 a 在调用一个函数时，会给该函数分配一个新的空间，编译器会通过自身的处理让这个新的空间和其它的栈的空间区分开来。 b 在每个函数对应的栈中，数据空间是独立的，不会混淆。 c 当一个函数调用完毕后，程序会销毁这个函数对应的栈空间。 2 计算两个数，并返回结果 代码 package main import ( "fmt" ) // 一个函数 getSum f.
go 函数调用规则（三）
yongbaoii的博客
04-28 501
gogogo
Go语言init函数详解
09-19
- `init`函数不能被其他函数调用，它们是隐式调用的。 - 每个源文件可以包含多个`init`函数，它们都会被执行，执行顺序取决于源文件的排列。 - 如果一个包被导入多次，它的`init`函数只会被执行一次。 4. **Go包...
Go语言中对函数进行简单的性能测试
01-20
在Go语言中，进行函数的性能测试是优化代码的关键步骤，可以帮助开发者了解代码执行效率，以便选择最佳实现方式。在给定的示例中，我们看到了一个关于计算一个整数中1的个数（也称为位计数）的简单性能测试。 首先...
go语言的panic和recover函数用法实例
09-19
3. **调用runtime包中的panic函数**：Go语言标准库中的`runtime`包提供了具体的panic处理逻辑。 4. **报告异常信息**：程序会打印出panic传递的值，并终止当前goroutine。 #### 三、recover函数详解 `recover`函数...
gra-GO.rar_Go_ Go_ Go!_go调用C#
09-21
_go调用C#" 指的是一个关于Go语言（Golang）与C#交互的项目，可能是一个五子棋游戏（gomoku game），其中Go语言作为主要开发语言，而C#可能是用于特定功能或者界面的实现。 【描述】"gomoku game in csharp, c#" ...
Go语言底层原理剖析.pdf
11-30
函数调用是Go语言中非常重要的一部分，函数调用规范是Go语言设计的核心之一。Go语言中函数调用可以分为两种：同步调用和异步调用。同步调用是指函数调用者等待函数返回结果，而异步调用是指函数调用者不等待函数返回...
一文读懂Go函数调用
QcloudCommunity的博客
12-21 1146
导读｜Go的函数调用时参数是通过栈传递还是寄存器传递？使用哪个版本的Go语言能让程序运行性能提升5%？腾讯后台开发工程师涂明光将带你由浅入深了解函数调用，并结合不同版本Go进行实操解答。函数调用基本概念1）调用者caller与被调用者callee如果一个函数调用另外一个函数，那么该函数被称为调用者函数，也叫做caller，而被调用的函数称为被调用者函数，也叫做callee。比如函数main中调用s...
go语言函数的调用
CN_Eden
04-02 842
根据这个图，主函数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 340
一、函数 传统解决方案 输入两个数，再输入一个运算符(+,-.*,/)，得到结果。 //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 函数调用规则（一）
yongbaoii的博客
04-28 1054
gogogo
go 普通函数调用流程
复制粘贴攻城狮
04-12 186
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) { funcc...
面试官：来说一说Go语言的函数调用惯例
EDDYCJY的博客
04-08 694
前言哈喽，大家好，我是asong。好久没有更新了，最近因工作需要忙着写python，Go语言我都有些生疏了，但是我不能放弃Go语言，该学习还是要学习的，今天与大家聊一聊Go语言的函数调用惯例，调用惯例是调用方和被调用方对于参数和返回值传递的约定，Go语言的调用惯例在1.17版本进行了优化，本文我们就看一下两个版本的调用惯例是什么样的吧～。1.17版本前栈传递在Go1.17...
如何在Go中定义和调用函数
08-13 1898
介绍 (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 函数的调用机制
baidu_41388533的博客
06-28 763
函数-调用过程 案例演示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——方法调用
吴声子夜歌的博客
05-02 602
命名类型方法接收者有两种类型，一个是值类型，另一个是指针类型，这个和函数是一样的，前者的形参是值类型，后者的形参是指针类型。下面定义一个类型T,增加两个方法，方法Gt的接收者为T,方法Set的接收者类型为*T。上面示例定义了一个新类型Int,新类型的底层类型是int,Int虽然不能继承int的方法，但底层类型支持的操作（算术运算和赋值运算）可以被上层类型继承，这是Go类型系统的一个特点。变量x的静态类型是T,M是类型T的一个方法，x.T被称为方法值(method value)。T类型的方法集是S和。
Go语言函数调用与CGO编程详解
在Go语言中，函数调用遵循一定的规则和约定，包括参数传递、返回值以及函数体内的逻辑。 1.1 Go语言的函数定义和调用语法与其他高级语言类似，但有其独特之处，如支持多返回值和匿名函数（闭包）。 1.2 Hello, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值