Return to crt0.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / libc / tahoe / csu.ucb

Annotation of cci/usr/src/lib/libc/tahoe/csu.ucb/crt0.c, revision 1.1.1.1

1.1       root        1: /* Tahoe version 3/28/84 (unused yet) */
                      2: 
                      3: /*
                      4:  *     C start up routine.
                      5:  *     Robert Henry, UCB, 20 Oct 81
                      6:  *
                      7:  *     We make the following (true) assumptions:
                      8:  *     1) when the kernel calls start, it does a jump to location 2,
                      9:  *     and thus avoids the register save mask.  We are NOT called
                     10:  *     with a calls!  see sys1.c:setregs().
                     11:  *     2) The only register variable that we can trust is sp,
                     12:  *     which points to the base of the kernel calling frame.
                     13:  *     Do NOT believe the documentation in exec(2) regarding the
                     14:  *     values of fp and ap.
                     15:  *     3) We can allocate as many register variables as we want,
                     16:  *     and don't have to save them for anybody.
                     17:  *     4) Because of the ways that asm's work, we can't have
                     18:  *     any automatic variables allocated on the stack, because
                     19:  *     we must catch the value of sp before any automatics are
                     20:  *     allocated.
                     21:  */
                     22: 
                     23: char **environ = (char **)0;
                     24: 
                     25: asm("#define _start start");
                     26: asm("#define _eprol eprol");
                     27: extern unsigned char   etext;
                     28: extern unsigned char   eprol;
                     29: start()
                     30: {
                     31:        struct kframe {
                     32:                int     kargc;
                     33:                char    *kargv[1];      /* size depends on kargc */
                     34:                char    kargstr[1];     /* size varies */
                     35:                char    kenvstr[1];     /* size varies */
                     36:        };
                     37:        /*
                     38:         *      ALL REGISTER VARIABLES!!!
                     39:         */
                     40:        register int r12;               /* dummy */
                     41:        register int r11;               /* needed for init */
                     42:        register struct kframe *kfp;    /* r10 */
                     43:        register char **targv;
                     44:        register char **argv;
                     45: 
                     46: #ifdef lint
                     47:        kfp = 0;
                     48:        initcode = initcode = 0;
                     49: #else not lint
                     50:        asm("   movl    sp,r10");       /* catch it quick */
                     51: #endif not lint
                     52:        for (argv = targv = &kfp->kargv[0]; *targv++; /* void */)
                     53:                /* void */ ;
                     54:        if (targv >= (char **)(*argv))
                     55:                --targv;
                     56:        environ = targv;
                     57: asm("eprol:");
                     58: #ifdef MCRT0
                     59:        monstartup(&eprol, &etext);
                     60: #endif MCRT0
                     61:        exit(main(kfp->kargc, argv, environ));
                     62: }
                     63: asm("#undef _start");
                     64: asm("#undef _eprol");
                     65: 
                     66: #ifdef MCRT0
                     67: /*ARGSUSED*/
                     68: exit(code)
                     69:        int code;       /* 4(fp) */
                     70: {
                     71:        monitor(0);
                     72:        _cleanup();
                     73:        asm("   movl 4(fp),r0");
                     74:        asm("   chmk $1");
                     75: }
                     76: #endif MCRT0
                     77: 
                     78: #ifdef CRT0
                     79: /*
                     80:  * null mcount and moncontrol,
                     81:  * just in case some routine is compiled for profiling
                     82:  */
                     83: moncontrol(val)
                     84:        int val;
                     85: {
                     86: 
                     87: }
                     88: asm("  .globl  mcount");
                     89: asm("mcount:   ret");
                     90: #endif CRT0

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.