I\'d like to do some stuffs before main
function. I have multiple source files. In each file, there is some work that needs to be done before main
.
(I know, this isn't a direct answer to the original question; it is, however, an answer for someone who's looking for a way to execute code before the contents of main
)
I've heard of a better idea - one, that's even portable and predictable in behavior. Do the stuff you want to do "before main
" in the beginning of the main
function (or call a function which does what you want in the beginning of main
).
If you control the code, there's (really!) no need for fragile and often unmaintainable hacks like the ones you have proposed (or introduced).
Assuming you are not mixing C++ in with your C... (because then you could do the static constructors on your c++ class, which is maybe what you're asking!)
Crt0
is the platform-specific runtime setup traditionally called before main(). You could override that, but that's pretty deep.
Some embedded platforms provide a _pre_main()
and _post_main()
kind of procs. But that's nonstandard I think.
Really, your main entry point is, well, main()
!
If you're in control of the Makefile, you could force main to be something else, with something like
gcc app.c -Dmain=not_really_main
And then link in your real main()
to call not_really_main()
.
edit: one more approach: The gcc linker has a variable called ENTRY which is the first thing executed, usually crt0. Again, this is pretty heavyweight, and you'll have understand the platform pretty deeply to pull it off, but it's another place you can "subvert main".
For a number of compiler specific solutions you can take a look at the fips_premain.c file from the OpenSSL distribution (you can view it online in a bunch of places, here for instance).
The MSVC specific part looks something like (FINGERPRINT_premain
being the function to be executed before main
):
# ifdef _WINDLL
__declspec(dllexport) /* this is essentially cosmetics... */
# endif
void FINGERPRINT_premain(void);
static int premain_wrapper(void) { FINGERPRINT_premain(); return 0; }
# ifdef _WIN64
# pragma section(".CRT$XCU",read)
__declspec(allocate(".CRT$XCU"))
# else
# pragma data_seg(".CRT$XCU")
# endif
static int (*p)(void) = premain_wrapper;
/* This results in pointer to premain to appear in .CRT segment,
* which is traversed by Visual C run-time initialization code.
* This applies to both Win32 and [all flavors of] Win64. */
# pragma data_seg()
You might be able to use compiler specific extensions to achieve this, eg. gcc allows you to use the constructor function attribute (and the matching destructor
attribute) to cause code to be run before main
and after main
(or exit
)