Program Entry Point

**Sentral** · 07-26-2006

Whenever a program is compiled successfully and run, is the entry point (starting point) always going to start at sometype of 'main' function? Like in a console app, the starting point is always int main(), correct? And in Windows it's always Winmain()? What I'm saying is, when you run a program it will always look in the main function, then go on from there, is this correct in saying that?

**Prelude** · 07-26-2006

From the perspective of C++, yes.

**twomers** · 07-26-2006

I believe so, wrt C++. Write a program without any main() and see what errors it says.

**Salem** · 07-26-2006

Well from the perspective of hosted systems, yes.
Free-standing implementations are a whole new ball game.

**siavoshkc** · 07-27-2006

There are some internal C code (CRT) that executes before your code. There is a function in that internal codes that call your main() or winmain() or any oher entery point.

**Mario F.** · 07-27-2006

That may be true of microsoft compiler. But not of any other compilers.

**twomers** · 07-27-2006

Weird. I didn't know that was purely MS.

Hey Mario, I found some code that messes up that color coder program.

**Mario F.** · 07-27-2006

The C Runtime Libraries are not an imposition. Compilers may or may not choose to implement/use them.

Anyways, fix it then! :G
(I completely forgot to keep checking on that)

EDIT: were on earth are the smileys?

**grumpy** · 07-27-2006

Constructors of static objects at file scope will be invoked before main() is called.

Code:

#include <iostream>

class X
{
    public:
       X() {std::cout << "1\n";};
       void something() {};
}

X x;

int main()
{
     std::cout << "2\n";
     x.something();
}

will print 1 then 2, rather than the reverse.

**siavoshkc** · 07-27-2006

>>That may be true of microsoft compiler. But not of any other compilers.
C/C++ compiler and linker manage the program in a way that it calls a function in one default lib or dll. Then that function calls your main().

**twomers** · 07-27-2006

>> Anyways, fix it then! :G

I didn't write it!

>> Constructors of static objects at file scope will be invoked before main() is called.

Interesting. I didn't know that!

**CornedBee** · 07-27-2006

Originally Posted by siavoshkc

C/C++ compiler and linker manage the program in a way that it calls a function in one default lib or dll. Then that function calls your main().

Compilers for hosted implementations can manage the program however they damn well please, as long as the effect remains the same. They could, for example, take your definition of the main function and rewrite that to include some startup code and generate the argc and argv "arguments" somehow. In standard C++, main() is not callable, nor can you take its address. That permits the compiler such games.

I don't know any compiler that does this. It's just a possibility. For what it's worth, the MS compilers pull in the code from crt0.c and call that function for startup, which in turn calls main(), wmain(), WinMain() or wWinMain(), depending on the settings.

I think the equivalent in GCC is in crtbegin.o, but it might also be ld-linux-x86-64.so.2 (my system only - this is architecture-specific stuff), crt1.o, crti.o, libgcc.a, libgcc_s.a, crtend.o or crtn.o - those are all the additional files GCC automatically links.

Details for older kernels:
http://asm.sourceforge.net/articles/startup.html

**siavoshkc** · 07-28-2006

So as I understood, in standard the entery point of program is main() with no alternatives. But for making the things more simple compiler implementors decided to change it and make another entery point to do the system initializations and then call the main(). Correct?

**siavoshkc** · 07-28-2006

So as I understood, in standard the entery point of program is main() with no alternatives. But for making the things more simple compiler implementors decided to change it and make another entery point to do the system initializations and then call the main(). Correct?

**CornedBee** · 07-28-2006

Not quite. The C and C++ standards say that the program, as written by the user, must start execution at the main() function.
They do not say that the physical, completed program must execute this as the first instruction. In fact, that would be quite unrealistic. Take the Linux model for example. There, you create a new process by calling fork(). However, fork() doesn't load a new application. It only duplicates the current process, and then in both processes returns from fork() - in the parent process, it returns the new process id, in the child process it returns 0. This is for the client to distinguish the two. But they still share the same code, the same file handles, and all variables are, for the moment, in the same state. (Hoever, they are copy-on-write, so modifying them in one process doesn't affect the other.)
It's not until one process calls exec*() that something new happens. This call goes into the kernel and eventually replaces the whole program code by something different. This means that the kernel first cleans out the old state, sets up a new state, then loads the program code. Executable formats in Linux are flexible, but the ELF format is the most common. It contains (just like PE does) in its header a starting address. The kernel, after loading the code and setting up the application state, just jumps to that address.
It is up to the compiler what it places at that address. And as it's totally invisible to the user of C or C++, the language standards having nothing to say about it either. (With one exception: the C++ standard requires the initialization of global objects, so it effectively requires that the compiler does something before giving main() a chance.)

Thread: Program Entry Point

Thread Tools

Search Thread

Display

Program Entry Point

Similar Threads

HELP with Program!

For the numerical recipes in C types!

Class warfare

Naming rules for classes conatining program entry points

Results for the Encryption Contest -- June 23, 2002