Introduction

In C programming, there are two ways to terminate a program from the main function: using return and using exit().

int main() {

    printf("Hello, World!");

    return 0;    // Method 1: Normal termination

}



int main() {

    printf("Hello, World!");

    exit(0);     // Method 2：Normal termination

}

Why can both methods terminate the program correctly, even though they appear completely different?

In this article, we'll unravel this mystery by understanding how C programs actually start and terminate.

Note that this article focuses on the implementation in GNU/Linux environments, specifically using glibc.

How exit() Works

First, let's examine how the exit function works to understand the program termination mechanism.

The exit function is a standard library function that properly terminates a program.

Internally, the _exit function, which is called by exit, is implemented in glibc as follows:

void

_exit (int status)

{

  while (1)

    {

      INLINE_SYSCALL (exit_group, 1, status);



#ifdef ABORT_INSTRUCTION

      ABORT_INSTRUCTION;

#endif

    }

}

Looking at this implementation, we can see that the _exit function receives an exit status as its argument and calls exit_group (system call number 231).

This system call performs the following operations:

1. Sends a program termination notification to the kernel


2. The kernel performs cleanup operations:
   
   
   
   
   • Releases resources used by the process
   
   
   • Updates the process table
   
   
   • Performs additional cleanup procedures
   
   
   
   

Through these operations, the program terminates properly.

So, why does returning from main() also properly terminate the program?

C Program's Hidden Entry Point

To understand this, we need to know an important fact: C programs don't actually start from main.

Let's check the default settings of the linker (ld) to see the actual entry point:

$ ld --verbose | grep "ENTRY"

ENTRY(_start)

As this output shows, the actual entry point of a C program is the _start function. main is called after _start.

The _start function is implemented in the standard library, and in glibc, it looks like this:

_start:

    # Initialize stack pointer

    xorl %ebp, %ebp

    popq %rsi        # Get argc

    movq %rsp, %rdx  # Get argv



    # Setup arguments for main

    pushq %rsi       # Push argc

    pushq %rdx       # Push argv



    # Call __libc_start_main

    call __libc_start_main

The _start function has two main roles:

1. Initializes the stack frame required for program execution


2. Sets up command-line arguments (argc, argv) for the main function

After these initializations are complete, __libc_start_main is called.

This function is responsible for calling the main function.

Now, let's examine how __libc_start_main works in detail.

How __libc_start_main Makes return Work

__libc_start_call_main, which is called by __libc_start_main, is implemented as follows:

_Noreturn static void

__libc_start_call_main (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),

                        int argc, char **argv

#ifdef LIBC_START_MAIN_AUXVEC_ARG

                            , ElfW(auxv_t) *auxvec

#endif

                        )

{

  int result;



  /* Memory for the cancellation buffer.  */

  struct pthread_unwind_buf unwind_buf;



  int not_first_call;

  DIAG_PUSH_NEEDS_COMMENT;

#if __GNUC_PREREQ (7, 0)

  /* This call results in a -Wstringop-overflow warning because struct

     pthread_unwind_buf is smaller than jmp_buf.  setjmp and longjmp

     do not use anything beyond the common prefix (they never access

     the saved signal mask), so that is a false positive.  */

  DIAG_IGNORE_NEEDS_COMMENT (11, "-Wstringop-overflow=");

#endif

  not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);

  DIAG_POP_NEEDS_COMMENT;

  if (__glibc_likely (! not_first_call))

    {

      struct pthread *self = THREAD_SELF;



      /* Store old info.  */

      unwind_buf.priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf);

      unwind_buf.priv.data.cleanup = THREAD_GETMEM (self, cleanup);



      /* Store the new cleanup handler info.  */

      THREAD_SETMEM (self, cleanup_jmp_buf, &unwind_buf);



      /* Run the program.  */

      result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);

    }

  else

    {

      /* Remove the thread-local data.  */

      __nptl_deallocate_tsd ();



      /* One less thread.  Decrement the counter.  If it is zero we

         terminate the entire process.  */

      result = 0;

      if (atomic_fetch_add_relaxed (&__nptl_nthreads, -1) != 1)

        /* Not much left to do but to exit the thread, not the process.  */

    while (1)

      INTERNAL_SYSCALL_CALL (exit, 0);

    }



  exit (result);

}

In this implementation, the key parts to focus on are as follows:

result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);

exit(result);

Here, the important point is how the main function is executed and its return value is handled:

1. Executes the main function and stores its return value in result


2. Uses the return value from main as an argument for exit

Through this mechanism:

• When using return in main → The return value is passed to __libc_start_main, which then passes it to exit


• When exit() is called directly in main → The program terminates immediately

In either case, exit is ultimately called, ensuring proper program termination.

Conclusion

C programs have the following mechanism in place:

1. The program starts from _start


2. _start prepares for main's execution


3. main is executed through __libc_start_main


4. Receives main's return value and uses it as an argument for exit

Through this mechanism:

• Even when using return in main, the return value is automatically passed to exit


• As a result, both return and exit() terminate the program properly

Note that this mechanism is not limited to GNU/Linux; similar implementations exist in other operating systems (like Windows and macOS) and different C standard libraries.