You could place the function in __mod_init_func data section of Mach-O binary.

From Mach-O format reference:

__DATA,__mod_init_func

Module initialization functions. The C++ compiler places static constructors here.

example.c

#include <stdio.h>

void myinit(int argc, char **argv, char **envp) {
  printf("%s: %s\n", __FILE__, __FUNCTION__);
}
__attribute__((section("__DATA,__mod_init_func"))) typeof(myinit) *__init = myinit;

int main() {
  printf("%s: %s\n", __FILE__, __FUNCTION__);
  return 0;
}

I build your example with clang on OS X platform:

$ clang -Wall example.c
$ ./a.out
example.c: myinit
example.c: main

Easiest way is to specify the function to be constructor using constructor attribute. The constructor attribute causes the function to be called automatically before execution enters main(). Similarly, the destructor attribute causes the function to be called automatically after main() completes or exit() is called. You can also specify optional priority if you have several functions

e.g. __attribute__((constructor(100)))

#include <stdio.h>

__attribute__((constructor)) void myinit() {
    printf("my init\n");
}

int main() {
    printf("my main\n");
    return 0;
}

__attribute__((destructor)) void mydeinit() {
    printf("my deinit\n");
}


$ clang -Wall example.c
$ ./a.out
my init
my main
my deinit

Disclaimer: I generally discourage what I'm about to say. Having code running before or after main makes things less predictable. I'm not sure why you wouldn't just let the first line of main invoke your myinit, but I suppose everyone has a reason. Here goes.

I don't know much about Mach-O, but the simplest way to run code before main, is to link in a C++ class that has a corresponding global instance defined. You can do this independently of your "C" code without having to alter anything else. You can also have this C++ code invoke C functions defined elsewhere in your code. In the example below, I show a simple example of how I would invoke your myinit.

In a standalone .cpp (or .cc) file, declare a very simple C++ class with a constructor that calls your "myinit function".

foo.cpp

// forward declare your myinit function and designate "C" linkage
extern "C" myinit(int, char**, char**);

class CodeToRunBeforeMain
{
 public:
    CodeToRunBeforeMain()
    {
        // invoke your myinit function here
        myinit(0, NULL, NULL);
    }

};

// global instance - constructor will run before main.
CodeToRunBeforeMain g_runBeforeMain;

The above approach doesn't recognize argc, argv, or envp. Hopefully, that isn't important.