Calling some functions before main in C

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. It was no problem in C++, but problematic with C.

In C++, this can be done by two ways:

1. Exploiting a constructor of a global class/struct.
2. Calling a function to a global variable

For example, static const int __register_dummy_ = __AddRegisterMetaInfo(...);

However, in C, either ways is impossible. Obviously, there is no constructor. So, the first option is inherently impossible.

I thought that the second option would be possible, but not compiled in C (I tested only wit开发者_运维百科h Visual C++. It gives C2099.). C only allows a constant to a non-automatic variable.

Is there any way to call some functions before main?

EDIT: It seems that many people just got misunderstand what I really wanted to do. Sorry for writing this question in a simplified way.

What I needed to do is implementing a sort of C++ runtime class information feature, just like MFC's approach. In this approach, I need to get some information from all source code. For example, say each source file has a definition of a class, and I'd like to see all information (e.g., class names and the parent class). The easiest way is placing a static constructor in each file, and each constructor accesses a global data structure and register its information. But, I also wanted to find a way to implement a similar thing in C. So, simply calling a pre_main_job in main can't be an answer to me.

Note that this abuse of static constructor also can be found in LLVM compiler suite. Each optimization/analysis feature is implemented as a pass. All these passes are registered via a static constructor.

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)

(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".