Return to local2.c CVS log

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

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

1.1     ! root        1: # ifndef lint
        !             2: static char *sccsid ="@(#)local2.c     1.39 (Berkeley) 5/11/88";
        !             3: # endif
        !             4: 
        !             5: # include "pass2.h"
        !             6: # include <ctype.h>
        !             7: 
        !             8: # define putstr(s)     fputs((s), stdout)
        !             9: 
        !            10: # ifdef FORT
        !            11: int ftlab1, ftlab2;
        !            12: # endif
        !            13: /* a lot of the machine dependent parts of the second pass */
        !            14: 
        !            15: # define BITMASK(n) ((1L<<n)-1)
        !            16: 
        !            17: /*ARGSUSED*/
        !            18: where(c){
        !            19:        fprintf( stderr, "%s, line %d: ", filename, lineno );
        !            20:        }
        !            21: 
        !            22: lineid( l, fn ) char *fn; {
        !            23:        /* identify line l and file fn */
        !            24:        printf( "#      line %d, file %s\n", l, fn );
        !            25:        }
        !            26: 
        !            27: 
        !            28: eobl2(){
        !            29:        register OFFSZ spoff;   /* offset from stack pointer */
        !            30: #ifndef FORT
        !            31:        extern int ftlab1, ftlab2;
        !            32: #endif
        !            33: 
        !            34:        spoff = maxoff;
        !            35:        if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
        !            36:        spoff /= SZCHAR;
        !            37:        SETOFF(spoff,4);
        !            38: #ifdef FORT
        !            39: #ifndef FLEXNAMES
        !            40:        printf( "       .set    .F%d,%ld\n", ftnno, spoff );
        !            41: #else
        !            42:        /* SHOULD BE L%d ... ftnno but must change pc/f77 */
        !            43:        printf( "       .set    LF%d,%ld\n", ftnno, spoff );
        !            44: #endif
        !            45: #else
        !            46:        printf( "L%d:\n", ftlab1);
        !            47:        if( spoff!=0 )
        !            48:                if( spoff < 64 )
        !            49:                        printf( "       subl2   $%ld,sp\n", spoff);
        !            50:                else
        !            51:                        printf( "       movab   -%ld(sp),sp\n", spoff);
        !            52:        printf( "       jbr     L%d\n", ftlab2);
        !            53: #endif
        !            54:        maxargs = -1;
        !            55:        }
        !            56: 
        !            57: struct hoptab { int opmask; char * opstring; } ioptab[] = {
        !            58: 
        !            59:        PLUS,   "add",
        !            60:        MINUS,  "sub",
        !            61:        MUL,    "mul",
        !            62:        DIV,    "div",
        !            63:        OR,     "bis",
        !            64:        ER,     "xor",
        !            65:        AND,    "bic",
        !            66:        -1, ""    };
        !            67: 
        !            68: hopcode( f, o ){
        !            69:        /* output the appropriate string from the above table */
        !            70: 
        !            71:        register struct hoptab *q;
        !            72: 
        !            73:        if(asgop(o))
        !            74:                o = NOASG o;
        !            75:        for( q = ioptab;  q->opmask>=0; ++q ){
        !            76:                if( q->opmask == o ){
        !            77:                        printf( "%s%c", q->opstring, tolower(f));
        !            78:                        return;
        !            79:                        }
        !            80:                }
        !            81:        cerror( "no hoptab for %s", opst[o] );
        !            82:        }
        !            83: 
        !            84: char *
        !            85: rnames[] = {  /* keyed to register number tokens */
        !            86: 
        !            87:        "r0", "r1",
        !            88:        "r2", "r3", "r4", "r5",
        !            89:        "r6", "r7", "r8", "r9", "r10", "r11",
        !            90:        "ap", "fp", "sp", "pc",
        !            91:        };
        !            92: 
        !            93: int rstatus[] = {
        !            94:        SAREG|STAREG, SAREG|STAREG,
        !            95:        SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG,
        !            96:        SAREG, SAREG, SAREG, SAREG, SAREG, SAREG,
        !            97:        SAREG, SAREG, SAREG, SAREG,
        !            98:        };
        !            99: 
        !           100: tlen(p) NODE *p;
        !           101: {
        !           102:        switch(p->in.type) {
        !           103:                case CHAR:
        !           104:                case UCHAR:
        !           105:                        return(1);
        !           106: 
        !           107:                case SHORT:
        !           108:                case USHORT:
        !           109:                        return(SZSHORT/SZCHAR);
        !           110: 
        !           111:                case DOUBLE:
        !           112:                        return(SZDOUBLE/SZCHAR);
        !           113: 
        !           114:                default:
        !           115:                        return(SZINT/SZCHAR);
        !           116:                }
        !           117: }
        !           118: 
        !           119: mixtypes(p, q) NODE *p, *q;
        !           120: {
        !           121:        register TWORD tp, tq;
        !           122: 
        !           123:        tp = p->in.type;
        !           124:        tq = q->in.type;
        !           125: 
        !           126:        return( (tp==FLOAT || tp==DOUBLE) !=
        !           127:                (tq==FLOAT || tq==DOUBLE) );
        !           128: }
        !           129: 
        !           130: prtype(n) NODE *n;
        !           131: {
        !           132:        switch (n->in.type)
        !           133:                {
        !           134: 
        !           135:                case DOUBLE:
        !           136:                        putchar('d');
        !           137:                        return;
        !           138: 
        !           139:                case FLOAT:
        !           140:                        putchar('f');
        !           141:                        return;
        !           142: 
        !           143:                case LONG:
        !           144:                case ULONG:
        !           145:                case INT:
        !           146:                case UNSIGNED:
        !           147:                        putchar('l');
        !           148:                        return;
        !           149: 
        !           150:                case SHORT:
        !           151:                case USHORT:
        !           152:                        putchar('w');
        !           153:                        return;
        !           154: 
        !           155:                case CHAR:
        !           156:                case UCHAR:
        !           157:                        putchar('b');
        !           158:                        return;
        !           159: 
        !           160:                default:
        !           161:                        if ( !ISPTR( n->in.type ) ) cerror("zzzcode- bad type");
        !           162:                        else {
        !           163:                                putchar('l');
        !           164:                                return;
        !           165:                                }
        !           166:                }
        !           167: }
        !           168: 
        !           169: zzzcode( p, c ) register NODE *p; {
        !           170:        register int m;
        !           171:        int val;
        !           172:        switch( c ){
        !           173: 
        !           174:        case 'N':  /* logical ops, turned into 0-1 */
        !           175:                /* use register given by register 1 */
        !           176:                cbgen( 0, m=getlab(), 'I' );
        !           177:                deflab( p->bn.label );
        !           178:                printf( "       clrl    %s\n", rnames[getlr( p, '1' )->tn.rval] );
        !           179:                deflab( m );
        !           180:                return;
        !           181: 
        !           182:        case 'P':
        !           183:                cbgen( p->in.op, p->bn.label, c );
        !           184:                return;
        !           185: 
        !           186:        case 'A':
        !           187:        case 'V':
        !           188:                sconv( p, c == 'V' );
        !           189:                return;
        !           190: 
        !           191:        case 'G':       /* i *= f; asgops with int lhs and float rhs */
        !           192:                {
        !           193:                register NODE *l, *r, *s;
        !           194:                int rt;
        !           195: 
        !           196:                l = p->in.left;
        !           197:                r = p->in.right;
        !           198:                s = talloc();
        !           199:                rt = r->in.type;
        !           200: 
        !           201:                s->in.op = SCONV;
        !           202:                s->in.left = l;
        !           203:                s->in.type = rt;
        !           204:                zzzcode(s, 'A');
        !           205:                putstr("\n\t");
        !           206: 
        !           207:                hopcode(rt == FLOAT ? 'F' : 'D', p->in.op);
        !           208:                putstr("2\t");
        !           209:                adrput(r);
        !           210:                putchar(',');
        !           211:                adrput(resc);
        !           212:                putstr("\n\t");
        !           213: 
        !           214:                s->in.op = ASSIGN;
        !           215:                s->in.left = l;
        !           216:                s->in.right = resc;
        !           217:                s->in.type = l->in.type;
        !           218:                zzzcode(s, 'A');
        !           219: 
        !           220:                s->in.op = FREE;
        !           221:                return;
        !           222:                }
        !           223: 
        !           224:        case 'J':       /* unsigned DIV/MOD with constant divisors */
        !           225:                {
        !           226:                register int ck = INAREG;
        !           227:                int label1, label2;
        !           228: 
        !           229:                /* case constant <= 1 is handled by optim() in pass 1 */
        !           230:                /* case constant < 0x80000000 is handled in table */
        !           231:                switch( p->in.op ) {
        !           232:                /* case DIV: handled in optim2() */
        !           233:                case MOD:
        !           234:                        if( p->in.left->in.op == REG &&
        !           235:                            p->in.left->tn.rval == resc->tn.rval )
        !           236:                                goto asgmod;
        !           237:                        label1 = getlab();
        !           238:                        expand(p, ck, "movl\tAL,A1\n\tcmpl\tA1,AR\n");
        !           239:                        printf("\tjlssu\tL%d\n", label1);
        !           240:                        expand(p, ck, "\tsubl2\tAR,A1\n");
        !           241:                        printf("L%d:", label1);
        !           242:                        break;
        !           243:                case ASG DIV:
        !           244:                        label1 = getlab();
        !           245:                        label2 = getlab();
        !           246:                        expand(p, ck, "cmpl\tAL,AR\n");
        !           247:                        printf("\tjgequ\tL%d\n", label1);
        !           248:                        expand(p, ck, "\tmovl\t$1,AL\n");
        !           249:                        printf("\tjbr\tL%d\nL%d:\n", label2, label1);
        !           250:                        expand(p, ck, "\tclrl\tAL\n");
        !           251:                        printf("L%d:", label2);
        !           252:                        break;
        !           253:                case ASG MOD:
        !           254:                asgmod:
        !           255:                        label1 = getlab();
        !           256:                        expand(p, ck, "cmpl\tAL,AR\n");
        !           257:                        printf("\tjlssu\tL%d\n", label1);
        !           258:                        expand(p, ck, "\tsubl2\tAR,AL\n");
        !           259:                        printf("L%d:", label1);
        !           260:                        break;
        !           261:                        }
        !           262:                return;
        !           263:                }
        !           264: 
        !           265:        case 'B':       /* get oreg value in temp register for left shift */
        !           266:                {
        !           267:                register NODE *r;
        !           268:                if (xdebug) eprint(p, 0, &val, &val);
        !           269:                r = p->in.right;
        !           270:                if( tlen(r) == SZINT/SZCHAR && r->in.type != FLOAT )
        !           271:                        putstr("movl");
        !           272:                else {
        !           273:                        putstr(ISUNSIGNED(r->in.type) ? "movz" : "cvt");
        !           274:                        prtype(r);
        !           275:                        putchar('l');
        !           276:                        }
        !           277:                return;
        !           278:                }
        !           279: 
        !           280:        case 'C':       /* num words pushed on arg stack */
        !           281:                {
        !           282:                extern int gc_numbytes;
        !           283:                extern int xdebug;
        !           284: 
        !           285:                if (xdebug) printf("->%d<-",gc_numbytes);
        !           286: 
        !           287:                printf("$%d", gc_numbytes/(SZLONG/SZCHAR) );
        !           288:                return;
        !           289:                }
        !           290: 
        !           291:        case 'D':       /* INCR and DECR */
        !           292:                zzzcode(p->in.left, 'A');
        !           293:                putchar('\n');
        !           294:                putchar('\t');
        !           295: 
        !           296:        case 'E':       /* INCR and DECR, FOREFF */
        !           297:                if (p->in.right->in.op == ICON && p->in.right->tn.lval == 1)
        !           298:                        {
        !           299:                        putstr(p->in.op == INCR ? "inc" : "dec");
        !           300:                        prtype(p->in.left);
        !           301:                        putchar('\t');
        !           302:                        adrput(p->in.left);
        !           303:                        return;
        !           304:                        }
        !           305:                putstr(p->in.op == INCR ? "add" : "sub");
        !           306:                prtype(p->in.left);
        !           307:                putchar('2');
        !           308:                putchar('\t');
        !           309:                adrput(p->in.right);
        !           310:                putchar(',');
        !           311:                adrput(p->in.left);
        !           312:                return;
        !           313: 
        !           314:        case 'F':       /* register type of right operand */
        !           315:                {
        !           316:                register NODE *n;
        !           317:                extern int xdebug;
        !           318:                register int ty;
        !           319: 
        !           320:                n = getlr( p, 'R' );
        !           321:                ty = n->in.type;
        !           322: 
        !           323:                if (xdebug) printf("->%d<-", ty);
        !           324: 
        !           325:                if ( ty==DOUBLE) putchar('d');
        !           326:                else if ( ty==FLOAT ) putchar('f');
        !           327:                else putchar('l');
        !           328:                return;
        !           329:                }
        !           330: 
        !           331:        case 'L':       /* type of left operand */
        !           332:        case 'R':       /* type of right operand */
        !           333:                {
        !           334:                register NODE *n;
        !           335:                extern int xdebug;
        !           336: 
        !           337:                n = getlr( p, c );
        !           338:                if (xdebug) printf("->%d<-", n->in.type);
        !           339: 
        !           340:                prtype(n);
        !           341:                return;
        !           342:                }
        !           343: 
        !           344:        case 'Z':       /* AND for CC with ICON -- lval is complemented */
        !           345:                {
        !           346:                register NODE *l, *r;
        !           347: 
        !           348:                l = getlr( p, 'L' );
        !           349:                r = getlr( p, 'R' );
        !           350:                m = (1 << tlen(l) * SZCHAR) - 1;
        !           351:                r->tn.lval = ~r->tn.lval;
        !           352:                if( (l->in.type == CHAR || l->in.type == SHORT) &&
        !           353:                    (r->tn.lval & ~m) ) {
        !           354:                        putstr("cvt");
        !           355:                        prtype(l);
        !           356:                        putstr("l\t");
        !           357:                        adrput(l);
        !           358:                        putchar(',');
        !           359:                        adrput(resc);
        !           360:                        putstr("\n\t");
        !           361:                        resc->tn.type = INT;
        !           362:                        l = resc;
        !           363:                        }
        !           364:                else if( l->in.type == UCHAR || l->in.type == USHORT )
        !           365:                        /* remove trash left over from complementing */
        !           366:                        r->tn.lval &= m;
        !           367:                putstr("bit");
        !           368:                prtype(l);
        !           369:                printf("\t$%ld", r->tn.lval);
        !           370:                putchar(',');
        !           371:                adrput(l);
        !           372:                return;
        !           373:                }
        !           374: 
        !           375:        case 'U':       /* 32 - n, for unsigned right shifts */
        !           376:                printf("$%d", 32 - p->in.right->tn.lval );
        !           377:                return;
        !           378: 
        !           379:        case 'T':       /* rounded structure length for arguments */
        !           380:                {
        !           381:                int size;
        !           382: 
        !           383:                size = p->stn.stsize;
        !           384:                SETOFF( size, 4);
        !           385:                printf("$%d", size);
        !           386:                return;
        !           387:                }
        !           388: 
        !           389:        case 'S':  /* structure assignment */
        !           390:                stasg(p);
        !           391:                break;
        !           392: 
        !           393:        default:
        !           394:                cerror( "illegal zzzcode" );
        !           395:                }
        !           396:        }
        !           397: 
        !           398: stasg(p)
        !           399:        register NODE *p;
        !           400: {
        !           401:        register NODE *l, *r;
        !           402:        register size;
        !           403: 
        !           404:        if( p->in.op == STASG ){
        !           405:                l = p->in.left;
        !           406:                r = p->in.right;
        !           407: 
        !           408:                }
        !           409:        else if( p->in.op == STARG ){  /* store an arg into a temporary */
        !           410:                r = p->in.left;
        !           411:                }
        !           412:        else cerror( "STASG bad" );
        !           413: 
        !           414:        if( r->in.op == ICON ) r->in.op = NAME;
        !           415:        else if( r->in.op == REG ) r->in.op = OREG;
        !           416:        else if( r->in.op != OREG ) cerror( "STASG-r" );
        !           417: 
        !           418:        size = p->stn.stsize;
        !           419: 
        !           420:        if( size <= 0 || size > 65535 )
        !           421:                cerror("structure size <0=0 or >65535");
        !           422: 
        !           423:        switch(size) {
        !           424:                case 1:
        !           425:                        putstr("        movb    ");
        !           426:                        break;
        !           427:                case 2:
        !           428:                        putstr("        movw    ");
        !           429:                        break;
        !           430:                case 4:
        !           431:                        putstr("        movl    ");
        !           432:                        break;
        !           433:                case 8:
        !           434:                        putstr("        movq    ");
        !           435:                        break;
        !           436:                default:
        !           437:                        printf("        movc3   $%d,", size);
        !           438:                        break;
        !           439:        }
        !           440:        adrput(r);
        !           441:        if( p->in.op == STASG ){
        !           442:                putchar(',');
        !           443:                adrput(l);
        !           444:                putchar('\n');
        !           445:                }
        !           446:        else
        !           447:                putstr(",(sp)\n");
        !           448: 
        !           449:        if( r->in.op == NAME ) r->in.op = ICON;
        !           450:        else if( r->in.op == OREG ) r->in.op = REG;
        !           451:        }
        !           452: 
        !           453: NODE *makearg( ty ) int ty; {
        !           454:        register NODE *p, *q;
        !           455: 
        !           456:        /* build a -(sp) operand */
        !           457:        p = talloc();
        !           458:        p->in.op = REG;
        !           459:        /* the type needn't be right, just consistent */
        !           460:        p->in.type = INCREF(ty);
        !           461:        p->tn.rval = SP;
        !           462:        p->tn.lval = 0;
        !           463:        q = talloc();
        !           464:        q->in.op = ASG MINUS;
        !           465:        q->in.type = INCREF(ty);
        !           466:        q->in.left = p;
        !           467:        p = talloc();
        !           468:        p->in.op = ICON;
        !           469:        p->in.type = INT;
        !           470:        p->tn.name = "";
        !           471:        /* size of floating argument is always 2 */
        !           472:        p->tn.lval = (1 + (ty == FLOAT || ty == DOUBLE)) * (SZINT/SZCHAR);
        !           473:        q->in.right = p;
        !           474:        p = talloc();
        !           475:        p->in.op = UNARY MUL;
        !           476:        p->in.left = q;
        !           477:        return( p );
        !           478:        }
        !           479: 
        !           480: sconv( p, forarg ) register NODE *p; {
        !           481:        register NODE *l, *r;
        !           482:        int m, val;
        !           483: 
        !           484:        if (xdebug) eprint(p, 0, &val, &val);
        !           485:        r = getlr(p, 'R');
        !           486:        if (p->in.op == ASSIGN)
        !           487:                l = getlr(p, 'L');
        !           488:        else if (p->in.op == SCONV) {
        !           489:                m = r->in.type;
        !           490:                if (forarg)
        !           491:                        l = makearg( m );
        !           492:                else
        !           493:                        l = resc;
        !           494:                l->in.type = m;
        !           495:                r = getlr(p, 'L');
        !           496:                }
        !           497:        else {          /* OPLTYPE */
        !           498:                m = (r->in.type==FLOAT || r->in.type==DOUBLE ? r->in.type : INT);
        !           499:                if (forarg)
        !           500:                        l = makearg( m );
        !           501:                else
        !           502:                        l = resc;
        !           503:                l->in.type = m;
        !           504:                }
        !           505:        if (r->in.op == ICON)
        !           506:                if (r->in.name[0] == '\0') {
        !           507:                        if (r->tn.lval == 0 &&
        !           508:                            (r->in.type == DOUBLE || r->in.type == FLOAT ||
        !           509:                            !forarg)) {
        !           510:                                if (r->in.type == FLOAT)
        !           511:                                        r->in.type = DOUBLE;
        !           512:                                putstr("clr");
        !           513:                                prtype(l);
        !           514:                                putchar('\t');
        !           515:                                adrput(l);
        !           516:                                goto cleanup;
        !           517:                                }
        !           518:                        if (r->tn.lval < 0 && r->tn.lval >= -63) {
        !           519:                                putstr("mneg");
        !           520:                                prtype(l);
        !           521:                                r->tn.lval = -r->tn.lval;
        !           522:                                goto ops;
        !           523:                                }
        !           524:                        if (r->tn.lval < 0)
        !           525:                                r->in.type = r->tn.lval >= -128 ? CHAR
        !           526:                                        : (r->tn.lval >= -32768 ? SHORT
        !           527:                                        : INT);
        !           528:                        else if (l->in.type == FLOAT ||
        !           529:                            l->in.type == DOUBLE)
        !           530:                                r->in.type = r->tn.lval <= 63 ? INT
        !           531:                                        : (r->tn.lval <= 127 ? CHAR
        !           532:                                        : (r->tn.lval <= 32767 ? SHORT
        !           533:                                        : INT));
        !           534:                        else
        !           535:                                r->in.type = r->tn.lval <= 63 ? INT
        !           536:                                        : (r->tn.lval <= 127 ? CHAR
        !           537:                                        : (r->tn.lval <= 255 ? UCHAR
        !           538:                                        : (r->tn.lval <= 32767 ? SHORT
        !           539:                                        : (r->tn.lval <= 65535 ? USHORT
        !           540:                                        : INT))));
        !           541:                        if (forarg && r->in.type == INT) {
        !           542:                                putstr("pushl\t");
        !           543:                                adrput(r);
        !           544:                                goto cleanup;
        !           545:                                }
        !           546:                        }
        !           547:                else {
        !           548:                        if (forarg && tlen(r) == SZINT/SZCHAR) {
        !           549:                                putstr("pushl\t");
        !           550:                                adrput(r);
        !           551:                                goto cleanup;
        !           552:                                }
        !           553:                        putstr("moval\t");
        !           554:                        acon(r);
        !           555:                        putchar(',');
        !           556:                        adrput(l);
        !           557:                        goto cleanup;
        !           558:                        }
        !           559: 
        !           560:        if (p->in.op == SCONV &&
        !           561:            !(l->in.type == FLOAT || l->in.type == DOUBLE) &&
        !           562:            !mixtypes(l, r)) {
        !           563:                /*
        !           564:                 * Because registers must always contain objects
        !           565:                 * of the same width as INTs, we may have to
        !           566:                 * perform two conversions to get an INT.  Can
        !           567:                 * the conversions be collapsed into one?
        !           568:                 */
        !           569:                if (m = collapsible(l, r))
        !           570:                        r->in.type = m;
        !           571:                else {
        !           572:                        /* two steps are required */
        !           573:                        NODE *x;
        !           574: 
        !           575:                        if (forarg) {
        !           576:                                x = resc;
        !           577:                                x->in.type = l->in.type;
        !           578:                                }
        !           579:                        else {
        !           580:                                x = &resc[1];
        !           581:                                *x = *l;
        !           582:                                }
        !           583: 
        !           584:                        if (tlen(x) > tlen(r) && ISUNSIGNED(r->in.type))
        !           585:                                putstr("movz");
        !           586:                        else
        !           587:                                putstr("cvt");
        !           588:                        prtype(r);
        !           589:                        prtype(x);
        !           590:                        putchar('\t');
        !           591:                        adrput(r);
        !           592:                        putchar(',');
        !           593:                        adrput(x);
        !           594:                        putchar('\n');
        !           595:                        putchar('\t');
        !           596:                        r = x;
        !           597:                        }
        !           598:                l->in.type = (ISUNSIGNED(l->in.type) ? UNSIGNED : INT);
        !           599:                }
        !           600: 
        !           601:        else if ((forarg || l == resc) &&
        !           602:                 tlen(l) < SZINT/SZCHAR &&
        !           603:                 mixtypes(l, r)) {
        !           604:                /* two steps needed here too */
        !           605:                NODE *x;
        !           606: 
        !           607:                if (forarg) {
        !           608:                        x = resc;
        !           609:                        x->in.type = l->in.type;
        !           610:                        }
        !           611:                else {
        !           612:                        x = &resc[1];
        !           613:                        *x = *l;
        !           614:                        }
        !           615:                putstr("cvt");
        !           616:                prtype(r);
        !           617:                prtype(x);
        !           618:                putchar('\t');
        !           619:                adrput(r);
        !           620:                putchar(',');
        !           621:                adrput(x);
        !           622:                putstr("\n\t");
        !           623:                r = x;
        !           624:                l->in.type = (ISUNSIGNED(l->in.type) ? UNSIGNED : INT);
        !           625:                }
        !           626: 
        !           627:        else if ((r->in.type == UNSIGNED || r->in.type == ULONG) &&
        !           628:            mixtypes(l, r)) {
        !           629:                int label1;
        !           630:                NODE *x = NULL;
        !           631: 
        !           632: #if defined(FORT) || defined(SPRECC)
        !           633:                if (forarg)
        !           634: #else
        !           635:                if (forarg || l == resc)
        !           636: #endif
        !           637:                        {
        !           638:                        /* compute in register, convert to double when done */
        !           639:                        x = l;
        !           640:                        l = resc;
        !           641:                        l->in.type = x->in.type;
        !           642:                        }
        !           643: 
        !           644:                label1 = getlab();
        !           645: 
        !           646:                putstr("cvtl");
        !           647:                prtype(l);
        !           648:                putchar('\t');
        !           649:                adrput(r);
        !           650:                putchar(',');
        !           651:                adrput(l);
        !           652:                printf("\n\tjgeq\tL%d\n\tadd", label1);
        !           653:                prtype(l);
        !           654:                putstr("2\t$0");
        !           655:                prtype(l);
        !           656:                putstr("4.294967296e9,");
        !           657:                adrput(l);
        !           658:                printf("\nL%d:", label1);
        !           659: 
        !           660: #if defined(FORT) || defined(SPRECC)
        !           661:                if (!forarg)
        !           662: #else
        !           663:                if (!forarg && (l->in.type == DOUBLE || l != resc))
        !           664: #endif
        !           665:                        goto cleanup;
        !           666:                if (x == NULL)
        !           667:                        cerror("sconv botch");
        !           668:                if (l == x) {
        !           669:                        r = &resc[1];
        !           670:                        *r = *l;
        !           671:                        }
        !           672:                else {
        !           673:                        r = l;
        !           674:                        l = x;
        !           675:                        }
        !           676:                l->in.type = DOUBLE;
        !           677:                putstr("\n\t");
        !           678:                }
        !           679: 
        !           680:        else if( (l->in.type == FLOAT || l->in.type == DOUBLE) &&
        !           681:            (r->in.type == UCHAR || r->in.type == USHORT) ) {
        !           682:                /* skip unnecessary unsigned to floating conversion */
        !           683: #if defined(FORT) || defined(SPRECC)
        !           684:                if (forarg)
        !           685: #else
        !           686:                if (forarg || l == resc)
        !           687: #endif
        !           688:                        l->in.type = DOUBLE;
        !           689:                putstr("movz");
        !           690:                prtype(r);
        !           691:                putstr("l\t");
        !           692:                adrput(r);
        !           693:                putchar(',');
        !           694:                adrput(resc);
        !           695:                putstr("\n\t");
        !           696:                if (l == resc) {
        !           697:                        r = &resc[1];
        !           698:                        *r = *l;
        !           699:                        }
        !           700:                else
        !           701:                        r = resc;
        !           702:                r->in.type = INT;
        !           703:                }
        !           704: 
        !           705: #if defined(FORT) || defined(SPRECC)
        !           706:        if (forarg && l->in.type == FLOAT)
        !           707: #else
        !           708:        if ((forarg || l == resc) && l->in.type == FLOAT)
        !           709: #endif
        !           710:                {
        !           711:                /* perform an implicit conversion to double */
        !           712:                l->in.type = DOUBLE;
        !           713:                if (r->in.type != FLOAT &&
        !           714:                    r->in.type != CHAR &&
        !           715:                    r->in.type != SHORT) {
        !           716:                        /* trim bits from the mantissa */
        !           717:                        putstr("cvt");
        !           718:                        prtype(r);
        !           719:                        putstr("f\t");
        !           720:                        adrput(r);
        !           721:                        putchar(',');
        !           722:                        adrput(resc);
        !           723:                        putstr("\n\t");
        !           724:                        if (l == resc) {
        !           725:                                r = &resc[1];
        !           726:                                *r = *l;
        !           727:                                }
        !           728:                        else
        !           729:                                r = resc;
        !           730:                        r->in.type = FLOAT;
        !           731:                        }
        !           732:                }
        !           733: 
        !           734:        if (!mixtypes(l,r)) {
        !           735:                if (tlen(l) == tlen(r)) {
        !           736:                        if (forarg && tlen(l) == SZINT/SZCHAR) {
        !           737:                                putstr("pushl\t");
        !           738:                                adrput(r);
        !           739:                                goto cleanup;
        !           740:                                }
        !           741:                        putstr("mov");
        !           742: #ifdef FORT
        !           743:                        if (Oflag)
        !           744:                                prtype(l);
        !           745:                        else {
        !           746:                                if (l->in.type == DOUBLE)
        !           747:                                        putchar('q');
        !           748:                                else if(l->in.type == FLOAT)
        !           749:                                        putchar('l');
        !           750:                                else
        !           751:                                        prtype(l);
        !           752:                                }
        !           753: #else
        !           754:                        prtype(l);
        !           755: #endif FORT
        !           756:                        goto ops;
        !           757:                        }
        !           758:                else if (tlen(l) > tlen(r) && ISUNSIGNED(r->in.type))
        !           759:                        putstr("movz");
        !           760:                else
        !           761:                        putstr("cvt");
        !           762:                }
        !           763:        else
        !           764:                putstr("cvt");
        !           765:        prtype(r);
        !           766:        prtype(l);
        !           767: ops:
        !           768:        putchar('\t');
        !           769:        adrput(r);
        !           770:        putchar(',');
        !           771:        adrput(l);
        !           772: 
        !           773: cleanup:
        !           774:        if (forarg)
        !           775:                tfree(l);
        !           776:        }
        !           777: 
        !           778: /*
        !           779:  * collapsible(dest, src) -- if a conversion with a register destination
        !           780:  *     can be accomplished in one instruction, return the type of src
        !           781:  *     that will do the job correctly; otherwise return 0.  Note that
        !           782:  *     a register must always end up having type INT or UNSIGNED.
        !           783:  */
        !           784: int
        !           785: collapsible(dest, src)
        !           786: NODE *dest, *src;
        !           787: {
        !           788:        int st = src->in.type;
        !           789:        int dt = dest->in.type;
        !           790:        int newt = 0;
        !           791: 
        !           792:        /*
        !           793:         * Are there side effects of evaluating src?
        !           794:         * If the derived type will not be the same size as src,
        !           795:         * we may have to use two steps.
        !           796:         */
        !           797:        if (tlen(src) > tlen(dest)) {
        !           798:                if (tshape(src, STARREG))
        !           799:                        return (0);
        !           800:                if (src->in.op == OREG && R2TEST(src->tn.rval))
        !           801:                        return (0);
        !           802:                }
        !           803: 
        !           804:        /*
        !           805:         * Can we get an object of dest's type by punning src?
        !           806:         * Praises be to great Cthulhu for little-endian machines...
        !           807:         */
        !           808:        if (st == CHAR && dt == USHORT)
        !           809:                /*
        !           810:                 * Special case -- we must sign-extend to 16 bits.
        !           811:                 */
        !           812:                return (0);
        !           813: 
        !           814:        if (tlen(src) < tlen(dest))
        !           815:                newt = st;
        !           816:        else
        !           817:                newt = dt;
        !           818: 
        !           819:        return (newt);
        !           820:        }
        !           821: 
        !           822: rmove( rt, rs, t ) TWORD t; {
        !           823:        printf( "       %s      %s,%s\n",
        !           824: #ifdef FORT
        !           825:                !Oflag ? (t==DOUBLE ? "movq" : "movl") :
        !           826: #endif
        !           827:                (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")),
        !           828:                rnames[rs], rnames[rt] );
        !           829:        }
        !           830: 
        !           831: struct respref
        !           832: respref[] = {
        !           833:        INTAREG|INTBREG,        INTAREG|INTBREG,
        !           834:        INAREG|INBREG,  INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON,
        !           835:        INTEMP, INTEMP,
        !           836:        FORARG, FORARG,
        !           837:        INTEMP, INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM,
        !           838:        0,      0 };
        !           839: 
        !           840: setregs(){ /* set up temporary registers */
        !           841:        fregs = 6;      /* tbl- 6 free regs on VAX (0-5) */
        !           842:        }
        !           843: 
        !           844: /*ARGSUSED*/
        !           845: rewfld( p ) NODE *p; {
        !           846:        return(1);
        !           847:        }
        !           848: 
        !           849: /*ARGSUSED*/
        !           850: callreg(p) NODE *p; {
        !           851:        return( R0 );
        !           852:        }
        !           853: 
        !           854: base( p ) register NODE *p; {
        !           855:        register int o = p->in.op;
        !           856: 
        !           857:        if( o==ICON && p->tn.name[0] != '\0' ) return( 100 ); /* ie no base reg */
        !           858:        if( o==REG ) return( p->tn.rval );
        !           859:     if( (o==PLUS || o==MINUS) && p->in.left->in.op == REG && p->in.right->in.op==ICON)
        !           860:                return( p->in.left->tn.rval );
        !           861:     if( o==OREG && !R2TEST(p->tn.rval) && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) )
        !           862:                return( p->tn.rval + 0200*1 );
        !           863:        if( o==INCR && p->in.left->in.op==REG ) return( p->in.left->tn.rval + 0200*2 );
        !           864:        if( o==ASG MINUS && p->in.left->in.op==REG) return( p->in.left->tn.rval + 0200*4 );
        !           865:        if( o==UNARY MUL && p->in.left->in.op==INCR && p->in.left->in.left->in.op==REG
        !           866:          && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) )
        !           867:                return( p->in.left->in.left->tn.rval + 0200*(1+2) );
        !           868:        if( o==NAME ) return( 100 + 0200*1 );
        !           869:        return( -1 );
        !           870:        }
        !           871: 
        !           872: offset( p, tyl ) register NODE *p; int tyl; {
        !           873: 
        !           874:        if( tyl==1 &&
        !           875:            p->in.op==REG &&
        !           876:            (p->in.type==INT || p->in.type==UNSIGNED) )
        !           877:                return( p->tn.rval );
        !           878:        if( p->in.op==LS &&
        !           879:            p->in.left->in.op==REG &&
        !           880:            (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) &&
        !           881:            p->in.right->in.op==ICON &&
        !           882:            p->in.right->in.name[0]=='\0' &&
        !           883:            (1<<p->in.right->tn.lval)==tyl)
        !           884:                return( p->in.left->tn.rval );
        !           885:        if( tyl==2 &&
        !           886:            p->in.op==PLUS &&
        !           887:            (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) &&
        !           888:            p->in.left->in.op==REG &&
        !           889:            p->in.right->in.op==REG &&
        !           890:            p->in.left->tn.rval==p->in.right->tn.rval )
        !           891:                return( p->in.left->tn.rval );
        !           892:        return( -1 );
        !           893:        }
        !           894: 
        !           895: makeor2( p, q, b, o) register NODE *p, *q; register int b, o; {
        !           896:        register NODE *t;
        !           897:        NODE *f;
        !           898: 
        !           899:        p->in.op = OREG;
        !           900:        f = p->in.left;         /* have to free this subtree later */
        !           901: 
        !           902:        /* init base */
        !           903:        switch (q->in.op) {
        !           904:                case ICON:
        !           905:                case REG:
        !           906:                case OREG:
        !           907:                case NAME:
        !           908:                        t = q;
        !           909:                        break;
        !           910: 
        !           911:                case MINUS:
        !           912:                        q->in.right->tn.lval = -q->in.right->tn.lval;
        !           913:                case PLUS:
        !           914:                        t = q->in.right;
        !           915:                        break;
        !           916: 
        !           917:                case INCR:
        !           918:                case ASG MINUS:
        !           919:                        t = q->in.left;
        !           920:                        break;
        !           921: 
        !           922:                case UNARY MUL:
        !           923:                        t = q->in.left->in.left;
        !           924:                        break;
        !           925: 
        !           926:                default:
        !           927:                        cerror("illegal makeor2");
        !           928:        }
        !           929: 
        !           930:        p->tn.lval = t->tn.lval;
        !           931: #ifndef FLEXNAMES
        !           932:        {
        !           933:                register int i;
        !           934:                for(i=0; i<NCHNAM; ++i)
        !           935:                        p->in.name[i] = t->in.name[i];
        !           936:        }
        !           937: #else
        !           938:        p->in.name = t->in.name;
        !           939: #endif
        !           940: 
        !           941:        /* init offset */
        !           942:        p->tn.rval = R2PACK( (b & 0177), o, (b>>7) );
        !           943: 
        !           944:        tfree(f);
        !           945:        return;
        !           946:        }
        !           947: 
        !           948: canaddr( p ) NODE *p; {
        !           949:        register int o = p->in.op;
        !           950: 
        !           951:        if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1);
        !           952:        return(0);
        !           953:        }
        !           954: 
        !           955: flshape( p ) NODE *p; {
        !           956:        register int o = p->in.op;
        !           957: 
        !           958:        return( o == REG || o == NAME || o == ICON ||
        !           959:                (o == OREG && (!R2TEST(p->tn.rval) || tlen(p) == 1)) );
        !           960:        }
        !           961: 
        !           962: /* INTEMP shapes must not contain any temporary registers */
        !           963: shtemp( p ) register NODE *p; {
        !           964:        int r;
        !           965: 
        !           966:        if( p->in.op == STARG ) p = p->in.left;
        !           967: 
        !           968:        switch (p->in.op) {
        !           969:        case REG:
        !           970:                return( !istreg(p->tn.rval) );
        !           971:        case OREG:
        !           972:                r = p->tn.rval;
        !           973:                if( R2TEST(r) ) {
        !           974:                        if( istreg(R2UPK1(r)) )
        !           975:                                return(0);
        !           976:                        r = R2UPK2(r);
        !           977:                        }
        !           978:                return( !istreg(r) );
        !           979:        case UNARY MUL:
        !           980:                p = p->in.left;
        !           981:                return( p->in.op != UNARY MUL && shtemp(p) );
        !           982:                }
        !           983: 
        !           984:        if( optype( p->in.op ) != LTYPE ) return(0);
        !           985:        return(1);
        !           986:        }
        !           987: 
        !           988: shumul( p ) register NODE *p; {
        !           989:        register int o;
        !           990:        extern int xdebug;
        !           991: 
        !           992:        if (xdebug) {
        !           993:                int val;
        !           994:                printf("shumul:\n");
        !           995:                eprint(p, 0, &val, &val);
        !           996:                }
        !           997: 
        !           998:        o = p->in.op;
        !           999:        if( o == NAME || (o == OREG && !R2TEST(p->tn.rval)) || o == ICON ) return( STARNM );
        !          1000: 
        !          1001:        if( ( o == INCR || o == ASG MINUS ) &&
        !          1002:            ( p->in.left->in.op == REG && p->in.right->in.op == ICON ) &&
        !          1003:            p->in.right->in.name[0] == '\0' )
        !          1004:                {
        !          1005:                switch (p->in.type)
        !          1006:                        {
        !          1007:                        case CHAR|PTR:
        !          1008:                        case UCHAR|PTR:
        !          1009:                                o = 1;
        !          1010:                                break;
        !          1011: 
        !          1012:                        case SHORT|PTR:
        !          1013:                        case USHORT|PTR:
        !          1014:                                o = 2;
        !          1015:                                break;
        !          1016: 
        !          1017:                        case INT|PTR:
        !          1018:                        case UNSIGNED|PTR:
        !          1019:                        case LONG|PTR:
        !          1020:                        case ULONG|PTR:
        !          1021:                        case FLOAT|PTR:
        !          1022:                                o = 4;
        !          1023:                                break;
        !          1024: 
        !          1025:                        case DOUBLE|PTR:
        !          1026:                                o = 8;
        !          1027:                                break;
        !          1028: 
        !          1029:                        default:
        !          1030:                                if ( ISPTR(p->in.type) &&
        !          1031:                                     ISPTR(DECREF(p->in.type)) ) {
        !          1032:                                        o = 4;
        !          1033:                                        break;
        !          1034:                                        }
        !          1035:                                else return(0);
        !          1036:                        }
        !          1037:                return( p->in.right->tn.lval == o ? STARREG : 0);
        !          1038:                }
        !          1039: 
        !          1040:        return( 0 );
        !          1041:        }
        !          1042: 
        !          1043: adrcon( val ) CONSZ val; {
        !          1044:        putchar( '$' );
        !          1045:        printf( CONFMT, val );
        !          1046:        }
        !          1047: 
        !          1048: conput( p ) register NODE *p; {
        !          1049:        switch( p->in.op ){
        !          1050: 
        !          1051:        case ICON:
        !          1052:                acon( p );
        !          1053:                return;
        !          1054: 
        !          1055:        case REG:
        !          1056:                putstr( rnames[p->tn.rval] );
        !          1057:                return;
        !          1058: 
        !          1059:        default:
        !          1060:                cerror( "illegal conput" );
        !          1061:                }
        !          1062:        }
        !          1063: 
        !          1064: /*ARGSUSED*/
        !          1065: insput( p ) NODE *p; {
        !          1066:        cerror( "insput" );
        !          1067:        }
        !          1068: 
        !          1069: upput( p, size ) NODE *p; int size; {
        !          1070:        if( size == SZLONG && p->in.op == REG ) {
        !          1071:                putstr( rnames[p->tn.rval + 1] );
        !          1072:                return;
        !          1073:                }
        !          1074:        cerror( "upput" );
        !          1075:        }
        !          1076: 
        !          1077: adrput( p ) register NODE *p; {
        !          1078:        register int r;
        !          1079:        /* output an address, with offsets, from p */
        !          1080: 
        !          1081:        if( p->in.op == FLD ){
        !          1082:                p = p->in.left;
        !          1083:                }
        !          1084:        switch( p->in.op ){
        !          1085: 
        !          1086:        case NAME:
        !          1087:                acon( p );
        !          1088:                return;
        !          1089: 
        !          1090:        case ICON:
        !          1091:                /* addressable value of the constant */
        !          1092:                putchar( '$' );
        !          1093:                acon( p );
        !          1094:                return;
        !          1095: 
        !          1096:        case REG:
        !          1097:                putstr( rnames[p->tn.rval] );
        !          1098:                return;
        !          1099: 
        !          1100:        case OREG:
        !          1101:                r = p->tn.rval;
        !          1102:                if( R2TEST(r) ){ /* double indexing */
        !          1103:                        register int flags;
        !          1104: 
        !          1105:                        flags = R2UPK3(r);
        !          1106:                        if( flags & 1 ) putchar('*');
        !          1107:                        if( flags & 4 ) putchar('-');
        !          1108:                        if( p->tn.lval != 0 || p->in.name[0] != '\0' ) acon(p);
        !          1109:                        if( R2UPK1(r) != 100) printf( "(%s)", rnames[R2UPK1(r)] );
        !          1110:                        if( flags & 2 ) putchar('+');
        !          1111:                        printf( "[%s]", rnames[R2UPK2(r)] );
        !          1112:                        return;
        !          1113:                        }
        !          1114:                if( r == AP ){  /* in the argument region */
        !          1115:                        if( p->in.name[0] != '\0' ) werror( "bad arg temp" );
        !          1116:                        printf( CONFMT, p->tn.lval );
        !          1117:                        putstr( "(ap)" );
        !          1118:                        return;
        !          1119:                        }
        !          1120:                if( p->tn.lval != 0 || p->in.name[0] != '\0') acon( p );
        !          1121:                printf( "(%s)", rnames[p->tn.rval] );
        !          1122:                return;
        !          1123: 
        !          1124:        case UNARY MUL:
        !          1125:                /* STARNM or STARREG found */
        !          1126:                if( tshape(p, STARNM) ) {
        !          1127:                        putchar( '*' );
        !          1128:                        adrput( p->in.left);
        !          1129:                        }
        !          1130:                else {  /* STARREG - really auto inc or dec */
        !          1131:                        register NODE *q;
        !          1132: 
        !          1133:                        q = p->in.left;
        !          1134:                        if( q->in.right->tn.lval != tlen(p) )
        !          1135:                                cerror("adrput: bad auto-increment/decrement");
        !          1136:                        printf("%s(%s)%s", (q->in.op==INCR ? "" : "-"),
        !          1137:                                rnames[q->in.left->tn.rval], 
        !          1138:                                (q->in.op==INCR ? "+" : "") );
        !          1139:                        p->in.op = OREG;
        !          1140:                        p->tn.rval = q->in.left->tn.rval;
        !          1141:                        p->tn.lval = (q->in.op == INCR ? -q->in.right->tn.lval : 0);
        !          1142: #ifndef FLEXNAMES
        !          1143:                        p->in.name[0] = '\0';
        !          1144: #else
        !          1145:                        p->in.name = "";
        !          1146: #endif
        !          1147:                        tfree(q);
        !          1148:                }
        !          1149:                return;
        !          1150: 
        !          1151:        default:
        !          1152:                cerror( "illegal address" );
        !          1153:                return;
        !          1154: 
        !          1155:                }
        !          1156: 
        !          1157:        }
        !          1158: 
        !          1159: acon( p ) register NODE *p; { /* print out a constant */
        !          1160: 
        !          1161:        if( p->in.name[0] == '\0' )
        !          1162:                printf( CONFMT, p->tn.lval);
        !          1163:        else {
        !          1164: #ifndef FLEXNAMES
        !          1165:                printf( "%.8s", p->in.name );
        !          1166: #else
        !          1167:                putstr( p->in.name );
        !          1168: #endif
        !          1169:                if( p->tn.lval != 0 ) {
        !          1170:                        putchar( '+' );
        !          1171:                        printf( CONFMT, p->tn.lval );
        !          1172:                        }
        !          1173:                }
        !          1174:        }
        !          1175: 
        !          1176: genscall( p, cookie ) register NODE *p; {
        !          1177:        /* structure valued call */
        !          1178:        return( gencall( p, cookie ) );
        !          1179:        }
        !          1180: 
        !          1181: /* tbl */
        !          1182: int gc_numbytes;
        !          1183: /* tbl */
        !          1184: 
        !          1185: /*ARGSUSED*/
        !          1186: gencall( p, cookie ) register NODE *p; {
        !          1187:        /* generate the call given by p */
        !          1188:        register NODE *p1;
        !          1189:        register int temp, temp1;
        !          1190:        register int m;
        !          1191: 
        !          1192:        if( p->in.right ) temp = argsize( p->in.right );
        !          1193:        else temp = 0;
        !          1194: 
        !          1195:        if( p->in.op == STCALL || p->in.op == UNARY STCALL ){
        !          1196:                /* set aside room for structure return */
        !          1197: 
        !          1198:                if( p->stn.stsize > temp ) temp1 = p->stn.stsize;
        !          1199:                else temp1 = temp;
        !          1200:                }
        !          1201: 
        !          1202:        if( temp > maxargs ) maxargs = temp;
        !          1203:        SETOFF(temp1,4);
        !          1204: 
        !          1205:        if( p->in.right ){ /* make temp node, put offset in, and generate args */
        !          1206:                genargs( p->in.right );
        !          1207:                }
        !          1208: 
        !          1209:        p1 = p->in.left;
        !          1210:        if( p1->in.op != ICON ){
        !          1211:                if( p1->in.op != REG ){
        !          1212:                        if( p1->in.op != OREG || R2TEST(p1->tn.rval) ){
        !          1213:                                if( p1->in.op != NAME ){
        !          1214:                                        order( p1, INAREG );
        !          1215:                                        }
        !          1216:                                }
        !          1217:                        }
        !          1218:                }
        !          1219: 
        !          1220: /* tbl
        !          1221:        setup gc_numbytes so reference to ZC works */
        !          1222: 
        !          1223:        gc_numbytes = temp&(0x3ff);
        !          1224: /* tbl */
        !          1225: 
        !          1226:        p->in.op = UNARY CALL;
        !          1227:        m = match( p, INTAREG|INTBREG );
        !          1228: 
        !          1229:        /* compensate for deficiency in 'ret' instruction ... wah,kre */
        !          1230:        /* (plus in assignment to gc_numbytes above, for neatness only) */
        !          1231:        if (temp >= 1024)
        !          1232:                printf("        addl2   $%d,sp\n", (temp&(~0x3ff)));
        !          1233: 
        !          1234:        return(m != MDONE);
        !          1235:        }
        !          1236: 
        !          1237: /* tbl */
        !          1238: char *
        !          1239: ccbranches[] = {
        !          1240:        "eql",
        !          1241:        "neq",
        !          1242:        "leq",
        !          1243:        "lss",
        !          1244:        "geq",
        !          1245:        "gtr",
        !          1246:        "lequ",
        !          1247:        "lssu",
        !          1248:        "gequ",
        !          1249:        "gtru",
        !          1250:        };
        !          1251: /* tbl */
        !          1252: 
        !          1253: /*ARGSUSED*/
        !          1254: cbgen( o, lab, mode ) { /*   printf conditional and unconditional branches */
        !          1255: 
        !          1256:        if( o != 0 && ( o < EQ || o > UGT ) )
        !          1257:                cerror( "bad conditional branch: %s", opst[o] );
        !          1258:        printf( "       j%s     L%d\n", o == 0 ? "br" : ccbranches[o-EQ], lab );
        !          1259:        }
        !          1260: 
        !          1261: nextcook( p, cookie ) NODE *p; {
        !          1262:        /* we have failed to match p with cookie; try another */
        !          1263:        if( cookie == FORREW ) return( 0 );  /* hopeless! */
        !          1264:        if( !(cookie&(INTAREG|INTBREG)) ) return( INTAREG|INTBREG );
        !          1265:        if( !(cookie&INTEMP) && asgop(p->in.op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG );
        !          1266:        return( FORREW );
        !          1267:        }
        !          1268: 
        !          1269: /*ARGSUSED*/
        !          1270: lastchance( p, cook ) NODE *p; {
        !          1271:        /* forget it! */
        !          1272:        return(0);
        !          1273:        }
        !          1274: 
        !          1275: optim2( p ) register NODE *p; {
        !          1276:        /* do local tree transformations and optimizations */
        !          1277: 
        !          1278:        int o;
        !          1279:        int i, mask;
        !          1280:        register NODE *l, *r;
        !          1281: 
        !          1282:        switch( o = p->in.op ) {
        !          1283: 
        !          1284:        case ASG PLUS:
        !          1285:        case ASG MINUS:
        !          1286:        case ASG MUL:
        !          1287:        case ASG OR:
        !          1288:                /* simple ASG OPSIMP -- reduce range of constant rhs */
        !          1289:                l = p->in.left;
        !          1290:                r = p->in.right;
        !          1291:                if( tlen(l) < SZINT/SZCHAR &&
        !          1292:                    r->in.op==ICON && r->in.name[0]==0 ){
        !          1293:                        mask = (1 << tlen(l) * SZCHAR) - 1;
        !          1294:                        if( r->tn.lval & (mask & ~(mask >> 1)) )
        !          1295:                                r->tn.lval |= ~mask;
        !          1296:                        else
        !          1297:                                r->tn.lval &= mask;
        !          1298:                        }
        !          1299:                break;
        !          1300: 
        !          1301:        case AND:
        !          1302:                /* commute L and R to eliminate complements and constants */
        !          1303:                if( (l = p->in.left)->in.op == ICON && l->in.name[0] == 0 ||
        !          1304:                    l->in.op == COMPL ) {
        !          1305:                        p->in.left = p->in.right;
        !          1306:                        p->in.right = l;
        !          1307:                        }
        !          1308:                /* fall through */
        !          1309: 
        !          1310:        case ASG AND:
        !          1311:                /* change meaning of AND to ~R&L - bic on pdp11/vax */
        !          1312:                r = p->in.right;
        !          1313:                if( r->in.op==ICON && r->in.name[0]==0 ) {
        !          1314:                        /* check for degenerate operations */
        !          1315:                        l = p->in.left;
        !          1316:                        mask = (1 << tlen(l) * SZCHAR) - 1;
        !          1317:                        if( o == ASG AND || ISUNSIGNED(r->in.type) ) {
        !          1318:                                i = ~r->tn.lval & mask;
        !          1319:                                if( i == 0 ) {
        !          1320:                                        /* redundant mask */
        !          1321:                                        r->in.op = FREE;
        !          1322:                                        ncopy(p, l);
        !          1323:                                        l->in.op = FREE;
        !          1324:                                        break;
        !          1325:                                        }
        !          1326:                                else if( i == mask )
        !          1327:                                        /* all bits masked off */
        !          1328:                                        goto zero;
        !          1329:                                r->tn.lval = i;
        !          1330:                                if( tlen(l) < SZINT/SZCHAR ){
        !          1331:                                        /* sign extend */
        !          1332:                                        if( r->tn.lval & (mask & ~(mask >> 1)) )
        !          1333:                                                r->tn.lval |= ~mask;
        !          1334:                                        else
        !          1335:                                                r->tn.lval &= mask;
        !          1336:                                        }
        !          1337:                                break;
        !          1338:                                }
        !          1339:                        else if( r->tn.lval == mask &&
        !          1340:                                 tlen(l) < SZINT/SZCHAR ) {
        !          1341:                                /* use movz instead of bic */
        !          1342:                                r->in.op = SCONV;
        !          1343:                                r->in.left = l;
        !          1344:                                r->in.right = 0;
        !          1345:                                r->in.type = ENUNSIGN(l->in.type);
        !          1346:                                r->in.su = l->in.su > 1 ? l->in.su : 1;
        !          1347:                                ncopy(p, r);
        !          1348:                                p->in.left = r;
        !          1349:                                p->in.type = INT;
        !          1350:                                break;
        !          1351:                                }
        !          1352:                        /* complement constant */
        !          1353:                        r->tn.lval = ~r->tn.lval;
        !          1354:                        }
        !          1355:                else if( r->in.op==COMPL ) { /* ~~A => A */
        !          1356:                        r->in.op = FREE;
        !          1357:                        p->in.right = r->in.left;
        !          1358:                        }
        !          1359:                else { /* insert complement node */
        !          1360:                        p->in.right = l = talloc();
        !          1361:                        l->in.op = COMPL;
        !          1362:                        l->in.rall = NOPREF;
        !          1363:                        l->in.type = r->in.type;
        !          1364:                        l->in.left = r;
        !          1365:                        l->in.right = NULL;
        !          1366:                        }
        !          1367:                break;
        !          1368: 
        !          1369:        case SCONV:
        !          1370:                l = p->in.left;
        !          1371: #if defined(FORT) || defined(SPRECC)
        !          1372:                if( p->in.type == FLOAT || p->in.type == DOUBLE ||
        !          1373:                    l->in.type == FLOAT || l->in.type == DOUBLE )
        !          1374:                        return;
        !          1375: #else
        !          1376:                if( mixtypes(p, l) ) return;
        !          1377: #endif
        !          1378:                if( l->in.op == PCONV )
        !          1379:                        return;
        !          1380:                if( (l->in.op == CALL || l->in.op == UNARY CALL) &&
        !          1381:                    l->in.type != INT && l->in.type != UNSIGNED )
        !          1382:                        return;
        !          1383: 
        !          1384:                /* Only trust it to get it right if the size is the same */
        !          1385:                if( tlen(p) != tlen(l) )
        !          1386:                        return;
        !          1387: 
        !          1388:                /* clobber conversion */
        !          1389:                if( l->in.op != FLD )
        !          1390:                        l->in.type = p->in.type;
        !          1391:                ncopy( p, l );
        !          1392:                l->in.op = FREE;
        !          1393: 
        !          1394:                break;
        !          1395: 
        !          1396:        case ASSIGN:
        !          1397:                /*
        !          1398:                 * Conversions are equivalent to assignments;
        !          1399:                 * when the two operations are combined,
        !          1400:                 * we can sometimes zap the conversion.
        !          1401:                 */
        !          1402:                r = p->in.right;
        !          1403:                l = p->in.left;
        !          1404:                if ( r->in.op == SCONV &&
        !          1405:                     !mixtypes(l, r) &&
        !          1406:                     l->in.op != FLD &&
        !          1407:                     tlen(l) == tlen(r) ) {
        !          1408:                                p->in.right = r->in.left;
        !          1409:                                r->in.op = FREE;
        !          1410:                        }
        !          1411:                break;
        !          1412: 
        !          1413:        case ULE:
        !          1414:        case ULT:
        !          1415:        case UGE:
        !          1416:        case UGT:
        !          1417:                p->in.op -= (UGE-GE);
        !          1418:                if( degenerate(p) )
        !          1419:                        break;
        !          1420:                p->in.op += (UGE-GE);
        !          1421:                break;
        !          1422: 
        !          1423:        case EQ:
        !          1424:        case NE:
        !          1425:        case LE:
        !          1426:        case LT:
        !          1427:        case GE:
        !          1428:        case GT:
        !          1429:                if( p->in.left->in.op == SCONV &&
        !          1430:                    p->in.right->in.op == SCONV ) {
        !          1431:                        l = p->in.left;
        !          1432:                        r = p->in.right;
        !          1433:                        if( l->in.type == DOUBLE &&
        !          1434:                            l->in.left->in.type == FLOAT &&
        !          1435:                            r->in.left->in.type == FLOAT ) {
        !          1436:                                /* nuke the conversions */
        !          1437:                                p->in.left = l->in.left;
        !          1438:                                p->in.right = r->in.left;
        !          1439:                                l->in.op = FREE;
        !          1440:                                r->in.op = FREE;
        !          1441:                                }
        !          1442:                        /* more? */
        !          1443:                        }
        !          1444:                (void) degenerate(p);
        !          1445:                break;
        !          1446: 
        !          1447:        case DIV:
        !          1448:                if( p->in.right->in.op == ICON &&
        !          1449:                    p->in.right->tn.name[0] == '\0' &&
        !          1450:                    ISUNSIGNED(p->in.right->in.type) &&
        !          1451:                    (unsigned) p->in.right->tn.lval >= 0x80000000 ) {
        !          1452:                        /* easy to do here, harder to do in zzzcode() */
        !          1453:                        p->in.op = UGE;
        !          1454:                        break;
        !          1455:                        }
        !          1456:        case MOD:
        !          1457:        case ASG DIV:
        !          1458:        case ASG MOD:
        !          1459:                /*
        !          1460:                 * optimize DIV and MOD
        !          1461:                 *
        !          1462:                 * basically we spot UCHAR and USHORT and try to do them
        !          1463:                 * as signed ints...  apparently div+mul+sub is always
        !          1464:                 * faster than ediv for finding MOD on the VAX, when
        !          1465:                 * full unsigned MOD isn't needed.
        !          1466:                 *
        !          1467:                 * a curious fact: for MOD, cmp+sub and cmp+sub+cmp+sub
        !          1468:                 * are faster for unsigned dividend and a constant divisor
        !          1469:                 * in the right range (.5 to 1 of dividend's range for the
        !          1470:                 * first, .333+ to .5 for the second).  full unsigned is
        !          1471:                 * already done cmp+sub in the appropriate case; the
        !          1472:                 * other cases are less common and require more ambition.
        !          1473:                 */
        !          1474:                if( degenerate(p) )
        !          1475:                        break;
        !          1476:                l = p->in.left;
        !          1477:                r = p->in.right;
        !          1478:                if( !ISUNSIGNED(r->in.type) ||
        !          1479:                    tlen(l) >= SZINT/SZCHAR ||
        !          1480:                    !(tlen(r) < SZINT/SZCHAR ||
        !          1481:                      (r->in.op == ICON && r->tn.name[0] == '\0')) )
        !          1482:                        break;
        !          1483:                if( r->in.op == ICON )
        !          1484:                        r->tn.type = INT;
        !          1485:                else {
        !          1486:                        NODE *t = talloc();
        !          1487:                        t->in.left = r;
        !          1488:                        r = t;
        !          1489:                        r->in.op = SCONV;
        !          1490:                        r->in.type = INT;
        !          1491:                        r->in.right = 0;
        !          1492:                        p->in.right = r;
        !          1493:                        }
        !          1494:                if( o == DIV || o == MOD ) {
        !          1495:                        NODE *t = talloc();
        !          1496:                        t->in.left = l;
        !          1497:                        l = t;
        !          1498:                        l->in.op = SCONV;
        !          1499:                        l->in.type = INT;
        !          1500:                        l->in.right = 0;
        !          1501:                        p->in.left = l;
        !          1502:                        }
        !          1503:                /* handle asgops in table */
        !          1504:                break;
        !          1505: 
        !          1506:        case RS:
        !          1507:        case ASG RS:
        !          1508:        case LS:
        !          1509:        case ASG LS:
        !          1510:                /* pick up degenerate shifts */
        !          1511:                l = p->in.left;
        !          1512:                r = p->in.right;
        !          1513:                if( !(r->in.op == ICON && r->tn.name[0] == '\0') )
        !          1514:                        break;
        !          1515:                i = r->tn.lval;
        !          1516:                if( i < 0 )
        !          1517:                        /* front end 'fixes' this? */
        !          1518:                        if( o == LS || o == ASG LS )
        !          1519:                                o += (RS-LS);
        !          1520:                        else
        !          1521:                                o += (LS-RS);
        !          1522:                if( (o == RS || o == ASG RS) &&
        !          1523:                    !ISUNSIGNED(l->in.type) )
        !          1524:                        /* can't optimize signed right shifts */
        !          1525:                        break;
        !          1526:                if( o == LS ) {
        !          1527:                        if( i < SZINT )
        !          1528:                                break;
        !          1529:                        }
        !          1530:                else {
        !          1531:                        if( i < tlen(l) * SZCHAR )
        !          1532:                                break;
        !          1533:                        }
        !          1534:        zero:
        !          1535:                if( !asgop( o ) )
        !          1536:                        if( tshape(l, SAREG|SNAME|SCON|SOREG|STARNM) ) {
        !          1537:                                /* no side effects */
        !          1538:                                tfree(l);
        !          1539:                                ncopy(p, r);
        !          1540:                                r->in.op = FREE;
        !          1541:                                p->tn.lval = 0;
        !          1542:                                }
        !          1543:                        else {
        !          1544:                                p->in.op = COMOP;
        !          1545:                                r->tn.lval = 0;
        !          1546:                                }
        !          1547:                else {
        !          1548:                        p->in.op = ASSIGN;
        !          1549:                        r->tn.lval = 0;
        !          1550:                        }
        !          1551:                break;
        !          1552:                }
        !          1553:        }
        !          1554: 
        !          1555: degenerate(p) register NODE *p; {
        !          1556:        int o;
        !          1557:        int result, i;
        !          1558:        int lower, upper;
        !          1559:        register NODE *l, *r;
        !          1560: 
        !          1561:        /*
        !          1562:         * try to keep degenerate comparisons with constants
        !          1563:         * out of the table.
        !          1564:         */
        !          1565:        r = p->in.right;
        !          1566:        l = p->in.left;
        !          1567:        if( r->in.op != ICON ||
        !          1568:            r->tn.name[0] != '\0' ||
        !          1569:            tlen(l) >= tlen(r) )
        !          1570:                return (0);
        !          1571:        switch( l->in.type ) {
        !          1572:        case CHAR:
        !          1573:                lower = -(1 << SZCHAR - 1);
        !          1574:                upper = (1 << SZCHAR - 1) - 1;
        !          1575:                break;
        !          1576:        case UCHAR:
        !          1577:                lower = 0;
        !          1578:                upper = (1 << SZCHAR) - 1;
        !          1579:                break;
        !          1580:        case SHORT:
        !          1581:                lower = -(1 << SZSHORT - 1);
        !          1582:                upper = (1 << SZSHORT - 1) - 1;
        !          1583:                break;
        !          1584:        case USHORT:
        !          1585:                lower = 0;
        !          1586:                upper = (1 << SZSHORT) - 1;
        !          1587:                break;
        !          1588:        default:
        !          1589:                cerror("unsupported type in degenerate()");
        !          1590:                }
        !          1591:        i = r->tn.lval;
        !          1592:        switch( o = p->in.op ) {
        !          1593:        case DIV:
        !          1594:        case ASG DIV:
        !          1595:        case MOD:
        !          1596:        case ASG MOD:
        !          1597:                /* DIV and MOD work like EQ */
        !          1598:        case EQ:
        !          1599:        case NE:
        !          1600:                if( lower == 0 && (unsigned) i > upper )
        !          1601:                        result = o == NE;
        !          1602:                else if( i < lower || i > upper )
        !          1603:                        result = o == NE;
        !          1604:                else
        !          1605:                        return (0);
        !          1606:                break;
        !          1607:        case LT:
        !          1608:        case GE:
        !          1609:                if( lower == 0 && (unsigned) i > upper )
        !          1610:                        result = o == LT;
        !          1611:                else if( i <= lower )
        !          1612:                        result = o != LT;
        !          1613:                else if( i > upper )
        !          1614:                        result = o == LT;
        !          1615:                else
        !          1616:                        return (0);
        !          1617:                break;
        !          1618:        case LE:
        !          1619:        case GT:
        !          1620:                if( lower == 0 && (unsigned) i >= upper )
        !          1621:                        result = o == LE;
        !          1622:                else if( i < lower )
        !          1623:                        result = o != LE;
        !          1624:                else if( i >= upper )
        !          1625:                        result = o == LE;
        !          1626:                else
        !          1627:                        return (0);
        !          1628:                break;
        !          1629:        default:
        !          1630:                cerror("unknown op in degenerate()");
        !          1631:                }
        !          1632:                
        !          1633:        if( o == MOD || o == ASG MOD ) {
        !          1634:                r->in.op = FREE;
        !          1635:                ncopy(p, l);
        !          1636:                l->in.op = FREE;
        !          1637:                }
        !          1638:        else if( o != ASG DIV && tshape(l, SAREG|SNAME|SCON|SOREG|STARNM) ) {
        !          1639:                /* no side effects */
        !          1640:                tfree(l);
        !          1641:                ncopy(p, r);
        !          1642:                r->in.op = FREE;
        !          1643:                p->tn.lval = result;
        !          1644:                }
        !          1645:        else {
        !          1646:                if( o == ASG DIV )
        !          1647:                        p->in.op = ASSIGN;
        !          1648:                else {
        !          1649:                        p->in.op = COMOP;
        !          1650:                        r->tn.type = INT;
        !          1651:                        }
        !          1652:                r->tn.lval = result;
        !          1653:                }
        !          1654:        if( logop(o) )
        !          1655:                p->in.type = INT;
        !          1656: 
        !          1657:        return (1);
        !          1658:        }
        !          1659: 
        !          1660: /* added by jwf */
        !          1661: struct functbl {
        !          1662:        int fop;
        !          1663:        TWORD ftype;
        !          1664:        char *func;
        !          1665:        } opfunc[] = {
        !          1666:        DIV,            TANY,   "udiv",
        !          1667:        MOD,            TANY,   "urem",
        !          1668:        ASG DIV,        TANY,   "audiv",
        !          1669:        ASG MOD,        TANY,   "aurem",
        !          1670:        0,      0,      0 };
        !          1671: 
        !          1672: hardops(p)  register NODE *p; {
        !          1673:        /* change hard to do operators into function calls.  */
        !          1674:        register NODE *q;
        !          1675:        register struct functbl *f;
        !          1676:        register o;
        !          1677:        NODE *old,*temp;
        !          1678: 
        !          1679:        o = p->in.op;
        !          1680:        if( ! (optype(o)==BITYPE &&
        !          1681:               (ISUNSIGNED(p->in.left->in.type) ||
        !          1682:                ISUNSIGNED(p->in.right->in.type))) )
        !          1683:                return;
        !          1684: 
        !          1685:        for( f=opfunc; f->fop; f++ ) {
        !          1686:                if( o==f->fop ) goto convert;
        !          1687:                }
        !          1688:        return;
        !          1689: 
        !          1690:        convert:
        !          1691:        if( p->in.right->in.op == ICON && p->in.right->tn.name[0] == '\0' )
        !          1692:                /* 'J', 'K' in zzzcode() -- assumes DIV or MOD operations */
        !          1693:                /* save a subroutine call -- use at most 5 instructions */
        !          1694:                return;
        !          1695:        if( tlen(p->in.left) < SZINT/SZCHAR && tlen(p->in.right) < SZINT/SZCHAR )
        !          1696:                /* optim2() will modify the op into an ordinary int op */
        !          1697:                return;
        !          1698:        if( asgop( o ) ) {
        !          1699:                old = NIL;
        !          1700:                switch( p->in.left->in.op ){
        !          1701:                case FLD:
        !          1702:                        q = p->in.left->in.left;
        !          1703:                        /*
        !          1704:                         * rewrite (lval.fld /= rval); as
        !          1705:                         *  ((*temp).fld = udiv((*(temp = &lval)).fld,rval));
        !          1706:                         * else the compiler will evaluate lval twice.
        !          1707:                         */
        !          1708:                        if( q->in.op == UNARY MUL ){
        !          1709:                                /* first allocate a temp storage */
        !          1710:                                temp = talloc();
        !          1711:                                temp->in.op = OREG;
        !          1712:                                temp->tn.rval = TMPREG;
        !          1713:                                temp->tn.lval = BITOOR(freetemp(1));
        !          1714:                                temp->in.type = INCREF(p->in.type);
        !          1715: #ifdef FLEXNAMES
        !          1716:                                temp->in.name = "";
        !          1717: #else
        !          1718:                                temp->in.name[0] = '\0';
        !          1719: #endif
        !          1720:                                old = q->in.left;
        !          1721:                                q->in.left = temp;
        !          1722:                        }
        !          1723:                        /* fall thru ... */
        !          1724: 
        !          1725:                case REG:
        !          1726:                case NAME:
        !          1727:                case OREG:
        !          1728:                        /* change ASG OP to a simple OP */
        !          1729:                        q = talloc();
        !          1730:                        q->in.op = NOASG p->in.op;
        !          1731:                        q->in.rall = NOPREF;
        !          1732:                        q->in.type = p->in.type;
        !          1733:                        q->in.left = tcopy(p->in.left);
        !          1734:                        q->in.right = p->in.right;
        !          1735:                        p->in.op = ASSIGN;
        !          1736:                        p->in.right = q;
        !          1737:                        p = q;
        !          1738:                        f -= 2; /* Note: this depends on the table order */
        !          1739:                        /* on the right side only - replace *temp with
        !          1740:                         *(temp = &lval), build the assignment node */
        !          1741:                        if( old ){
        !          1742:                                temp = q->in.left->in.left; /* the "*" node */
        !          1743:                                q = talloc();
        !          1744:                                q->in.op = ASSIGN;
        !          1745:                                q->in.left = temp->in.left;
        !          1746:                                q->in.right = old;
        !          1747:                                q->in.type = old->in.type;
        !          1748: #ifdef FLEXNAMES
        !          1749:                                q->in.name = "";
        !          1750: #else
        !          1751:                                q->in.name[0] = '\0';
        !          1752: #endif
        !          1753:                                temp->in.left = q;
        !          1754:                        }
        !          1755:                        break;
        !          1756: 
        !          1757:                case UNARY MUL:
        !          1758:                        /* avoid doing side effects twice */
        !          1759:                        q = p->in.left;
        !          1760:                        p->in.left = q->in.left;
        !          1761:                        q->in.op = FREE;
        !          1762:                        break;
        !          1763: 
        !          1764:                default:
        !          1765:                        cerror( "hardops: can't compute & LHS" );
        !          1766:                        }
        !          1767:                }
        !          1768: 
        !          1769:        /* build comma op for args to function */
        !          1770:        q = talloc();
        !          1771:        q->in.op = CM;
        !          1772:        q->in.rall = NOPREF;
        !          1773:        q->in.type = INT;
        !          1774:        q->in.left = p->in.left;
        !          1775:        q->in.right = p->in.right;
        !          1776:        p->in.op = CALL;
        !          1777:        p->in.right = q;
        !          1778: 
        !          1779:        /* put function name in left node of call */
        !          1780:        p->in.left = q = talloc();
        !          1781:        q->in.op = ICON;
        !          1782:        q->in.rall = NOPREF;
        !          1783:        q->in.type = INCREF( FTN + p->in.type );
        !          1784: #ifndef FLEXNAMES
        !          1785:        strcpy( q->in.name, f->func );
        !          1786: #else
        !          1787:        q->in.name = f->func;
        !          1788: #endif
        !          1789:        q->tn.lval = 0;
        !          1790:        q->tn.rval = 0;
        !          1791: 
        !          1792:        }
        !          1793: 
        !          1794: zappost(p) NODE *p; {
        !          1795:        /* look for ++ and -- operators and remove them */
        !          1796: 
        !          1797:        register int o, ty;
        !          1798:        register NODE *q;
        !          1799:        o = p->in.op;
        !          1800:        ty = optype( o );
        !          1801: 
        !          1802:        switch( o ){
        !          1803: 
        !          1804:        case INCR:
        !          1805:        case DECR:
        !          1806:                        q = p->in.left;
        !          1807:                        p->in.right->in.op = FREE;  /* zap constant */
        !          1808:                        ncopy( p, q );
        !          1809:                        q->in.op = FREE;
        !          1810:                        return;
        !          1811: 
        !          1812:                }
        !          1813: 
        !          1814:        if( ty == BITYPE ) zappost( p->in.right );
        !          1815:        if( ty != LTYPE ) zappost( p->in.left );
        !          1816: }
        !          1817: 
        !          1818: fixpre(p) NODE *p; {
        !          1819: 
        !          1820:        register int o, ty;
        !          1821:        o = p->in.op;
        !          1822:        ty = optype( o );
        !          1823: 
        !          1824:        switch( o ){
        !          1825: 
        !          1826:        case ASG PLUS:
        !          1827:                        p->in.op = PLUS;
        !          1828:                        break;
        !          1829:        case ASG MINUS:
        !          1830:                        p->in.op = MINUS;
        !          1831:                        break;
        !          1832:                }
        !          1833: 
        !          1834:        if( ty == BITYPE ) fixpre( p->in.right );
        !          1835:        if( ty != LTYPE ) fixpre( p->in.left );
        !          1836: }
        !          1837: 
        !          1838: /*ARGSUSED*/
        !          1839: NODE * addroreg(l) NODE *l;
        !          1840:                                /* OREG was built in clocal()
        !          1841:                                 * for an auto or formal parameter
        !          1842:                                 * now its address is being taken
        !          1843:                                 * local code must unwind it
        !          1844:                                 * back to PLUS/MINUS REG ICON
        !          1845:                                 * according to local conventions
        !          1846:                                 */
        !          1847: {
        !          1848:        cerror("address of OREG taken");
        !          1849:        /*NOTREACHED*/
        !          1850: }
        !          1851: 
        !          1852: 
        !          1853: 
        !          1854: # ifndef ONEPASS
        !          1855: main( argc, argv ) char *argv[]; {
        !          1856:        return( mainp2( argc, argv ) );
        !          1857:        }
        !          1858: # endif
        !          1859: 
        !          1860: strip(p) register NODE *p; {
        !          1861:        NODE *q;
        !          1862: 
        !          1863:        /* strip nodes off the top when no side effects occur */
        !          1864:        for( ; ; ) {
        !          1865:                switch( p->in.op ) {
        !          1866:                case SCONV:                     /* remove lint tidbits */
        !          1867:                        q = p->in.left;
        !          1868:                        ncopy( p, q );
        !          1869:                        q->in.op = FREE;
        !          1870:                        break;
        !          1871:                /* could probably add a few more here */
        !          1872:                default:
        !          1873:                        return;
        !          1874:                        }
        !          1875:                }
        !          1876:        }
        !          1877: 
        !          1878: myreader(p) register NODE *p; {
        !          1879:        strip( p );             /* strip off operations with no side effects */
        !          1880:        canon( p );             /* expands r-vals for fields */
        !          1881:        walkf( p, hardops );    /* convert ops to function calls */
        !          1882:        walkf( p, optim2 );
        !          1883:        }

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