Return to crt0.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / lib / csu.hp300

Annotation of 43BSDReno/lib/csu.hp300/crt0.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1980 Regents of the University of California.
                      3:  * All rights reserved.  The Berkeley software License Agreement
                      4:  * specifies the terms and conditions for redistribution.
                      5:  */
                      6: 
                      7: #if defined(LIBC_SCCS) && !defined(lint)
                      8: static char sccsid[] = "@(#)crt0.c     5.3 (Berkeley) 3/9/86";
                      9: #endif LIBC_SCCS and not lint
                     10: 
                     11: /*
                     12:  *     C start up routine.
                     13:  *     Robert Henry, UCB, 20 Oct 81
                     14:  *
                     15:  *     We make the following (true) assumptions:
                     16:  *     1) when the kernel calls start, it does a jump to location 2,
                     17:  *     and thus avoids the register save mask.  We are NOT called
                     18:  *     with a calls!  see sys1.c:setregs().
                     19:  *     2) The only register variable that we can trust is sp,
                     20:  *     which points to the base of the kernel calling frame.
                     21:  *     Do NOT believe the documentation in exec(2) regarding the
                     22:  *     values of fp and ap.
                     23:  *     3) We can allocate as many register variables as we want,
                     24:  *     and don't have to save them for anybody.
                     25:  *     4) Because of the ways that asm's work, we can't have
                     26:  *     any automatic variables allocated on the stack, because
                     27:  *     we must catch the value of sp before any automatics are
                     28:  *     allocated.
                     29:  */
                     30: 
                     31: char **environ = (char **)0;
                     32: static int fd;
                     33: 
                     34: asm("#define _start start");
                     35: asm("#define _eprol eprol");
                     36: 
                     37: #ifdef hp300
                     38: asm("#define link .long 0; linkw");    /* Yuk!! */
                     39: #endif
                     40: 
                     41: extern unsigned char   etext;
                     42: extern unsigned char   eprol;
                     43: start()
                     44: {
                     45:        struct kframe {
                     46:                int     kargc;
                     47:                char    *kargv[1];      /* size depends on kargc */
                     48:                char    kargstr[1];     /* size varies */
                     49:                char    kenvstr[1];     /* size varies */
                     50:        };
                     51:        /*
                     52:         *      ALL REGISTER VARIABLES!!!
                     53:         */
                     54:        register int d7;                /* needed for init (this will be
                     55:                                           a problem with GCC) */
                     56:        register struct kframe *kfp;    /* PCC a5 */
                     57:        register char **targv;
                     58:        register char **argv;
                     59:        extern int errno;
                     60: 
                     61: #ifdef lint
                     62:        kfp = 0;
                     63:        initcode = initcode = 0;
                     64: #else not lint
                     65: #ifdef __GNUC__
                     66:        asm("lea a6@(4),%0" : "=r" (kfp));      /* catch it quick */
                     67: #else
                     68:        asm("   lea     a6@(4),a5");    /* catch it quick */
                     69: #endif
                     70: #endif not lint
                     71:        for (argv = targv = &kfp->kargv[0]; *targv++; /* void */)
                     72:                /* void */ ;
                     73:        if (targv >= (char **)(*argv))
                     74:                --targv;
                     75:        environ = targv;
                     76: asm("eprol:");
                     77: 
                     78: #ifdef paranoid
                     79:        /*
                     80:         * The standard I/O library assumes that file descriptors 0, 1, and 2
                     81:         * are open. If one of these descriptors is closed prior to the start 
                     82:         * of the process, I/O gets very confused. To avoid this problem, we
                     83:         * insure that the first three file descriptors are open before calling
                     84:         * main(). Normally this is undefined, as it adds two unnecessary
                     85:         * system calls.
                     86:         */
                     87:        do      {
                     88:                fd = open("/dev/null", 2);
                     89:        } while (fd >= 0 && fd < 3);
                     90:        close(fd);
                     91: #endif paranoid
                     92: 
                     93: #ifdef MCRT0
                     94:        monstartup(&eprol, &etext);
                     95: #endif MCRT0
                     96:        errno = 0;
                     97:        exit(main(kfp->kargc, argv, environ));
                     98: }
                     99: asm("#undef link");
                    100: asm("#undef _start");
                    101: asm("#undef _eprol");
                    102: 
                    103: #ifdef MCRT0
                    104: /*ARGSUSED*/
                    105: exit(code)
                    106:        register int code;      /* PCC d7 */
                    107: {
                    108:        monitor(0);
                    109:        _cleanup();
                    110: #ifdef __GNUC__
                    111:        asm("movl %1,sp@-" : "=m" (*(char *)0) : "r" (code));
                    112: #else
                    113:        asm("   movl d7,sp@-");
                    114: #endif
                    115:        asm("   subql #4,sp");
                    116:        asm("   movl #1,d0");
                    117:        asm("   trap #0");
                    118: }
                    119: #endif MCRT0
                    120: 
                    121: #ifdef CRT0
                    122: /*
                    123:  * null mcount and moncontrol,
                    124:  * just in case some routine is compiled for profiling
                    125:  */
                    126: moncontrol(val)
                    127:        int val;
                    128: {
                    129: 
                    130: }
                    131: asm("  .globl  mcount");
                    132: asm("mcount:   rts");
                    133: #endif CRT0

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