一个c程序在执行main函数之前和main之后都做了那些事情啊？

[小魔菇]

很想知道
一个c程序在执行main函数之前和main之后都做了那些事情？
请高手指点指点哈~

[小魔菇]

[Quote=引用 7 楼 Black_Tortoise 的回复:]
main真正执行之前都要和操作系统进行沟通，获取main执行所需要的内存空间。

main返回之后要么回到调用它的函数里面，要么就再次与操作系统沟通，来释放程序运行所占用的资源，并结束程序。
[/Quote]
能说的详细点吗？

[ttlyfast]

曾经试图 把数据段偏移保存在全局变量里...失败了 :-(

frv体系 uclinux

crt0.s

/*  Based on ../i386/crt0.S and newlib's libgloss/frv/crt0.S  */

/*
    When we enter this piece of code, the program stack looks like this:
        argc            argument counter (integer)
        argv[0]         program name (pointer)
        argv[1...N]     program args (pointers)
        argv[argc-1]    end of args (integer)
	NULL
        env[0...N]      environment variables (pointers)
        NULL

    Also, GR16 holds a pointer to a memory map.  */

#include <features.h>

	.text
	.global _start
	.type	_start,%function
#if defined L_crt0 || defined L_Scrt0 || ! defined __UCLIBC_CTOR_DTOR__
	.type __uClibc_main,%function
#else
	.weak	_init
	.weak	_fini
	.type	__uClibc_start_main,%function
#endif
_start:
	/* Make sure the stack pointer is properly aligned.  Save the
	   original value in gr21 such that we can get to arguments and
	   such from there.  */
	mov.p	sp, gr21
	andi	sp, #-8, sp
	/* At program start-up, gr16 contains a pointer to a memory
	   map, that we use to relocate addresses.  */
	call	.Lcall
.Lcall:
	movsg	lr, gr4
	sethi.p	#gprelhi(.Lcall), gr5
	setlo	#gprello(.Lcall), gr5
	sub.p	gr4, gr5, gr4
	/* gr4 now holds the _gp address.  */
	
	mov	gr16, gr8
	sethi.p #gprelhi(__ROFIXUP_LIST__), gr9
	sethi	#gprelhi(__ROFIXUP_END__), gr10
	setlo.p #gprello(__ROFIXUP_LIST__), gr9
	setlo	#gprello(__ROFIXUP_END__), gr10
	add.p	gr9, gr4, gr9
	add	gr10, gr4, gr10
	call	__self_reloc
	mov.p	gr8, gr17
	mov	gr8, gr15

/*add-----------------------*/

	sethi.p #gprelhi(__g_mem_map1), gr8
	setlo #gprello(__g_mem_map1), gr8
/*	
	sethi.p 0x0,gr9
	setlo 0x0,gr9
*/
	st	gr16, @(gr15, gr8)
/* ------------------------------------ */	

	/* gr17 now holds the self-relocated _GLOBAL_OFFSET_TABLE_
	address, because the linker added its unrelocated address as
	the last entry in the ROFIXUP list, and __self_reloc returns
	the last entry, relocated.  */

	/* Prepare arguments for uClibc main.  */
	ld	@(gr21, gr0), gr8
	slli	gr8, #2, gr10
	add	gr21, gr10, gr10
	addi.p	gr21, #4, gr9
	addi	gr10, #8, gr10

	/* Set up an invalid (NULL return address, NULL frame pointer)
	   callers stack frame so anybody unrolling the stack knows where
	   to stop */
	mov	gr0, fp
	movgs	gr0, lr

#if (defined L_crt1 || defined L_gcrt1 || defined L_Scrt1) && defined __UCLIBC_CTOR_DTOR__
	/* Pass .init and .fini arguments to __uClibc_start_main().  */
	sethi.p	#gotfuncdeschi(_init), gr11
	sethi	#gotfuncdeschi(_fini), gr12
	setlo.p	#gotfuncdesclo(_init), gr11
	setlo	#gotfuncdesclo(_fini), gr12
	ld.p	@(gr11, gr17), gr11
	mov	gr17, gr15
	ld.p	@(gr12, gr17), gr12
	call	__uClibc_start_main
#else
	mov.p	gr17, gr15
	call	__uClibc_main
#endif	

	/* Crash if somehow `exit' returns anyways.  */
	jmpl	@(gr0,gr0)
.size _start,.-_start


#if 1

/* defined by sheng yu*/

.data
	.globl __data_start
__data_start:
	.global __g_mem_map1
//	.hidden __g_mem_map1
__g_mem_map1:
.long 8
	.weak __g_mem_map = __data_start
#endif

#if 0

.data
.globl __g_mem_map
__g_mem_map:
.long 0
.globl __g_sr_got
__g_sr_got:
.long 0
#endif

#if defined L_gcrt1 && defined __UCLIBC_PROFILING__
# include "./gmon-start.S"
#endif

[小魔菇]

[Quote=引用 13 楼 ttlyfast 的回复:]
曾经试图 把数据段偏移保存在全局变量里...失败了 :-(

frv体系 uclinux

crt0.s
Assembly code/* Based on ../i386/crt0.Sandnewlib's libgloss/frv/crt0.S */

/*
When we enter this piece of code, the program stack looks like this:
argc argument counter (integer)
argv[0] program name (pointer)
argv[1...N] program args (pointers)
argv[argc-…
[/Quote]
回复越来越强悍了
都把大牛一个个都引出来了 呵呵

[ttlyfast]

我是个小菜鸟 非常非常的菜 基本上不会编程

[小魔菇]

[Quote=引用 15 楼 ttlyfast 的回复:]
我是个小菜鸟 非常非常的菜 基本上不会编程
[/Quote]
以前在电视上看到 只有象那种顶级高手才说这样的话
呵呵
欲盖弥彰

[pflifeshow]

真得学习了。。。。。。

[nishuangfeng]

学习中

[xiaoyong_w]

之前就是跳到main的地址

[wuyu637]

main函数之前--真正的函数执行入口或开始

一种解释

实际上，在可执行文件被加载之后，控制权立即交给由编译器插入的Start函数，它将对后面这些全局变量进行准备：
　　　_osver 操作系统的构件编号
_winmajor　操作系统的主版本号
_winminor　操作系统的次版本号
_winver　操作系统完全版本号
__argc　命令行参数个数
　 __argv　指向参数字符串的指针数组
_environ　指向环境变量字符串的指针数组
Start函数初始化堆并调用main函数．mian函数返回之后,Start函数调用Exit函数结束该进程．
启动函数Start的源代码在：
　　　crt0.c Microsoft Visual C++
c0w.asm Borladn C++

另一种解释

Some of the stuff that has to happen before main():
set up initial stack pointer
initialize static and global data
zero out uninitialized data
run global constructors

Some of this comes with the runtime library's crt0.o file or its __start() function. Some of it you need to do yourself.
Crt0 is a synonym for the C runtime library.
Depending on the system you're using the follwing may be incomplete, but it should give you an idea. Using newlib-1.9.0/libgloss/m68k/crt0.S as an outline, the steps are:
1. Set stack pointer to value of __STACK if set
2. Set the initial value of the frame pointer
3. Clear .bss (where all the values that start at zero go)
4. Call indirect of hardware_init_hook if set to initialize hardware
5. Call indirect of software_init_hook if set to initialize software
6. Add __do_global_dtors and __FINI_SECTION__ to the atexit function so destructors and other cleanup functions are called when the program exits by either returning from main, or calling exit
7. setup the paramters for argc, argv, argp and call main
8. call exit if main returns

第三种解释：囫囵C语言（三）：谁调用了我的 main？
　　　　
　　　　现在最重要的是要跟得上潮流，所以套用比较时髦的话，谁动了我的奶酪。谁调用了我的 main？不过作为计算机工作者，我劝大家还是不要赶时髦，今天Java热，明天 .net 流行，什么时髦就学什么。我的意思是先花几年把基本功学好，等你赶时髦的时候也好事半功倍。废话不多说了。
　　　　
　　　　我们都听说过一句话：“main是C语言的入口”。我至今不明白为什么这么说。就好像如果有人说：“挣钱是泡妞”，肯定无数砖头拍过来。这句话应该是“挣钱是泡妞的一个条件，只不过这个条件特别重要”。那么上面那句话应该是 “main是C语言中一个符号，只不过这个符号比较特别。”
　　　　
　　　　我们看下面的例子：
　　　　
　　　　/* file name test00.c */
　　　　
　　　　int main(int argc, char* argv)
　　　　{
　　　　 return 0;
　　　　}
　　　　
　　　　编译链接它：
　　　　cc test00.c -o test.exe
　　　　会生成 test.exe
　　　　
　　　　但是我们加上这个选项： -nostdlib (不链接标准库)
　　　　cc test00.c -nostdlib -o test.exe
　　　　链接器会报错：
　　　　undefined symbol: __start
　　　　
　　　　也就是说：
　　　　1. 编译器缺省是找 __start 符号，而不是 main
　　　　2. __start 这个符号是程序的起始点
　　　　3. main 是被标准库调用的一个符号
　　　　
　　　　再来思考一个问题：
　　　　我们写程序，比如一个模块，通常要有 initialize 和 de-initialize，但是我们写 C 程序的时候为什么有些模块没有这两个过程么呢？比如我们程序从 main 开始就可以 malloc，free，但是我们在 main 里面却没有初始化堆。再比如在 main 里面可以直接 printf，可是我们并没有打开标准输出文件啊。(不知道什么是 stdin，stdout，stderr 以及 printf 和 stdout 关系的群众请先看看 C 语言中文件的概念)。
　　　　
　　　　有人说，这些东西不需要初始化。如果您真得这么想，请您不要再往下看了，我个人认为计算机软件不适合您。
　　　　
　　　　聪明的人民群众会想，一定是在 main 之前干了些什么。使这些函数可以直接调用而不用初始化。通常，我们会在编译器的环境中找到一个名字类似于 crt0.o 的文件，这个文件中包含了我们刚才所说的 __start 符号。（crt 大概是 C Runtime 的缩写，请大家帮助确认一下。）
　　　　
　　　　那么真正的 crt0.s 是什么样子呢？下面我们给出部分伪代码：
　　　　
　　　　///////////////////////////////////////////////////////
　　　　section .text:
　　　　__start:
　　　　
　　　　 :
　　　　 init stack;
　　　　 init heap;
　　　　 open stdin;
　　　　 open stdout;
　　　　 open stderr;
　　　　 :
　　　　 push argv;
　　　　 push argc;
　　　　 call _main; (调用 main)
　　　　 :
　　　　 destory heap;
　　　　 close stdin;
　　　　 close stdout;
　　　　 close stderr;
　　　　 :
　　　　 call __exit;
　　　　////////////////////////////////////////////////////
　　　　
　　　　实际上可能还有很多初始化工作，因为都是和操作系统相关的，笔者就不一一列出了。
　　　　
　　　　注意：
　　　　1. 不同的编译器，不一定缺省得符号都是 __start。
　　　　2. 汇编里面的 _main 就是 C 语言里面的 main，是因为汇编器和C编译器对符号的命名有差异（通常是差一个下划线'_'）。
　　　　3. 目前操作系统结构有两个主要的分支：微内核和宏内核。微内核的优点是，结构清晰，简单，内核组件较少，便于维护；缺点是，进程间通信较多，程序频繁进出内核，效率较低。宏内核正好相反。我说这个是什么目的是：没办法保证每个组件都在用户空间（标准库函数）中初始化，有些组件确实可能不要初始化，操作系统在创建进程的时候在内核空间做的。这依赖于操作系统的具体实现，比如堆，宏内核结构可能在内核初始化，微内核结构在用户空间；即使同样是微内核，这个东东也可能会被拿到内核空间初始化。
　　　　
　　　　随着 CPU 技术的发展，存储量的迅速扩展，代码复杂程度的增加，微内核被越来越多的采用。你会为了 10% 的效率使代码复杂度增加么？要知道每隔 18 个月 CPU 的速度就会翻一番。所以我对程序员的要求是，我首先不要你的代码效率高，我首先要你的代码能让 80% 的人迅速看懂并可以维护。

总结：

main函数执行之前，主要就是初始化系统相关资源：

1.设置栈指针

2.初始化static静态和global全局变量，即data段的内容

3.将未初始化部分的赋初值：数值型short，int，long等为0，bool为FALSE，指针为NULL，等等，即.bss段的内容

4.运行全局构造器，估计是C++中构造函数之类的吧

5.将main函数的参数，argc，argv等传递给main函数，然后才真正运行main函数

[OenAuth.Core]

main之前：预编译　全局变量的初始化等
main之后：全局变量的释放

[Rex.Y]

agree with you

[小魔菇]

[Quote=引用 1 楼 wuyu637 的回复:]
main函数之前--真正的函数执行入口或开始

一种解释

实际上，在可执行文件被加载之后，控制权立即交给由编译器插入的Start函数，它将对后面这些全局变量进行准备：
_osver 操作系统的构件编号
_winmajor　操作系统的主版本号
_winminor　操作系统的次版本号
_winver　操作系统完全版本号
__argc　命令行参数个数
__argv　指向参数字符串的指针数组
_environ　指向环境变量字符串的指针数组
Start函数初始化堆并调用…
[/Quote]
好强大
我得消化一下

[猫已经找不回了]

一般就是预编译跟全局的变量处理吧.
其他的不知道..顶1楼

[xuguod20042576]

main之前一般是预编译，全局变量的内存分配

[deviosyan]

学到了, 挖坟也有知识

[Larry_lau]

学习了、、、很详细、

[Leson_Yin]

！！！

[misibi]

[Quote=引用 16 楼 eclipse_2 的回复:]
引用 15 楼 ttlyfast 的回复:
我是个小菜鸟 非常非常的菜 基本上不会编程

以前在电视上看到 只有象那种顶级高手才说这样的话
呵呵
欲盖弥彰
[/Quote]

e

[Dracula777]

我也支持一下，学习了~

[qlrlili]

很有收获！向大牛哥学习！