首页 > 其他分享 >函数调用栈

函数调用栈

时间:2024-07-14 11:29:29浏览次数:19  
标签:00 48 mov 函数调用 rbp ff rax

1、程序源代码:

[xuanmiao@localhost Practice]$ cat main.c
#include <stdio.h>

int plus(int a, int b)
{
    int c = a+b;
    return c;
}

int main()
{
    int a = 1, b = 2;
    int c = 0;
    c = plus(a,b);
    return 0;
} 

2、编译

[xuanmiao@localhost Practice]$ gcc main.c -o main -g
[xuanmiao@localhost Practice]$ ls
main  main.c

3、生成汇编代码(此处只取main和plus函数部分)

汇编代码
 [xuanmiao@localhost Practice]$ cat main.txt 

main:     file format elf64-x86-64


Disassembly of section .init:

00000000004003a8 <_init>:
  4003a8:	48 83 ec 08          	sub    $0x8,%rsp
  4003ac:	48 8b 05 45 0c 20 00 	mov    0x200c45(%rip),%rax        # 600ff8 <__gmon_start__>
  4003b3:	48 85 c0             	test   %rax,%rax
  4003b6:	74 05                	je     4003bd <_init+0x15>
  4003b8:	e8 33 00 00 00       	callq  4003f0 <__gmon_start__@plt>
  4003bd:	48 83 c4 08          	add    $0x8,%rsp
  4003c1:	c3                   	retq   

Disassembly of section .plt:

00000000004003d0 <.plt>:
  4003d0:	ff 35 32 0c 20 00    	pushq  0x200c32(%rip)        # 601008 <_GLOBAL_OFFSET_TABLE_+0x8>
  4003d6:	ff 25 34 0c 20 00    	jmpq   *0x200c34(%rip)        # 601010 <_GLOBAL_OFFSET_TABLE_+0x10>
  4003dc:	0f 1f 40 00          	nopl   0x0(%rax)

00000000004003e0 <__libc_start_main@plt>:
  4003e0:	ff 25 32 0c 20 00    	jmpq   *0x200c32(%rip)        # 601018 <__libc_start_main@GLIBC_2.2.5>
  4003e6:	68 00 00 00 00       	pushq  $0x0
  4003eb:	e9 e0 ff ff ff       	jmpq   4003d0 <.plt>

00000000004003f0 <__gmon_start__@plt>:
  4003f0:	ff 25 2a 0c 20 00    	jmpq   *0x200c2a(%rip)        # 601020 <__gmon_start__>
  4003f6:	68 01 00 00 00       	pushq  $0x1
  4003fb:	e9 d0 ff ff ff       	jmpq   4003d0 <.plt>

Disassembly of section .text:

0000000000400400 <_start>:
  400400:	31 ed                	xor    %ebp,%ebp
  400402:	49 89 d1             	mov    %rdx,%r9
  400405:	5e                   	pop    %rsi
  400406:	48 89 e2             	mov    %rsp,%rdx
  400409:	48 83 e4 f0          	and    $0xfffffffffffffff0,%rsp
  40040d:	50                   	push   %rax
  40040e:	54                   	push   %rsp
  40040f:	49 c7 c0 b0 05 40 00 	mov    $0x4005b0,%r8
  400416:	48 c7 c1 40 05 40 00 	mov    $0x400540,%rcx
  40041d:	48 c7 c7 07 05 40 00 	mov    $0x400507,%rdi
  400424:	e8 b7 ff ff ff       	callq  4003e0 <__libc_start_main@plt>
  400429:	f4                   	hlt    
  40042a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000400430 <deregister_tm_clones>:
  400430:	b8 37 10 60 00       	mov    $0x601037,%eax
  400435:	55                   	push   %rbp
  400436:	48 2d 30 10 60 00    	sub    $0x601030,%rax
  40043c:	48 83 f8 0e          	cmp    $0xe,%rax
  400440:	48 89 e5             	mov    %rsp,%rbp
  400443:	77 02                	ja     400447 <deregister_tm_clones+0x17>
  400445:	5d                   	pop    %rbp
  400446:	c3                   	retq   
  400447:	b8 00 00 00 00       	mov    $0x0,%eax
  40044c:	48 85 c0             	test   %rax,%rax
  40044f:	74 f4                	je     400445 <deregister_tm_clones+0x15>
  400451:	5d                   	pop    %rbp
  400452:	bf 30 10 60 00       	mov    $0x601030,%edi
  400457:	ff e0                	jmpq   *%rax
  400459:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

0000000000400460 <register_tm_clones>:
  400460:	b8 30 10 60 00       	mov    $0x601030,%eax
  400465:	55                   	push   %rbp
  400466:	48 2d 30 10 60 00    	sub    $0x601030,%rax
  40046c:	48 c1 f8 03          	sar    $0x3,%rax
  400470:	48 89 e5             	mov    %rsp,%rbp
  400473:	48 89 c2             	mov    %rax,%rdx
  400476:	48 c1 ea 3f          	shr    $0x3f,%rdx
  40047a:	48 01 d0             	add    %rdx,%rax
  40047d:	48 d1 f8             	sar    %rax
  400480:	75 02                	jne    400484 <register_tm_clones+0x24>
  400482:	5d                   	pop    %rbp
  400483:	c3                   	retq   
  400484:	ba 00 00 00 00       	mov    $0x0,%edx
  400489:	48 85 d2             	test   %rdx,%rdx
  40048c:	74 f4                	je     400482 <register_tm_clones+0x22>
  40048e:	5d                   	pop    %rbp
  40048f:	48 89 c6             	mov    %rax,%rsi
  400492:	bf 30 10 60 00       	mov    $0x601030,%edi
  400497:	ff e2                	jmpq   *%rdx
  400499:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

00000000004004a0 <__do_global_dtors_aux>:
  4004a0:	80 3d 85 0b 20 00 00 	cmpb   $0x0,0x200b85(%rip)        # 60102c <_edata>
  4004a7:	75 11                	jne    4004ba <__do_global_dtors_aux+0x1a>
  4004a9:	55                   	push   %rbp
  4004aa:	48 89 e5             	mov    %rsp,%rbp
  4004ad:	e8 7e ff ff ff       	callq  400430 <deregister_tm_clones>
  4004b2:	5d                   	pop    %rbp
  4004b3:	c6 05 72 0b 20 00 01 	movb   $0x1,0x200b72(%rip)        # 60102c <_edata>
  4004ba:	f3 c3                	repz retq 
  4004bc:	0f 1f 40 00          	nopl   0x0(%rax)

00000000004004c0 <frame_dummy>:
  4004c0:	48 83 3d 58 09 20 00 	cmpq   $0x0,0x200958(%rip)        # 600e20 <__JCR_END__>
  4004c7:	00 
  4004c8:	74 1e                	je     4004e8 <frame_dummy+0x28>
  4004ca:	b8 00 00 00 00       	mov    $0x0,%eax
  4004cf:	48 85 c0             	test   %rax,%rax
  4004d2:	74 14                	je     4004e8 <frame_dummy+0x28>
  4004d4:	55                   	push   %rbp
  4004d5:	bf 20 0e 60 00       	mov    $0x600e20,%edi
  4004da:	48 89 e5             	mov    %rsp,%rbp
  4004dd:	ff d0                	callq  *%rax
  4004df:	5d                   	pop    %rbp
  4004e0:	e9 7b ff ff ff       	jmpq   400460 <register_tm_clones>
  4004e5:	0f 1f 00             	nopl   (%rax)
  4004e8:	e9 73 ff ff ff       	jmpq   400460 <register_tm_clones>

00000000004004ed <plus>:
#include <stdio.h>

int plus(int a, int b)
{
  4004ed:	55                   	push   %rbp
  4004ee:	48 89 e5             	mov    %rsp,%rbp
  4004f1:	89 7d ec             	mov    %edi,-0x14(%rbp)
  4004f4:	89 75 e8             	mov    %esi,-0x18(%rbp)
    int c = a+b;
  4004f7:	8b 45 e8             	mov    -0x18(%rbp),%eax
  4004fa:	8b 55 ec             	mov    -0x14(%rbp),%edx
  4004fd:	01 d0                	add    %edx,%eax
  4004ff:	89 45 fc             	mov    %eax,-0x4(%rbp)
    return c;
  400502:	8b 45 fc             	mov    -0x4(%rbp),%eax
}
  400505:	5d                   	pop    %rbp
  400506:	c3                   	retq   

0000000000400507 <main>:

int main()
{
  400507:	55                   	push   %rbp
  400508:	48 89 e5             	mov    %rsp,%rbp
  40050b:	48 83 ec 10          	sub    $0x10,%rsp
    int a = 1, b = 2;
  40050f:	c7 45 fc 01 00 00 00 	movl   $0x1,-0x4(%rbp)
  400516:	c7 45 f8 02 00 00 00 	movl   $0x2,-0x8(%rbp)
    int c = 0;
  40051d:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%rbp)
    c = plus(a,b);
  400524:	8b 55 f8             	mov    -0x8(%rbp),%edx
  400527:	8b 45 fc             	mov    -0x4(%rbp),%eax
  40052a:	89 d6                	mov    %edx,%esi
  40052c:	89 c7                	mov    %eax,%edi
  40052e:	e8 ba ff ff ff       	callq  4004ed <plus>
  400533:	89 45 f4             	mov    %eax,-0xc(%rbp)
    return 0;
  400536:	b8 00 00 00 00       	mov    $0x0,%eax
} 
  40053b:	c9                   	leaveq 
  40053c:	c3                   	retq   
  40053d:	0f 1f 00             	nopl   (%rax)

0000000000400540 <__libc_csu_init>:
  400540:	41 57                	push   %r15
  400542:	41 89 ff             	mov    %edi,%r15d
  400545:	41 56                	push   %r14
  400547:	49 89 f6             	mov    %rsi,%r14
  40054a:	41 55                	push   %r13
  40054c:	49 89 d5             	mov    %rdx,%r13
  40054f:	41 54                	push   %r12
  400551:	4c 8d 25 b8 08 20 00 	lea    0x2008b8(%rip),%r12        # 600e10 <__frame_dummy_init_array_entry>
  400558:	55                   	push   %rbp
  400559:	48 8d 2d b8 08 20 00 	lea    0x2008b8(%rip),%rbp        # 600e18 <__init_array_end>
  400560:	53                   	push   %rbx
  400561:	4c 29 e5             	sub    %r12,%rbp
  400564:	31 db                	xor    %ebx,%ebx
  400566:	48 c1 fd 03          	sar    $0x3,%rbp
  40056a:	48 83 ec 08          	sub    $0x8,%rsp
  40056e:	e8 35 fe ff ff       	callq  4003a8 <_init>
  400573:	48 85 ed             	test   %rbp,%rbp
  400576:	74 1e                	je     400596 <__libc_csu_init+0x56>
  400578:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40057f:	00 
  400580:	4c 89 ea             	mov    %r13,%rdx
  400583:	4c 89 f6             	mov    %r14,%rsi
  400586:	44 89 ff             	mov    %r15d,%edi
  400589:	41 ff 14 dc          	callq  *(%r12,%rbx,8)
  40058d:	48 83 c3 01          	add    $0x1,%rbx
  400591:	48 39 eb             	cmp    %rbp,%rbx
  400594:	75 ea                	jne    400580 <__libc_csu_init+0x40>
  400596:	48 83 c4 08          	add    $0x8,%rsp
  40059a:	5b                   	pop    %rbx
  40059b:	5d                   	pop    %rbp
  40059c:	41 5c                	pop    %r12
  40059e:	41 5d                	pop    %r13
  4005a0:	41 5e                	pop    %r14
  4005a2:	41 5f                	pop    %r15
  4005a4:	c3                   	retq   
  4005a5:	90                   	nop
  4005a6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  4005ad:	00 00 00 

00000000004005b0 <__libc_csu_fini>:
  4005b0:	f3 c3                	repz retq 

Disassembly of section .fini:

00000000004005b4 <_fini>:
  4005b4:	48 83 ec 08          	sub    $0x8,%rsp
  4005b8:	48 83 c4 08          	add    $0x8,%rsp
  4005bc:	c3                   	retq

标签:00,48,mov,函数调用,rbp,ff,rax
From: https://www.cnblogs.com/czy363/p/18301286

相关文章

  • 09 为内核支持函数调用
    在[[08内核第一条指令|上一节]]我们使用了编写entry.asm函数中编写了内核的第一条指令,但是我们使用的汇编.这里注意我们仍然是嵌入了这段asm代码到我们的rust代码之中,然后进行编译.但是即使连使用fnmain都不被允许,因此我们如果希望使用rust来编写内核代码,因此我们最好为内核......
  • zip-zip(子函数调用)
    题目监听服务器端口,得到题目如下:源码解析主函数主函数中是题目界面的逻辑,对应于用户的选择做出相应的操作,其中需要注意的是选项2,解压操作需要获得root权限(uid==0).选项1,2:文件压缩和解压缩,是常规的文件压缩代码,不做解释。选项3:buy操作,buy()函数调用了加密函数en......
  • 【AI 大模型】大模型应用架构 ( 业务架构 - AI Embedded、AI Copilot、AI Agent | 技
    文章目录一、大模型技术方向-大模型训练/大模型应用二、大模型应用-业务架构1、AIEmbedded模式2、AICopilot模式3、AIAgent模式三、大模型应用-技术架构1、提示词技术架构2、Agent+FunctionCalling技术架构3、RAG技术架构4、Fine-tuning微调技术......
  • 现代 C++ 中的一次函数调用的工作流程
    现代C++中的一次函数调用的工作流程ChatGPT4o给的答案:函数声明解析编译器首先解析函数调用,确定要调用的函数。这包括名称查找、重载解析和模板实例化。参数传递编译器检查传递的参数与函数签名是否匹配。如果有隐式类型转换,编译器会进行必要的类型转换。函数调用......
  • Qwen-Agent:Qwen2加持,强大的多代理框架 - 函数调用、代码解释器以及 RAG!
    ✨点击这里✨:......
  • OpenAI函数调用:使用Assistants API函数工具的一个示例
    AreyoulookingtoexpandGPT'scapabilities?CheckoutthistutorialforacompleteexampleofanAIAssistantthatcansendemailswheneverweaskitto.您是否希望扩展GPT的功能?查看这个教程,它提供了一个完整的示例,展示了一个AI助手如何在我们要求时发送电子邮......
  • C程序函数调用&系统调用
    理解程序的执行我们要知道CPU可以自由地访问寄存器、内存。另外,程序是由操作系统执行的,所以操作系统能够控制程序的所有执行情况,限制程序的行为。程序地执行过程:程序是一个二进制文件,包含程序的代码指令、代码中的文本信息等(参考C语言的程序的各种段)执行一个程序后,会将这个二......
  • risc-v中的函数调用
    先来看一个普通main函数的完整执行过程(以a=bproblem为例)intmain(){inta=2;intb=3;intc=a+b;}其risc-v(rv32)的汇编如下main:addisp,sp,-32#将栈指针sp向下移动32个字节,预留栈空间swra,28(sp)#将返回地址ra存......
  • C语言杂谈:函数栈帧,函数调用时到底发生了什么
            我们都知道在调用函数时,要为函数在栈上开辟空间,函数后续内容都会在栈帧空间中保存,如非静态局部变量,返回值等。这段空间就叫栈帧。    当函数调用,就会开辟栈帧空间,函数返回时,栈帧空间就会被释放。这里的释放并非清空,而是让其无效化,可以后续的使用。1,......
  • GLM-4-9B领先!伯克利函数调用榜单BFCL的Function Calling评测方法解析与梳理
    智谱公布的GLM-4-9B基于BFCL榜单的工具调用能力测试结果©作者|格林来源|神州问学在智谱最新开源的GLM-4-9B-Chat中,其工具调用能力在BFCL(伯克利函数调用排行榜)榜上获得了超高的总BFCL分,和gpt-4-turbo-2024-04-09几乎不相上下。在榜单中,还提到了AST总分以及Exec总分两个......