Return to lcatch2.c CVS log

Up to [Research Unix] / researchv8dc / cmd / ccom / vax

Annotation of researchv8dc/cmd/ccom/vax/lcatch2.c, revision 1.1

1.1     ! root        1: # include "mfile2.h"
        !             2: extern int Pflag, bbcnt;
        !             3: /* a lot of the machine dependent parts of the second pass */
        !             4: 
        !             5: char *
        !             6: rnames[]= {  /* keyed to register number tokens */
        !             7: 
        !             8:        "r0", "r1",
        !             9:        "r2", "r3", "r4",
        !            10:        "r5", "r6", "r7", "r8", "r9", "r10", "r11",
        !            11:        "ap", "fp", "sp", "pc" 
        !            12:        };
        !            13: 
        !            14: eobl2()                        /* end of function stuff */
        !            15: {
        !            16: }
        !            17: 
        !            18: char *
        !            19: exname( ix )
        !            20: char *ix;
        !            21: {
        !            22:        /* make a name look like an external name in the local machine */
        !            23: 
        !            24:        static char text[100] = "_";
        !            25: 
        !            26:        if( ix == NULL ) cerror("no name in exname");
        !            27:        strcpy(text+1, ix);
        !            28:        return( text );
        !            29: }
        !            30: 
        !            31: lineid( l, fn )
        !            32: int l;
        !            33: char *fn;
        !            34: {
        !            35:        /* identify line l and file fn */
        !            36:        printx( "#      line %d, file %s\n", l, fn );
        !            37: }
        !            38: 
        !            39: deflab( n )
        !            40: int n;
        !            41: {
        !            42:        printx( "L%d:\n", n );
        !            43: }
        !            44: 
        !            45: 
        !            46: genubr( n )
        !            47: int n;
        !            48: {
        !            49:        /* output a branch to label n */
        !            50:        printx( "\tjbr\tL%d\n", n );
        !            51:        if(Pflag)
        !            52:                printx("#jmp L%d\n", n);
        !            53: }
        !            54: genret( s, l, n )
        !            55: int s, l, n;
        !            56: {
        !            57:        /* a return: s nonzero means a structure returned */
        !            58:        /* n has the value of "retlab", a common spot for returns */
        !            59:        deflab(n);
        !            60:        if( s ) printx( "\tmovab\tL%d,r0\n", l );
        !            61:        if(Pflag) {
        !            62:                printx("#ret %d\n", ++bbcnt);
        !            63:                printx("\tincl\tlocprof+%d\n", 4*(bbcnt+3));
        !            64:        }
        !            65:        dbfunret();
        !            66:        printx( "\tret\n" );
        !            67: }
        !            68: 
        !            69: defalign(n)
        !            70: int n;
        !            71: {
        !            72:        /* cause the alignment to become a multiple of n bits */
        !            73:        if( n % SZCHAR ) cerror( "funny alignment: %d", n );
        !            74:        else n /= SZCHAR;
        !            75:        if( n == 1 ) return;
        !            76:        else if( n==2 ) n=1;
        !            77:        else if( n==4 ) n=2;
        !            78:        else cerror( "funny alignment: %d", n );
        !            79:        printx( "\t.align\t%d\n", n );
        !            80: }
        !            81: 
        !            82: char *locnames[] = {
        !            83:        /* location counter names for PROG, DATA, ADATA, ISTRNG, STRNG */
        !            84:        "       .text\n",
        !            85:        "       .data\n",
        !            86:        "       .data\n",
        !            87:        "       .data   2\n",
        !            88:        "       .data   1\n",
        !            89:        };
        !            90: 
        !            91: bycode( t, i )
        !            92: int t, i;
        !            93: {
        !            94:        /* put byte i+1 in a string */
        !            95: 
        !            96:        if ( t < 0 ) { /* end of the string */
        !            97:                printx("\n");
        !            98:        } else { /* stash byte t into string */
        !            99:                if( (i&7) == 0 ) printx( "\n    .byte   " );
        !           100:                else printx(",");
        !           101:                printx("0x%x", t);
        !           102:        }
        !           103: }
        !           104: 
        !           105: genshort( s )
        !           106: short s;
        !           107: {
        !           108:        /* write out a short value */
        !           109:        printx( "       .short  %d\n", (short) s );
        !           110: }
        !           111: 
        !           112: genlong( l )
        !           113: long l;
        !           114: {
        !           115:        /* write out a long initializer */
        !           116:        printx( "       .long   0x%lx\n", l );
        !           117: }

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