汇编调用到C语言mian函数--中间究竟发生了什么过程

最新推荐文章于 2025-06-14 14:17:38 发布
原创 最新推荐文章于 2025-06-14 14:17:38 发布 · 1.5k 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#安全
本文深入探讨了C语言程序启动时，从汇编到main函数执行前的内部流程。通过实例分析，揭示了_start函数、__libc_start_main函数的作用及与main函数的关系，解释了Scrt1.o文件和libc库在程序启动过程中的关键作用。

最近面试，技术经理问我汇编到main函数步骤是什么，当时我是一脸疑惑，what？main函数就不是C语言调用第一个函数吗？后面我自己查了相关资料，才发现自己too young too navie.

很多人只知道main函数是c语言的第一个调用函数，其实不是，下面用个例子说明

在开始讲解之前，我先科普一下知识，平时我们编译.c文件是，一般分为三个步骤：
第一步生成汇编代码
第二部生成目标文件
第三步生成可执行文件

[test@localhost Assembler]$ gcc -S main.c 
[test@localhost Assembler]$ gcc -c main.s 
[test@localhost Assembler]$ gcc main.o

-S生成汇编代码，-c生成目标文件，gcc生成可执行文件。

gcc的过程
好了，下面我们来写个程序！
创建一个test.c文件，里面写以下代码

#include <stdio.h>
#include <stdlib.h>

嘻嘻，没错，我故意没写main函数，看看会编译后会发生什么结果！

在这里插入图片描述
这个编译结果有两个意思，第一个是在Scrt1.o文件里调用了_start函数。第二个意思是在_start函数中没调用main函数。这说明main函数并不是我们所说的C语言第一个调用的函数，下面用更具体的证据证明。

下面我们查看Scrt1.o里面调用了什么：
在这里插入图片描述D是初始化data段，U是undefined的含义，说明main函数在该文件中未定义，但是T _start代表存在代码区 _start，并且在_start里面调用了main函数，进一步证实了我们的猜测。

如果小伙伴想深究下去main函数怎么调用，请继续往下看！
我们先修改main.c文件代码，加上main函数

#include <stdio.h>
#include <stdlib.h>
int main(){

}

然后我们编译是没有报错的，然后我们反编译该代码

yates@yates-HLY-WX9XX:~/software/c$ objdump -d test

test:     file format elf64-x86-64


Disassembly of section .init:

0000000000001000 <_init>:
    1000:	f3 0f 1e fa          	endbr64 
    1004:	48 83 ec 08          	sub    $0x8,%rsp
    1008:	48 8b 05 d9 2f 00 00 	mov    0x2fd9(%rip),%rax        # 3fe8 <__gmon_start__>
    100f:	48 85 c0             	test   %rax,%rax
    1012:	74 02                	je     1016 <_init+0x16>
    1014:	ff d0                	callq  *%rax
    1016:	48 83 c4 08          	add    $0x8,%rsp
    101a:	c3                   	retq   

Disassembly of section .plt:

0000000000001020 <.plt>:
    1020:	ff 35 a2 2f 00 00    	pushq  0x2fa2(%rip)        # 3fc8 <_GLOBAL_OFFSET_TABLE_+0x8>
    1026:	f2 ff 25 a3 2f 00 00 	bnd jmpq *0x2fa3(%rip)        # 3fd0 <_GLOBAL_OFFSET_TABLE_+0x10>
    102d:	0f 1f 00             	nopl   (%rax)

Disassembly of section .plt.got:

0000000000001030 <__cxa_finalize@plt>:
    1030:	f3 0f 1e fa          	endbr64 
    1034:	f2 ff 25 bd 2f 00 00 	bnd jmpq *0x2fbd(%rip)        # 3ff8 <__cxa_finalize@GLIBC_2.2.5>
    103b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

Disassembly of section .text:

0000000000001040 <_start>:
    1040:	f3 0f 1e fa          	endbr64 
    1044:	31 ed                	xor    %ebp,%ebp
    1046:	49 89 d1             	mov    %rdx,%r9
    1049:	5e                   	pop    %rsi
    104a:	48 89 e2             	mov    %rsp,%rdx
    104d:	48 83 e4 f0          	and    $0xfffffffffffffff0,%rsp
    1051:	50                   	push   %rax
    1052:	54                   	push   %rsp
    1053:	4c 8d 05 56 01 00 00 	lea    0x156(%rip),%r8        # 11b0 <__libc_csu_fini>
    105a:	48 8d 0d df 00 00 00 	lea    0xdf(%rip),%rcx        # 1140 <__libc_csu_init>
    1061:	48 8d 3d c1 00 00 00 	lea    0xc1(%rip),%rdi        # 1129 <main>
    1068:	ff 15 72 2f 00 00    	callq  *0x2f72(%rip)        # 3fe0 <__libc_start_main@GLIBC_2.2.5>
    106e:	f4                   	hlt    
    106f:	90                   	nop

0000000000001070 <deregister_tm_clones>:
    1070:	48 8d 3d 99 2f 00 00 	lea    0x2f99(%rip),%rdi        # 4010 <__TMC_END__>
    1077:	48 8d 05 92 2f 00 00 	lea    0x2f92(%rip),%rax        # 4010 <__TMC_END__>
    107e:	48 39 f8             	cmp    %rdi,%rax
    1081:	74 15                	je     1098 <deregister_tm_clones+0x28>
    1083:	48 8b 05 4e 2f 00 00 	mov    0x2f4e(%rip),%rax        # 3fd8 <_ITM_deregisterTMCloneTable>
    108a:	48 85 c0             	test   %rax,%rax
    108d:	74 09                	je     1098 <deregister_tm_clones+0x28>
    108f:	ff e0                	jmpq   *%rax
    1091:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    1098:	c3                   	retq   
    1099:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

00000000000010a0 <register_tm_clones>:
    10a0:	48 8d 3d 69 2f 00 00 	lea    0x2f69(%rip),%rdi        # 4010 <__TMC_END__>
    10a7:	48 8d 35 62 2f 00 00 	lea    0x2f62(%rip),%rsi        # 4010 <__TMC_END__>
    10ae:	48 29 fe             	sub    %rdi,%rsi
    10b1:	48 89 f0             	mov    %rsi,%rax
    10b4:	48 c1 ee 3f          	shr    $0x3f,%rsi
    10b8:	48 c1 f8 03          	sar    $0x3,%rax
    10bc:	48 01 c6             	add    %rax,%rsi
    10bf:	48 d1 fe             	sar    %rsi
    10c2:	74 14                	je     10d8 <register_tm_clones+0x38>
    10c4:	48 8b 05 25 2f 00 00 	mov    0x2f25(%rip),%rax        # 3ff0 <_ITM_registerTMCloneTable>
    10cb:	48 85 c0             	test   %rax,%rax
    10ce:	74 08                	je     10d8 <register_tm_clones+0x38>
    10d0:	ff e0                	jmpq   *%rax
    10d2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
    10d8:	c3                   	retq   
    10d9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

00000000000010e0 <__do_global_dtors_aux>:
    10e0:	f3 0f 1e fa          	endbr64 
    10e4:	80 3d 25 2f 00 00 00 	cmpb   $0x0,0x2f25(%rip)        # 4010 <__TMC_END__>
    10eb:	75 2b                	jne    1118 <__do_global_dtors_aux+0x38>
    10ed:	55                   	push   %rbp
    10ee:	48 83 3d 02 2f 00 00 	cmpq   $0x0,0x2f02(%rip)        # 3ff8 <__cxa_finalize@GLIBC_2.2.5>
    10f5:	00 
    10f6:	48 89 e5             	mov    %rsp,%rbp
    10f9:	74 0c                	je     1107 <__do_global_dtors_aux+0x27>
    10fb:	48 8b 3d 06 2f 00 00 	mov    0x2f06(%rip),%rdi        # 4008 <__dso_handle>
    1102:	e8 29 ff ff ff       	callq  1030 <__cxa_finalize@plt>
    1107:	e8 64 ff ff ff       	callq  1070 <deregister_tm_clones>
    110c:	c6 05 fd 2e 00 00 01 	movb   $0x1,0x2efd(%rip)        # 4010 <__TMC_END__>
    1113:	5d                   	pop    %rbp
    1114:	c3                   	retq   
    1115:	0f 1f 00             	nopl   (%rax)
    1118:	c3                   	retq   
    1119:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

0000000000001120 <frame_dummy>:
    1120:	f3 0f 1e fa          	endbr64 
    1124:	e9 77 ff ff ff       	jmpq   10a0 <register_tm_clones>

0000000000001129 <main>:
    1129:	f3 0f 1e fa          	endbr64 
    112d:	55                   	push   %rbp
    112e:	48 89 e5             	mov    %rsp,%rbp
    1131:	b8 00 00 00 00       	mov    $0x0,%eax
    1136:	5d                   	pop    %rbp
    1137:	c3                   	retq   
    1138:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
    113f:	00 

0000000000001140 <__libc_csu_init>:
    1140:	f3 0f 1e fa          	endbr64 
    1144:	41 57                	push   %r15
    1146:	4c 8d 3d a3 2c 00 00 	lea    0x2ca3(%rip),%r15        # 3df0 <__frame_dummy_init_array_entry>
    114d:	41 56                	push   %r14
    114f:	49 89 d6             	mov    %rdx,%r14
    1152:	41 55                	push   %r13
    1154:	49 89 f5             	mov    %rsi,%r13
    1157:	41 54                	push   %r12
    1159:	41 89 fc             	mov    %edi,%r12d
    115c:	55                   	push   %rbp
    115d:	48 8d 2d 94 2c 00 00 	lea    0x2c94(%rip),%rbp        # 3df8 <__do_global_dtors_aux_fini_array_entry>
    1164:	53                   	push   %rbx
    1165:	4c 29 fd             	sub    %r15,%rbp
    1168:	48 83 ec 08          	sub    $0x8,%rsp
    116c:	e8 8f fe ff ff       	callq  1000 <_init>
    1171:	48 c1 fd 03          	sar    $0x3,%rbp
    1175:	74 1f                	je     1196 <__libc_csu_init+0x56>
    1177:	31 db                	xor    %ebx,%ebx
    1179:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    1180:	4c 89 f2             	mov    %r14,%rdx
    1183:	4c 89 ee             	mov    %r13,%rsi
    1186:	44 89 e7             	mov    %r12d,%edi
    1189:	41 ff 14 df          	callq  *(%r15,%rbx,8)
    118d:	48 83 c3 01          	add    $0x1,%rbx
    1191:	48 39 dd             	cmp    %rbx,%rbp
    1194:	75 ea                	jne    1180 <__libc_csu_init+0x40>
    1196:	48 83 c4 08          	add    $0x8,%rsp
    119a:	5b                   	pop    %rbx
    119b:	5d                   	pop    %rbp
    119c:	41 5c                	pop    %r12
    119e:	41 5d                	pop    %r13
    11a0:	41 5e                	pop    %r14
    11a2:	41 5f                	pop    %r15
    11a4:	c3                   	retq   
    11a5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
    11ac:	00 00 00 00 

00000000000011b0 <__libc_csu_fini>:
    11b0:	f3 0f 1e fa          	endbr64 
    11b4:	c3                   	retq   

Disassembly of section .fini:

00000000000011b8 <_fini>:
    11b8:	f3 0f 1e fa          	endbr64 
    11bc:	48 83 ec 08          	sub    $0x8,%rsp
    11c0:	48 83 c4 08          	add    $0x8,%rsp
    11c4:	c3                   	retq

我们发现这里面调用了__libc_start_main函数，但是该函数并没有在Scrt1.o里面调用，其实我们根据名字可以猜测到，该函数调用在libc库中调用。
首先将一系列参数压栈，然后调用 libc 的库函数 __libc_start_main 做初始化工作，其中最后一个压栈的参数 push $129是 main 函数的地址，__libc_start_main 在完成初始化工作之后会调用 main 函数。由于 __libc_start_main 需要动态链接，所以这个库函数的指令在可执行文件 main 的反汇编中肯定是找不到的，然而我们找到了这个：

0000000000001040 <_start>:
    1040:	f3 0f 1e fa          	endbr64 
    1044:	31 ed                	xor    %ebp,%ebp
    1046:	49 89 d1             	mov    %rdx,%r9
    1049:	5e                   	pop    %rsi
    104a:	48 89 e2             	mov    %rsp,%rdx
    104d:	48 83 e4 f0          	and    $0xfffffffffffffff0,%rsp
    1051:	50                   	push   %rax
    1052:	54                   	push   %rsp
    1053:	4c 8d 05 56 01 00 00 	lea    0x156(%rip),%r8        # 11b0 <__libc_csu_fini>
    105a:	48 8d 0d df 00 00 00 	lea    0xdf(%rip),%rcx        # 1140 <__libc_csu_init>
    1061:	48 8d 3d c1 00 00 00 	lea    0xc1(%rip),%rdi        # 1129 <main>
    1068:	ff 15 72 2f 00 00    	callq  *0x2f72(%rip)        # 3fe0 <__libc_start_main@GLIBC_2.2.5>
    106e:	f4                   	hlt    
    106f:	90                   	nop

从上面可以说明，编译一个.c文件，除了要链接Scrt1.o文件和libc库。

以上是我在Ubuntu 20系统上debug 出来的结果，但是实际每个系统出现现象会有不一样，但是具体原理基本不便，所以小伙伴要多动手，多动脑。

由cve-2019-9766引出的缓冲区漏洞学习
zwish的信安之路
06-25 1753
通过工程实践引出的缓冲区溢出，缓冲区溢出 缓冲区攻击的最终目的就是希望系统能执行这块可读写内存中已经被蓄意设定好的恶意代码。 1、栈的结构 1、先进后出。 2、在内存中表现为从高地址往低地址增长。 3、栈顶：栈的最上方（低地址区）。 4、栈低：栈的最下方（高地址区）。 基本的进程地址空间分布： 2、基本栈溢出： 缓冲区溢出示意图： 如果在数据段（右边的data）就保存了一系列的指令的二进制代码...
从汇编环境到C语言环境、volatile关键字、编译原理、链接脚本
不善挽留
04-04 1566
从汇编环境到C语言环境、初始化DDR、设置SVC模式、初始化SP指针、从汇编跳转到C语言、代码实现、volatile关键字、编译下载验证、编写 Makefile、编译原理、链接脚本、修改 Makefile
十三、MIPS汇编指令-main函数
wanhex的博客
03-07 3176
本次的分享，我们将以一段简单的C语言程序为例，使用mips-linux的gcc编译器对其进行编译后，使用ida对编译后的程序进行反汇编，并通过对照C语言代码的方式理解MIPS汇编指令。 首先我们来看这段C代码（test.c）： #include <stdio.h> #include <string.h> void B() { printf(".....\...
main参数传递、反汇编、汇编混合编程
qq_53198713的博客
12-26 647
参考 http://www.cnblogs.com/rocedu/p/6766748.html#SECCLA在Linux下完成“求命令行传入整数参数的和”注意C中main: int main(int argc, char *argv[]), 字符串“12” 转为12，可以调用atoi()求和函数 int sum(int N)放入sum.c中, main中调用sum()，main放入main.c中测试代码传入自己的8位学号提交代码附件提交运行测试截图创建两个文件一起编译，然后运行。
STM32入门教程——从汇编到 C函数的main
12-13 1186
stm32汇编程序到C程序的结合，为初学者介绍stm32的运行过程。
C语言函数中的中间数,汇编调用到C语言mian函数--中间究竟发生了什么过程
weixin_36482976的博客
05-21 408
最近面试，技术经理问我汇编到main函数步骤是什么，当时我是一脸疑惑，what？main函数就不是C语言调用第一个函数吗？后面我自己查了相关资料，才发现自己too young too navie.很多人只知道main函数是c语言的第一个调用函数，其实不是，下面用个例子说明在开始讲解之前，我先科普一下知识，平时我们编译.c文件是，一般分为三个步骤：第一步生成汇编代码第二部生成目标文件第三步生成可执行...
keil：C语言里面调用汇编程序
weixin_30919235的博客
04-05 1378
C语言直观，汇编效率高，C里面嵌入汇编是很好的选择。 路径大概如图： mian.c是我的C语言程序，Func.s是汇编程序。 主要是Init_1这个函数的实现在汇编文件里面，使用汇编实现的。 首先在C里面用 extern 声明 Init_1这个函数，再在main里面调用好了。 然后在汇编里面用EXPORT Init_1与C联系起来就可以了。 转载于:https://w...
C语言执行 main() 函数前，程序都做了什么
最新发布
qq_44431362的博客
06-14 1504
在 C 语言程序中，main()函数是用户代码的逻辑起点，但在它被执行之前，程序需要经历等多个关键阶段。这些阶段由编译器、链接器、操作系统共同协作完成，确保程序具备运行所需的环境和资源。
89c52流水灯汇编语言,89c52单片机流水灯汇编程序
weixin_36418584的博客
05-23 4472
8路流水灯汇编语言程序的写法汇编语言程序如下： ;假设1：D1~D8八个彩灯接在P1口，输出低电平发光 ;假设2：系统晶振为12MHz ;假设3：N = 5 ;程序如下： ORG 0000H MOV R3, #5 ;N=5 LOOP0: MOV A, #0FFH MOV P1, #0FFH ;开始时全灭 ;-逐个点亮51单片机中如何用汇编语言编写流水灯流水灯就是51单片机控制led灯依次点亮的控制...
C/C++逆向：寻找mian函数（其他编译配置特征）
WolvenSec的博客
09-01 2017
在上篇文章中写了在逆向中定位main函数几种方法，其中有一种方法是通过编译器特征定位main函数（使用IDA分析简单demo程序获取特征，根据得到的特征可以定位相同编译器编译程序的main函数）。在上一篇文章中我们提取了VS环境(VS2017)中MSVC编译器编译配置与目标平台架构分别为Debug和x86生成的程序特征，从而正确定位到了main函数所在位置。本篇文章主要写一下根据编译器特征定位main函数的方法，提取VS环境（VS2017）生成的编译配置与目标平台架构分别为Debugx64Release。
了解mian函数
u011337769的博客
07-25 790
题目： #include "stdio.h" void print() { //请在此函数中写入相关代码 } void main() { //不能写入任何代码 }    要求在print函数中写代码使整个程序运行后输出“hello world” 注意mian中不能写入任何代码，包括调用print函数。 参考代码： #include "stdio.h" extern
x86的c语言和arm64的c语言,X86-64和ARM64用户栈的结构 (5) --- mian()函数和子函数之间的栈...
weixin_39727005的博客
05-23 473
main函数及其子函数之间的栈1 工具及实验程序本文的实验在一个虚拟机中进行，虚拟机模拟的cpu是x86-64(Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz)，运行的是64bit ubuntu，安装了ARM64的工具链：$sudo apt-get install gcc-aarch64-linux-gnu$sudo apt-get install gcc-ar...
c语言代码大全表解释_「正点原子Linux连载」第十章C语言版LED灯实验
weixin_39950081的博客
11-20 1587
1)实验平台：正点原子Linux开发板2)摘自《正点原子I.MX6U嵌入式Linux驱动开发指南》关注官方微信号公众号，获取更多资料：正点原子第十章C语言版LED灯实验第八章我们讲解了如何用汇编语言编写LED灯实验，但是实际开发过程中汇编用的很少，大部分都是C语言开发，汇编只是用来完成C语言环境的初始化。本章我们就来学习如何用汇编来完成C语言环境的初始化工作，然后从汇编跳转到C语言代码里面去。10...
C语言为什么必须有main函数
coreyGC的专栏
06-18 1577
[html] view plaincopy #include stdio.h>    int main()  {              printf("Hello World!";              return 0;  }   -------------------------------------------------helloworld.c--------
在Linux环境下运行你的第一个C语言程序
让技术没有门槛
06-28 1835
今天是入职的第一天，在公司从事SOC的开发，需要用到Linux的知识，所以开始和大家一起学习Linux的编程，使用Linux运行我们的第一个C语言程序。
mcu的main函数是如何被调用
MHD0815的博客
03-05 588
在上述示例中，`ldr r0, =main`指令用于将main函数的地址加载到寄存器r0中，然后`blx r0`指令用于通过寄存器r0跳转到main函数的地址。这样，启动代码就能够正确地跳转到main函数的地址，从而启动用户编写的C代码。1. **复位向量（Reset Vector）**：当MCU上电或复位时，程序计数器（PC）会跳转到复位向量的地址，这是一个预定义的地址，通常是0x0000_0000。3. **调用main函数**：在进行完必要的初始化后，启动代码会调用C语言的main函数。
图解函数栈帧的创建和销毁全过程
qq_52989768的博客
11-25 776
这篇博客主要是对局部变量以及函数的一些问题的解答 局部变量是如何创建的？ 局部变量在没有初始化时是随机值，背后原理是什么？ 为什么说形参是实参的临时拷贝？ 函数是如何调用函数的？ 局部变量出函数就会销毁，那么函数返回的值是如何传递到main函数中的？ 上述问题在函数的栈帧创建到销毁的过程中可以找到答案 注：不同的编译器此过程会有差异 以下列代码为例： int Add(int x,int y) { int z=x+y; return z; } int main() {
C语言学习专栏（1）：易忘点
qq_44159782的博客
01-30 1526
C语言学习专栏系列： 【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）； 本博客的内容来自于：深入浅出python系列（一）：基本数据类型； 学习、合作与交流联系q384660495； 本博客的内容仅供学习与参考，并非营利； include< > 与 #include ""的区别: < > 表示系统直接按系统指定的目录检索； “” 表示系统先在 “” 指定的路径(没写路径代表当前路径)查找头文件，如 果找不到，再按系统指定的目录检索； main函数 一个
函数调用过程
Tian_Luo_Girl的博客
12-30 496
每一个未运行完的函数都对应着一个栈帧，系统为单个函数分配的那部分栈空间就叫做栈帧，栈帧保存了函数的信息。 以下面的代码为例，通过汇编代码的运行过程介绍栈帧创建和销毁的过程#include <stdio.h> int Add(int x, int y) { int z = 0; z = x + y; return z; } int main() { int a = 10;
gcc 编译C语言最全命令
热门推荐
lanshi00的博客
03-05 1万+
gcc 编译命令 最简单的编译命令是:gcc main.c 默认生成的可执行文件是 a.out,如果需要指定输出文件,则需要使用如下的命令:gcc main.c – o main 使用-Wall 选项可以输出所有的警告信息: gcc -Wall main.c -o main 输出 C 源码的预处理结果需要使用-E 选项,默认是输出控制台,可以将其 重定向到文件保存: gcc -E main.c ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值