How to make other function as entry point other than main() in C

If you're compiling with gcc, specifying -e <symbol> option will let you change the entry point to a function symbol().

There is a solution for build executable shared library that you can build a program use another function as entry point.

The code looks like:

#include <stdio.h>
#include <stdlib.h>
const char __invoke_dynamic_linker[] __attribute__ ((section (".interp"))) 
    = "/lib/ld-linux.so.2";
void fun()
{
    printf("This is fun./n");
    exit(0);
}

Then build your program as an shared library and specify func as entry point：

$ gcc -fpic -shared -o fun.so -Wl,-e,fun fun.c
$ ./fun.so

The problem of this way is that the func can't have the normal arguments as we have in main function, this is because we don't have the c library to initialize the main arguments stuff.

You can do this in a portable way, simply by including this header file in your main program:

int nomDePlume(int argc, char *argv[]);
int main(int argc, char *argv[]) { return nomDePlume(argc, argv); }

Then provide your own variant of main:

int nomDePlume(int argc, char *argv[]) {
    weaveYourMagic();
    return 42;
}

That doesn't actually change the entry point of the executable (something that's very much implementation specific) but it does let you call your program entry point whatever you wish (within the bounds of legal identifiers, of course).

If you don't want a main at all (even in a header file), it becomes a little tricky.

That's because the entry pount for an executable generally isn't main - there's quite a bit of activity happening before main is called, to do with environment setup and other things (and some tear-down stuff after main exits, such as your atexit handlers).

In other words, while the main function may be where your C program starts, that's not the same thing as where your executable starts.

As one example, in Linux, the ELF executable format contains an entry point address in the e_entry field of a header block, and that's where the program loader jumps to when it's ready to run the executable.

What usually happens to set this up is that you link (implicitly) with some start-up code like crt0 and the linker populates the e_entry field with the address of a known symbol. An example of which is (from that link, with comments slightly modified):

.text
.globl _start
_start:                       # Entry point known to linker.
    xor %ebp, %ebp            # RBP <- 0, mark end of stack frames.
    mov (%rsp), %edi          # Get argc from stack (implicitly
                              #   zero-extended to 64-bit).
    lea 8(%rsp), %rsi         # Take address of argv from stack.
    lea 16(%rsp,%rdi,8), %rdx # Take address of envp from stack.
    xor %eax, %eax            # Per ABI and compatibility with icc.

    call main                 # Three args %edi/%rsi/%rdx (first
                              #   two are C standard).

    mov %eax, %edi            # Effectively set up _exit(main()).
    xor %eax, %eax            # Per ABI and compatibility with icc.
    call _exit                # Terminate the program.

You can see there the start-up and tear-down stuff happening on either side of the main call, and therein lies a possible solution for you.

By creating your own crt0, replacing the text main with whatever you want to call, and ensuring the linker uses your crt0 rather than the default one, you can have it call whatever function you want to provide as the main one.

However, it's not really clear what you gain from being able to use an arbitrarily-named main function, other than to obtain job security or annoy your colleague when they can't find where your code begins :-)

If it's an educational thing, that's fine - I just wouldn't do this in a real-world situation.