Return to code.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / libexec / pcc / ccom.vax

Annotation of 43BSDReno/libexec/pcc/ccom.vax/code.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char *sccsid ="@(#)code.c       1.10 (Berkeley) 5/31/88";
        !             3: #endif lint
        !             4: 
        !             5: # include "pass1.h"
        !             6: # include <sys/types.h>
        !             7: # include <a.out.h>
        !             8: # include <stab.h>
        !             9: 
        !            10: int proflg = 0;        /* are we generating profiling code? */
        !            11: int strftn = 0;  /* is the current function one which returns a value */
        !            12: int gdebug;
        !            13: int fdefflag;  /* are we within a function definition ? */
        !            14: #ifndef STABDOT
        !            15: char NULLNAME[8];
        !            16: #endif
        !            17: int labelno;
        !            18: 
        !            19: # define putstr(s)     fputs((s), stdout)
        !            20: 
        !            21: branch( n ){
        !            22:        /* output a branch to label n */
        !            23:        /* exception is an ordinary function branching to retlab: then, return */
        !            24:        if( nerrors ) return;
        !            25:        if( n == retlab && !strftn ){
        !            26:                putstr( "       ret\n" );
        !            27:                }
        !            28:        else printf( "  jbr     L%d\n", n );
        !            29:        }
        !            30: 
        !            31: int lastloc = { -1 };
        !            32: 
        !            33: short log2tab[] = {0, 0, 1, 2, 2, 3, 3, 3, 3};
        !            34: #define LOG2SZ 9
        !            35: 
        !            36: defalign(n) {
        !            37:        /* cause the alignment to become a multiple of n */
        !            38:        n /= SZCHAR;
        !            39:        if( lastloc != PROG && n > 1 ) printf( "        .align  %d\n", n >= 0 && n < LOG2SZ ? log2tab[n] : 0 );
        !            40:        }
        !            41: 
        !            42: locctr( l ){
        !            43:        register temp;
        !            44:        /* l is PROG, ADATA, DATA, STRNG, ISTRNG, or STAB */
        !            45: 
        !            46:        if( l == lastloc ) return(l);
        !            47:        temp = lastloc;
        !            48:        lastloc = l;
        !            49:        if( nerrors ) return(temp);
        !            50:        switch( l ){
        !            51: 
        !            52:        case PROG:
        !            53:                putstr( "       .text\n" );
        !            54:                psline();
        !            55:                break;
        !            56: 
        !            57:        case DATA:
        !            58:        case ADATA:
        !            59:                putstr( "       .data\n" );
        !            60:                break;
        !            61: 
        !            62:        case STRNG:
        !            63:                putstr( "       .data   1\n" );
        !            64:                break;
        !            65: 
        !            66:        case ISTRNG:
        !            67:                putstr( "       .data   2\n" );
        !            68:                break;
        !            69: 
        !            70:        case STAB:
        !            71:                putstr( "       .stab\n" );
        !            72:                break;
        !            73: 
        !            74:        default:
        !            75:                cerror( "illegal location counter" );
        !            76:                }
        !            77: 
        !            78:        return( temp );
        !            79:        }
        !            80: 
        !            81: deflab( n ){
        !            82:        /* output something to define the current position as label n */
        !            83:        if (nerrors) return;
        !            84:        printf( "L%d:\n", n );
        !            85:        }
        !            86: 
        !            87: int crslab = 10;
        !            88: 
        !            89: getlab(){
        !            90:        /* return a number usable for a label */
        !            91:        return( ++crslab );
        !            92:        }
        !            93: 
        !            94: 
        !            95: int ent_mask[] = {
        !            96:        0,0,0,0,0, 0xfc0, 0xf80, 0xf00, 0xe00, 0xc00, 0x800, 0};
        !            97: 
        !            98: int reg_use = 11;
        !            99: 
        !           100: efcode(){
        !           101:        /* code for the end of a function */
        !           102: 
        !           103:        if( strftn ){  /* copy output (in R2) to caller */
        !           104:                register NODE *l, *r;
        !           105:                register struct symtab *p;
        !           106:                register TWORD t;
        !           107:                int i;
        !           108: 
        !           109:                p = &stab[curftn];
        !           110:                t = p->stype;
        !           111:                t = DECREF(t);
        !           112: 
        !           113:                deflab( retlab );
        !           114: 
        !           115:                i = getlab();   /* label for return area */
        !           116: #ifndef LCOMM
        !           117:                putstr("        .data\n" );
        !           118:                putstr("        .align  2\n" );
        !           119:                printf("L%d:    .space  %d\n", i, tsize(t, p->dimoff, p->sizoff)/SZCHAR );
        !           120:                putstr("        .text\n" );
        !           121: #else
        !           122:                { int sz = tsize(t, p->dimoff, p->sizoff) / SZCHAR;
        !           123:                if (sz % (SZINT/SZCHAR))
        !           124:                        sz += (SZINT/SZCHAR) - (sz % (SZINT/SZCHAR));
        !           125:                printf("        .lcomm  L%d,%d\n", i, sz);
        !           126:                }
        !           127: #endif
        !           128:                psline();
        !           129:                printf("        movab   L%d,r1\n", i);
        !           130: 
        !           131:                reached = 1;
        !           132:                l = block( REG, NIL, NIL, PTR|t, p->dimoff, p->sizoff );
        !           133:                l->tn.rval = 1;  /* R1 */
        !           134:                l->tn.lval = 0;  /* no offset */
        !           135:                r = block( REG, NIL, NIL, PTR|t, p->dimoff, p->sizoff );
        !           136:                r->tn.rval = 0;  /* R0 */
        !           137:                r->tn.lval = 0;
        !           138:                l = buildtree( UNARY MUL, l, NIL );
        !           139:                r = buildtree( UNARY MUL, r, NIL );
        !           140:                l = buildtree( ASSIGN, l, r );
        !           141:                l->in.op = FREE;
        !           142:                ecomp( l->in.left );
        !           143:                printf( "       movab   L%d,r0\n", i );
        !           144:                /* turn off strftn flag, so return sequence will be generated */
        !           145:                strftn = 0;
        !           146:                }
        !           147:        branch( retlab );
        !           148: #ifndef VMS
        !           149:        printf( "       .set    L%d,0x%x\n", ftnno, ent_mask[reg_use] );
        !           150: #else
        !           151:        printf( "       .set    L%d,%d  # Hex = 0x%x\n", ftnno, 0x3c| ent_mask[reg_use], ent_mask[reg_use]  );
        !           152:        /* KLS kludge, under VMS if you use regs 2-5, you must save them. */
        !           153: #endif
        !           154:        reg_use = 11;
        !           155:        p2bend();
        !           156:        fdefflag = 0;
        !           157:        }
        !           158: 
        !           159: int ftlab1, ftlab2;
        !           160: 
        !           161: bfcode( a, n ) int a[]; {
        !           162:        /* code for the beginning of a function; a is an array of
        !           163:                indices in stab for the arguments; n is the number */
        !           164:        register i;
        !           165:        register temp;
        !           166:        register struct symtab *p;
        !           167:        int off;
        !           168: #ifdef TRUST_REG_CHAR_AND_REG_SHORT
        !           169:        char *toreg();
        !           170: #endif
        !           171: 
        !           172:        if( nerrors ) return;
        !           173:        (void) locctr( PROG );
        !           174:        p = &stab[curftn];
        !           175:        putstr( "       .align  1\n");
        !           176:        defnam( p );
        !           177:        temp = p->stype;
        !           178:        temp = DECREF(temp);
        !           179:        strftn = (temp==STRTY) || (temp==UNIONTY);
        !           180: 
        !           181:        retlab = getlab();
        !           182: 
        !           183:        /* routine prolog */
        !           184: 
        !           185:        printf( "       .word   L%d\n", ftnno);
        !           186:        ftlab1 = getlab();
        !           187:        ftlab2 = getlab();
        !           188:        printf( "       jbr     L%d\n", ftlab1);
        !           189:        printf( "L%d:\n", ftlab2);
        !           190:        if( proflg ) {  /* profile code */
        !           191:                i = getlab();
        !           192:                printf("        movab   L%d,r0\n", i);
        !           193:                putstr("        jsb     mcount\n");
        !           194:                putstr("        .data\n");
        !           195:                putstr("        .align  2\n");
        !           196:                printf("L%d:    .long   0\n", i);
        !           197:                putstr("        .text\n");
        !           198:                psline();
        !           199:                }
        !           200: 
        !           201:        off = ARGINIT;
        !           202: 
        !           203:        for( i=0; i<n; ++i ){
        !           204:                p = &stab[a[i]];
        !           205:                if( p->sclass == REGISTER ){
        !           206:                        temp = p->offset;  /* save register number */
        !           207:                        p->sclass = PARAM;  /* forget that it is a register */
        !           208:                        p->offset = NOOFFSET;
        !           209:                        (void) oalloc( p, &off );
        !           210: #ifdef TRUST_REG_CHAR_AND_REG_SHORT /* and reg double */
        !           211: /*tbl*/                printf( "       %s      %d(ap),r%d\n", toreg(p->stype), p->offset/SZCHAR, temp );
        !           212: #else
        !           213: /*tbl*/                printf( "       movl    %d(ap),r%d\n", p->offset/SZCHAR, temp );
        !           214: #endif
        !           215:                        p->offset = temp;  /* remember register number */
        !           216:                        p->sclass = REGISTER;   /* remember that it is a register */
        !           217:                        }
        !           218:                else if( p->stype == STRTY || p->stype == UNIONTY ) {
        !           219:                        p->offset = NOOFFSET;
        !           220:                        if( oalloc( p, &off ) ) cerror( "bad argument" );
        !           221:                        SETOFF( off, ALSTACK );
        !           222:                        }
        !           223:                else {
        !           224:                        if( oalloc( p, &off ) ) cerror( "bad argument" );
        !           225:                        }
        !           226: 
        !           227:                }
        !           228:        if (gdebug && !nerrors) {
        !           229: #ifdef STABDOT
        !           230:                pstabdot(N_SLINE, lineno);
        !           231: #else
        !           232:                pstab(NULLNAME, N_SLINE);
        !           233:                printf("0,%d,LL%d\n", lineno, labelno);
        !           234:                printf("LL%d:\n", labelno++);
        !           235: #endif
        !           236:        }
        !           237:        fdefflag = 1;
        !           238:        }
        !           239: 
        !           240: bccode(){ /* called just before the first executable statment */
        !           241:                /* by now, the automatics and register variables are allocated */
        !           242:        SETOFF( autooff, SZINT );
        !           243:        /* set aside store area offset */
        !           244:        p2bbeg( autooff, regvar );
        !           245:        reg_use = (reg_use > regvar ? regvar : reg_use);
        !           246:        }
        !           247: 
        !           248: /*ARGSUSED*/
        !           249: ejobcode( flag ){
        !           250:        /* called just before final exit */
        !           251:        /* flag is 1 if errors, 0 if none */
        !           252:        }
        !           253: 
        !           254: #ifndef aobeg
        !           255: aobeg(){
        !           256:        /* called before removing automatics from stab */
        !           257:        }
        !           258: #endif aobeg
        !           259: 
        !           260: #ifndef aocode
        !           261: /*ARGSUSED*/
        !           262: aocode(p) struct symtab *p; {
        !           263:        /* called when automatic p removed from stab */
        !           264:        }
        !           265: #endif aocode
        !           266: 
        !           267: #ifndef aoend
        !           268: aoend(){
        !           269:        /* called after removing all automatics from stab */
        !           270:        }
        !           271: #endif aoend
        !           272: 
        !           273: defnam( p ) register struct symtab *p; {
        !           274:        /* define the current location as the name p->sname */
        !           275: 
        !           276:        if( p->sclass == EXTDEF ){
        !           277:                printf( "       .globl  %s\n", exname( p->sname ) );
        !           278:                }
        !           279:        if( p->sclass == STATIC && p->slevel>1 ) deflab( p->offset );
        !           280:        else printf( "%s:\n", exname( p->sname ) );
        !           281: 
        !           282:        }
        !           283: 
        !           284: bycode( t, i ){
        !           285: #ifdef ASSTRINGS
        !           286: static int     lastoctal = 0;
        !           287: #endif
        !           288: 
        !           289:        /* put byte i+1 in a string */
        !           290: 
        !           291:        if ( nerrors ) return;
        !           292: #ifdef ASSTRINGS
        !           293: 
        !           294:        i &= 077;
        !           295:        if ( t < 0 ){
        !           296:                if ( i != 0 )   putstr( "\"\n" );
        !           297:        } else {
        !           298:                if ( i == 0 ) putstr("\t.ascii\t\"");
        !           299:                if ( t == '\\' || t == '"'){
        !           300:                        lastoctal = 0;
        !           301:                        printf("\\%c", t);
        !           302:                }
        !           303:                        /*
        !           304:                         *      We escape the colon in strings so that
        !           305:                         *      c2 will, in its infinite wisdom, interpret
        !           306:                         *      the characters preceding the colon as a label.
        !           307:                         *      If we didn't escape the colon, c2 would
        !           308:                         *      throw away any trailing blanks or tabs after
        !           309:                         *      the colon, but reconstruct a assembly
        !           310:                         *      language semantically correct program.
        !           311:                         *      C2 hasn't been taught about strings.
        !           312:                         */
        !           313:                else if ( t == ':' || t < 040 || t >= 0177 ){
        !           314:                        lastoctal++;
        !           315:                        printf("\\%o",t);
        !           316:                }
        !           317:                else if ( lastoctal && '0' <= t && t <= '9' ){
        !           318:                        lastoctal = 0;
        !           319:                        printf("\"\n\t.ascii\t\"%c", t );
        !           320:                }
        !           321:                else
        !           322:                {       
        !           323:                        lastoctal = 0;
        !           324:                        putchar(t);
        !           325:                }
        !           326:                if ( i == 077 ) putstr("\"\n");
        !           327:        }
        !           328: #else
        !           329: 
        !           330:        i &= 07;
        !           331:        if( t < 0 ){ /* end of the string */
        !           332:                if( i != 0 ) putchar( '\n' );
        !           333:                }
        !           334: 
        !           335:        else { /* stash byte t into string */
        !           336:                if( i == 0 ) putstr( "  .byte   " );
        !           337:                else putchar( ',' );
        !           338:                printf( "0x%x", t );
        !           339:                if( i == 07 ) putchar( '\n' );
        !           340:                }
        !           341: #endif
        !           342:        }
        !           343: 
        !           344: zecode( n ){
        !           345:        /* n integer words of zeros */
        !           346:        OFFSZ temp;
        !           347:        if( n <= 0 ) return;
        !           348:        printf( "       .space  %d\n", (SZINT/SZCHAR)*n );
        !           349:        temp = n;
        !           350:        inoff += temp*SZINT;
        !           351:        }
        !           352: 
        !           353: /*ARGSUSED*/
        !           354: fldal( t ) unsigned t; { /* return the alignment of field of type t */
        !           355:        uerror( "illegal field type" );
        !           356:        return( ALINT );
        !           357:        }
        !           358: 
        !           359: /*ARGSUSED*/
        !           360: fldty( p ) struct symtab *p; { /* fix up type of field p */
        !           361:        ;
        !           362:        }
        !           363: 
        !           364: /*ARGSUSED*/
        !           365: where(c){ /* print location of error  */
        !           366:        /* c is either 'u', 'c', or 'w' */
        !           367:        /* GCOS version */
        !           368:        fprintf( stderr, "%s, line %d: ", ftitle, lineno );
        !           369:        }
        !           370: 
        !           371: 
        !           372: #ifdef TRUST_REG_CHAR_AND_REG_SHORT
        !           373: /* tbl - toreg() returns a pointer to a char string
        !           374:                  which is the correct  "register move" for the passed type 
        !           375:  */
        !           376: struct type_move {TWORD fromtype; char tostrng[8];} toreg_strs[] =
        !           377:        {
        !           378:        INT, "movl",
        !           379:        UNSIGNED,       "movl",
        !           380:        DOUBLE, "movq",
        !           381:        CHAR, "cvtbl",
        !           382:        SHORT, "cvtwl",
        !           383:        UCHAR,  "movzbl",
        !           384:        USHORT, "movzwl",
        !           385:        0, ""
        !           386:        };
        !           387: 
        !           388: char
        !           389: *toreg(type)
        !           390:        TWORD type;
        !           391: {
        !           392:        struct type_move *p;
        !           393: 
        !           394:        for ( p=toreg_strs; p->fromtype != 0; p++)
        !           395:                if (p->fromtype == type) return(p->tostrng);
        !           396: 
        !           397:        /* type not found, must be a pointer type */
        !           398:        return("movl");
        !           399: }
        !           400: /* tbl */
        !           401: #endif
        !           402: 
        !           403: 
        !           404: main( argc, argv ) char *argv[]; {
        !           405: #ifdef BUFSTDERR
        !           406:        char errbuf[BUFSIZ];
        !           407:        setbuf(stderr, errbuf);
        !           408: #endif
        !           409:        return(mainp1( argc, argv ));
        !           410:        }
        !           411: 
        !           412: struct sw heapsw[SWITSZ];      /* heap for switches */
        !           413: 
        !           414: genswitch(p,n) register struct sw *p;{
        !           415:        /*      p points to an array of structures, each consisting
        !           416:                of a constant value and a label.
        !           417:                The first is >=0 if there is a default label;
        !           418:                its value is the label number
        !           419:                The entries p[1] to p[n] are the nontrivial cases
        !           420:                */
        !           421:        register i;
        !           422:        register CONSZ j, range;
        !           423:        register dlab, swlab;
        !           424: 
        !           425:        if( nerrors ) return;
        !           426:        range = p[n].sval-p[1].sval;
        !           427: 
        !           428:        if( range>0 && range <= 3*n && n>=4 ){ /* implement a direct switch */
        !           429: 
        !           430:                swlab = getlab();
        !           431:                dlab = p->slab >= 0 ? p->slab : getlab();
        !           432: 
        !           433:                /* already in r0 */
        !           434:                printf("        casel   r0,$%ld,$%ld\n", p[1].sval, range);
        !           435:                printf("L%d:\n", swlab);
        !           436:                for( i=1,j=p[1].sval; i<=n; j++) {
        !           437:                        printf("        .word   L%d-L%d\n", (j == p[i].sval ? ((j=p[i++].sval), p[i-1].slab) : dlab),
        !           438:                                swlab);
        !           439:                        }
        !           440: 
        !           441:                if( p->slab >= 0 ) branch( dlab );
        !           442:                else printf("L%d:\n", dlab);
        !           443:                return;
        !           444: 
        !           445:                }
        !           446: 
        !           447:        if( n>8 ) {     /* heap switch */
        !           448: 
        !           449:                heapsw[0].slab = dlab = p->slab >= 0 ? p->slab : getlab();
        !           450:                makeheap(p, n, 1);      /* build heap */
        !           451: 
        !           452:                walkheap(1, n); /* produce code */
        !           453: 
        !           454:                if( p->slab >= 0 )
        !           455:                        branch( dlab );
        !           456:                else
        !           457:                        printf("L%d:\n", dlab);
        !           458:                return;
        !           459:        }
        !           460: 
        !           461:        /* debugging code */
        !           462: 
        !           463:        /* out for the moment
        !           464:        if( n >= 4 ) werror( "inefficient switch: %d, %d", n, (int) (range/n) );
        !           465:        */
        !           466: 
        !           467:        /* simple switch code */
        !           468: 
        !           469:        for( i=1; i<=n; ++i ){
        !           470:                /* already in r0 */
        !           471: 
        !           472:                putstr( "       cmpl    r0,$" );
        !           473:                printf( CONFMT, p[i].sval );
        !           474:                printf( "\n     jeql    L%d\n", p[i].slab );
        !           475:                }
        !           476: 
        !           477:        if( p->slab>=0 ) branch( p->slab );
        !           478:        }
        !           479: 
        !           480: makeheap(p, m, n)
        !           481: register struct sw *p;
        !           482: {
        !           483:        register int q;
        !           484: 
        !           485:        q = selectheap(m);
        !           486:        heapsw[n] = p[q];
        !           487:        if( q>1 ) makeheap(p, q-1, 2*n);
        !           488:        if( q<m ) makeheap(p+q, m-q, 2*n+1);
        !           489: }
        !           490: 
        !           491: selectheap(m) {
        !           492:        register int l,i,k;
        !           493: 
        !           494:        for(i=1; ; i*=2)
        !           495:                if( (i-1) > m ) break;
        !           496:        l = ((k = i/2 - 1) + 1)/2;
        !           497:        return( l + (m-k < l ? m-k : l));
        !           498: }
        !           499: 
        !           500: walkheap(start, limit)
        !           501: {
        !           502:        int label;
        !           503: 
        !           504: 
        !           505:        if( start > limit ) return;
        !           506:        printf("        cmpl    r0,$%d\n",  heapsw[start].sval);
        !           507:        printf("        jeql    L%d\n", heapsw[start].slab);
        !           508:        if( (2*start) > limit ) {
        !           509:                printf("        jbr     L%d\n", heapsw[0].slab);
        !           510:                return;
        !           511:        }
        !           512:        if( (2*start+1) <= limit ) {
        !           513:                label = getlab();
        !           514:                printf("        jgtr    L%d\n", label);
        !           515:        } else
        !           516:                printf("        jgtr    L%d\n", heapsw[0].slab);
        !           517:        walkheap( 2*start, limit);
        !           518:        if( (2*start+1) <= limit ) {
        !           519:                printf("L%d:\n", label);
        !           520:                walkheap( 2*start+1, limit);
        !           521:        }
        !           522: }

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