N1256 5.1.2.2.3 p1: If the return type of the main function is a type compatible with int, a return from the initial call to the main function is equivalent to calling the exit function with the value returned by the main function as its argument; reaching the } that terminates the main function returns a value of 0. If the return type is not compatible with int, the termination status returned to the host environment is unspecified.

main() is __cdecl__ or __stdcall__ on the major platforms.

That calling convention on x86 specifies that the return value is red from the EAX register. So, when your main() function exits, the return value is red from EAX, it's that simple.

The compilers may add boilerplate code around the main, in fact main() is rarely the real main() function, but that doesn't change the spec.

Did you read the comment you just replied to?!

The two comments are not incompatible, they are just very different worldviews. One tells you what the standard says (that the termination status is unspecified if main does not return an int), the other tells you what usually happens (you get what happened to be in AX).

And as I've just tested, gcc doesn't return zero termination status if you reach the } at the end of main.

Calling conventions are as much a standard as the C spec.

The main() is called like a regular function, by the system thing that executes programs.

Depending on the compiler and the flags, the main() is not the real entry point of the program. It can add another entry point to do some magic, like setting the return code.

Depends if it's in C99 mode. GCC defaults to “GNU89” I think.

Normally, yes. But main() is special and implicitly returns 0, for whatever reason.

Absolutely not. You can look at a crashing programs and see the return code is a random value. You can also make a program that doesn't return anything and see that it's also a random value, though some compilers on some platforms might initialize that to zero.

No, it's literally special-cased in the C standard.

Someone should tell the gcc maintainers then.

    int main()
    {
        int a = 12;
    }

    $ gcc maintest.c
    $ ./a.out
    $ echo $?
    148

  $ cat test.c
  int main(void) {int a = 12;}
  $ gcc-6 test.c -o test --std=c89; ./test; echo $?
  162
  $ gcc-6 test.c -o test --std=c99; ./test; echo $?
  0

Must be a C99 thing.

This isn't that conclusive of a test -- uninitialized memory is 0 relatively often.

Okay, that is conclusive. (And I'm pleasantly surprised by how readable GCC's source code is.)

This has nothing to do with memory. The x86_64 ABI returns values from functions in the RAX register.

Sure; same point applies though -- just because 0 happens to be in RAX doesn't mean it's defined behavior.

Just tested on the MSVC compiler I have at hands. The standard is not respected.

MSVC doesn't claim to implement C99, where this rule was added, so it kind of makes sense that it doesn't happen. (generally, if they added C99-stuff then only where it was required for C++)

    int main(void)
    {
        __asm {
          mov eax, 123
        }
    }

    // visual studio command line
    // cl testc.c
    // cl testcpp.cpp
    // testc.exe
    // echo C %errorlevel%
    // testcpp.exe
    // echo CPP %errorlevel%

Indeed. It's a C99 thing.

For those not familiar with MSVC. The C compiler is not C99 compliant and the C++ compiler is.

I love C but this whole thread highlights a lot of the criticism of it. Everyone's right based on some standard or switch, and everyone's wrong for the same reason.

This is not specific to C, but common to all evolving standards. If you want portable code just drive on the middle of the road.

Often this is as easy as coding to an older standard, like C89 with a few selected features from later standards, and adding some compatibility features / problem detection in the build system.

And don't rely on features that are difficult to explain and/or add only questionable value. Just return 0 from main, it's the obvious simple thing to do.