4.3BSD - /usr/src/lib/pcc/local2.c

   1: # ifndef lint
   2: static char *sccsid ="@(#)local2.c	1.14 (Berkeley) 4/23/86";
   3: # endif
   4: 
   5: # include "pass2.h"
   6: # include "ctype.h"
   7: # ifdef FORT
   8: int ftlab1, ftlab2;
   9: # endif
  10: /* a lot of the machine dependent parts of the second pass */
  11: 
  12: # define putstr(s)  fputs((s), stdout)
  13: 
  14: # define BITMASK(n) ((1L<<n)-1)
  15: 
  16: where(c){
  17:     fprintf( stderr, "%s, line %d: ", filename, lineno );
  18:     }
  19: 
  20: lineid( l, fn ) char *fn; {
  21:     /* identify line l and file fn */
  22:     printf( "#	line %d, file %s\n", l, fn );
  23:     }
  24: 
  25: 
  26: eobl2(){
  27:     OFFSZ spoff;    /* offset from stack pointer */
  28: #ifdef FORT
  29:     spoff = maxoff;
  30:     if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
  31:     spoff /= SZCHAR;
  32:     SETOFF(spoff,4);
  33: #ifndef FLEXNAMES
  34:     printf( "	.set	.F%d,%ld\n", ftnno, spoff );
  35: #else
  36:     /* SHOULD BE L%d ... ftnno but must change pc/f77 */
  37:     printf( "	.set	LF%d,%ld\n", ftnno, spoff );
  38: #endif
  39: #else
  40:     extern int ftlab1, ftlab2;
  41: 
  42:     spoff = maxoff;
  43:     if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
  44:     spoff /= SZCHAR;
  45:     SETOFF(spoff,4);
  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:     ASG PLUS, "add",
  60:     ASG MINUS, "sub",
  61:     ASG MUL, "mul",
  62:     ASG DIV, "div",
  63:     ASG OR, "bis",
  64:     ASG ER, "xor",
  65:     ASG AND, "bic",
  66:     PLUS,   "add",
  67:     MINUS,  "sub",
  68:     MUL,    "mul",
  69:     DIV,    "div",
  70:     OR, "bis",
  71:     ER, "xor",
  72:     AND,    "bic",
  73:     -1, ""    };
  74: 
  75: hopcode( f, o ){
  76:     /* output the appropriate string from the above table */
  77: 
  78:     register struct hoptab *q;
  79: 
  80:     for( q = ioptab;  q->opmask>=0; ++q ){
  81:         if( q->opmask == o ){
  82:             putstr( q->opstring );
  83: /* tbl
  84: 			if( f == 'F' ) putchar( 'e' );
  85: 			else if( f == 'D' ) putchar( 'd' );
  86:    tbl */
  87: /* tbl */
  88:             switch( f ) {
  89:                 case 'L':
  90:                 case 'W':
  91:                 case 'B':
  92:                 case 'D':
  93:                 case 'F':
  94:                     putchar(tolower(f));
  95:                     break;
  96: 
  97:                 }
  98: /* tbl */
  99:             return;
 100:             }
 101:         }
 102:     cerror( "no hoptab for %s", opst[o] );
 103:     }
 104: 
 105: char *
 106: rnames[] = {  /* keyed to register number tokens */
 107: 
 108:     "r0", "r1",
 109:     "r2", "r3", "r4", "r5",
 110:     "r6", "r7", "r8", "r9", "r10", "r11",
 111:     "ap", "fp", "sp", "pc",
 112: 
 113:     };
 114: 
 115: int rstatus[] = {
 116:     SAREG|STAREG, SAREG|STAREG,
 117:     SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG,
 118:     SAREG, SAREG, SAREG, SAREG, SAREG, SAREG,
 119:     SAREG, SAREG, SAREG, SAREG,
 120: 
 121:     };
 122: 
 123: tlen(p) NODE *p;
 124: {
 125:     switch(p->in.type) {
 126:         case CHAR:
 127:         case UCHAR:
 128:             return(1);
 129: 
 130:         case SHORT:
 131:         case USHORT:
 132:             return(2);
 133: 
 134:         case DOUBLE:
 135:             return(8);
 136: 
 137:         default:
 138:             return(4);
 139:         }
 140: }
 141: 
 142: mixtypes(p, q) NODE *p, *q;
 143: {
 144:     register TWORD tp, tq;
 145: 
 146:     tp = p->in.type;
 147:     tq = q->in.type;
 148: 
 149:     return( (tp==FLOAT || tp==DOUBLE) !=
 150:         (tq==FLOAT || tq==DOUBLE) );
 151: }
 152: 
 153: prtype(n) NODE *n;
 154: {
 155:     switch (n->in.type)
 156:         {
 157:         case DOUBLE:
 158:             putchar('d');
 159:             return;
 160: 
 161:         case FLOAT:
 162:             putchar('f');
 163:             return;
 164: 
 165:         case LONG:
 166:         case ULONG:
 167:         case INT:
 168:         case UNSIGNED:
 169:             putchar('l');
 170:             return;
 171: 
 172:         case SHORT:
 173:         case USHORT:
 174:             putchar('w');
 175:             return;
 176: 
 177:         case CHAR:
 178:         case UCHAR:
 179:             putchar('b');
 180:             return;
 181: 
 182:         default:
 183:             if ( !ISPTR( n->in.type ) ) cerror("zzzcode- bad type");
 184:             else {
 185:                 putchar('l');
 186:                 return;
 187:                 }
 188:         }
 189: }
 190: 
 191: zzzcode( p, c ) register NODE *p; {
 192:     register m;
 193:     CONSZ val;
 194:     switch( c ){
 195: 
 196:     case 'N':  /* logical ops, turned into 0-1 */
 197:         /* use register given by register 1 */
 198:         cbgen( 0, m=getlab(), 'I' );
 199:         deflab( p->bn.label );
 200:         printf( "	clrl	%s\n", rnames[getlr( p, '1' )->tn.rval] );
 201:         deflab( m );
 202:         return;
 203: 
 204:     case 'I':
 205:     case 'P':
 206:         cbgen( p->in.op, p->bn.label, c );
 207:         return;
 208: 
 209:     case 'A':
 210:         {
 211:         register NODE *l, *r;
 212: 
 213:         if (xdebug) eprint(p, 0, &val, &val);
 214:         r = getlr(p, 'R');
 215:         if (p->in.op == ASSIGN)
 216:             l = getlr(p, 'L');
 217:         else if (p->in.op == SCONV) {
 218:             l = resc;
 219: #if defined(FORT) || defined(SPRECC)
 220:             l->in.type = r->in.type;
 221: #else
 222:             l->in.type = r->in.type==FLOAT ? DOUBLE : r->in.type;
 223: #endif
 224:             r = getlr(p, 'L');
 225:             }
 226:         else {      /* OPLTYPE */
 227:             l = resc;
 228: #if defined(FORT) || defined(SPRECC)
 229:             l->in.type = (r->in.type==FLOAT || r->in.type==DOUBLE ? r->in.type : INT);
 230: #else
 231:             l->in.type = (r->in.type==FLOAT || r->in.type==DOUBLE ? DOUBLE : INT);
 232: #endif
 233:             }
 234:         if (r->in.op == ICON)
 235:             if (r->in.name[0] == '\0') {
 236:                 if (r->tn.lval == 0) {
 237:                     putstr("clr");
 238:                     prtype(l);
 239:                     putchar('\t');
 240:                     adrput(l);
 241:                     return;
 242:                     }
 243:                 if (r->tn.lval < 0 && r->tn.lval >= -63) {
 244:                     putstr("mneg");
 245:                     prtype(l);
 246:                     r->tn.lval = -r->tn.lval;
 247:                     goto ops;
 248:                     }
 249:                 if (r->tn.lval < 0)
 250:                     r->in.type = r->tn.lval >= -128 ? CHAR
 251:                         : (r->tn.lval >= -32768 ? SHORT
 252:                         : INT);
 253:                 else if (l->in.type == FLOAT ||
 254:                     l->in.type == DOUBLE)
 255:                     r->in.type = r->tn.lval <= 63 ? INT
 256:                         : (r->tn.lval <= 127 ? CHAR
 257:                         : (r->tn.lval <= 32767 ? SHORT
 258:                         : INT));
 259:                 else
 260:                     r->in.type = r->tn.lval <= 63 ? INT
 261:                         : (r->tn.lval <= 127 ? CHAR
 262:                         : (r->tn.lval <= 255 ? UCHAR
 263:                         : (r->tn.lval <= 32767 ? SHORT
 264:                         : (r->tn.lval <= 65535 ? USHORT
 265:                         : INT))));
 266:                 }
 267:             else {
 268:                 putstr("moval");
 269:                 putchar('\t');
 270:                 acon(r);
 271:                 putchar(',');
 272:                 adrput(l);
 273:                 return;
 274:                 }
 275: 
 276:         if (p->in.op == SCONV &&
 277:             !(l->in.type == FLOAT || l->in.type == DOUBLE) &&
 278:             !mixtypes(l, r)) {
 279:             /*
 280: 			 * Because registers must always contain objects
 281: 			 * of the same width as INTs, we may have to
 282: 			 * perform two conversions to get an INT.  Can
 283: 			 * the conversions be collapsed into one?
 284: 			 */
 285:             if (m = collapsible(l, r))
 286:                 r->in.type = m;
 287:             else {
 288:                 /*
 289: 				 * Two steps are required.
 290: 				 */
 291:                 NODE *x = &resc[1];
 292: 
 293:                 *x = *l;
 294:                 if (tlen(x) > tlen(r) && ISUNSIGNED(r->in.type))
 295:                     putstr("movz");
 296:                 else
 297:                     putstr("cvt");
 298:                 prtype(r);
 299:                 prtype(x);
 300:                 putchar('\t');
 301:                 adrput(r);
 302:                 putchar(',');
 303:                 adrput(x);
 304:                 putchar('\n');
 305:                 putchar('\t');
 306:                 r = x;
 307:                 }
 308:             l->in.type = (ISUNSIGNED(l->in.type) ? UNSIGNED : INT);
 309:             }
 310: 
 311:         if ((r->in.type == UNSIGNED || r->in.type == ULONG) &&
 312:             mixtypes(l, r)) {
 313:             int label1, label2;
 314: 
 315:             label1 = getlab();
 316:             label2 = getlab();
 317: 
 318:             putstr("movl\t");
 319:             adrput(r);
 320:             putchar(',');
 321:             adrput(l);
 322:             putstr("\n\tjbsc\t$31,");
 323:             adrput(l);
 324:             printf(",L%d\n\tcvtl", label1);
 325:             prtype(l);
 326:             putchar('\t');
 327:             adrput(l);
 328:             putchar(',');
 329:             adrput(l);
 330:             printf("\n\tjbr\tL%d\nL%d:\n\tcvtl", label2, label1);
 331:             prtype(l);
 332:             putchar('\t');
 333:             adrput(l);
 334:             putchar(',');
 335:             adrput(l);
 336:             putstr("\n\tadd");
 337:             prtype(l);
 338:             putstr("2\t$0");
 339:             prtype(l);
 340:             putstr("2.147483648e9,");
 341:             adrput(l);
 342:             printf("\nL%d:", label2);
 343: 
 344:             return;
 345:             }
 346: 
 347:         if (!mixtypes(l,r)) {
 348:             if (tlen(l) == tlen(r)) {
 349:                 putstr("mov");
 350: #ifdef FORT
 351:                 if (Oflag)
 352:                     prtype(l);
 353:                 else {
 354:                     if (l->in.type == DOUBLE)
 355:                         putchar('q');
 356:                     else if(l->in.type == FLOAT)
 357:                         putchar('l');
 358:                     else
 359:                         prtype(l);
 360:                     }
 361: #else
 362:                 prtype(l);
 363: #endif FORT
 364:                 goto ops;
 365:                 }
 366:             else if (tlen(l) > tlen(r) && ISUNSIGNED(r->in.type))
 367:                 putstr("movz");
 368:             else
 369:                 putstr("cvt");
 370:             }
 371:         else
 372:             putstr("cvt");
 373:         prtype(r);
 374:         prtype(l);
 375:     ops:
 376:         putchar('\t');
 377:         adrput(r);
 378:         putchar(',');
 379:         adrput(l);
 380:         return;
 381:         }
 382: 
 383:     case 'G':   /* i *= f; asgops with int lhs and float rhs */
 384:         {
 385:         register NODE *l, *r, *s;
 386:         int rt;
 387: 
 388:         l = p->in.left;
 389:         r = p->in.right;
 390:         s = talloc();
 391:         rt = r->in.type;
 392: 
 393:         s->in.op = SCONV;
 394:         s->in.left = l;
 395:         s->in.type = rt;
 396:         zzzcode(s, 'A');
 397:         putstr("\n\t");
 398: 
 399:         hopcode(rt == FLOAT ? 'F' : 'D', p->in.op);
 400:         putstr("2\t");
 401:         adrput(r);
 402:         putchar(',');
 403:         adrput(resc);
 404:         putstr("\n\t");
 405: 
 406:         s->in.op = ASSIGN;
 407:         s->in.left = l;
 408:         s->in.right = resc;
 409:         s->in.type = l->in.type;
 410:         zzzcode(s, 'A');
 411: 
 412:         s->in.op = FREE;
 413:         return;
 414:         }
 415: 
 416:     case 'B':   /* get oreg value in temp register for left shift */
 417:         {
 418:         register NODE *r;
 419:         if (xdebug) eprint(p, 0, &val, &val);
 420:         r = p->in.right;
 421:         if( tlen(r) == sizeof(int) && r->in.type != FLOAT )
 422:             putstr("movl");
 423:         else {
 424:             putstr("cvt");
 425:             prtype(r);
 426:             putchar('l');
 427:             }
 428:         return;
 429:         }
 430: 
 431:     case 'C':   /* num words pushed on arg stack */
 432:         {
 433:         extern int gc_numbytes;
 434:         extern int xdebug;
 435: 
 436:         if (xdebug) printf("->%d<-",gc_numbytes);
 437: 
 438:         printf("$%d", gc_numbytes/(SZLONG/SZCHAR) );
 439:         return;
 440:         }
 441: 
 442:     case 'D':   /* INCR and DECR */
 443:         zzzcode(p->in.left, 'A');
 444:         putchar('\n');
 445:         putchar('\t');
 446: 
 447:     case 'E':   /* INCR and DECR, FOREFF */
 448:         if (p->in.right->tn.lval == 1)
 449:             {
 450:             putstr( p->in.op == INCR ? "inc" : "dec" );
 451:             prtype(p->in.left);
 452:             putchar('\t');
 453:             adrput(p->in.left);
 454:             return;
 455:             }
 456:         putstr( p->in.op == INCR ? "add" : "sub" );
 457:         prtype(p->in.left);
 458:         putchar('2');
 459:         putchar('\t');
 460:         adrput(p->in.right);
 461:         putchar(',');
 462:         adrput(p->in.left);
 463:         return;
 464: 
 465:     case 'F':   /* register type of right operand */
 466:         {
 467:         register NODE *n;
 468:         extern int xdebug;
 469:         register int ty;
 470: 
 471:         n = getlr( p, 'R' );
 472:         ty = n->in.type;
 473: 
 474:         if (xdebug) printf("->%d<-", ty);
 475: 
 476:         if ( ty==DOUBLE) putchar('d');
 477:         else if ( ty==FLOAT ) putchar('f');
 478:         else putchar('l');
 479:         return;
 480:         }
 481: 
 482:     case 'L':   /* type of left operand */
 483:     case 'R':   /* type of right operand */
 484:         {
 485:         register NODE *n;
 486:         extern int xdebug;
 487: 
 488:         n = getlr( p, c );
 489:         if (xdebug) printf("->%d<-", n->in.type);
 490: 
 491:         prtype(n);
 492:         return;
 493:         }
 494: 
 495:     case 'Z':   /* complement mask for bit instr */
 496:         printf("$%ld", ~p->in.right->tn.lval);
 497:         return;
 498: 
 499:     case 'U':   /* 32 - n, for unsigned right shifts */
 500:         printf("$%d", 32 - p->in.right->tn.lval );
 501:         return;
 502: 
 503:     case 'T':   /* rounded structure length for arguments */
 504:         {
 505:         int size;
 506: 
 507:         size = p->stn.stsize;
 508:         SETOFF( size, 4);
 509:         printf("$%d", size);
 510:         return;
 511:         }
 512: 
 513:     case 'S':  /* structure assignment */
 514:         {
 515:             register NODE *l, *r;
 516:             register size;
 517: 
 518:             if( p->in.op == STASG ){
 519:                 l = p->in.left;
 520:                 r = p->in.right;
 521: 
 522:                 }
 523:             else if( p->in.op == STARG ){  /* store an arg into a temporary */
 524:                 r = p->in.left;
 525:                 }
 526:             else cerror( "STASG bad" );
 527: 
 528:             if( r->in.op == ICON ) r->in.op = NAME;
 529:             else if( r->in.op == REG ) r->in.op = OREG;
 530:             else if( r->in.op != OREG ) cerror( "STASG-r" );
 531: 
 532:             size = p->stn.stsize;
 533: 
 534:             if( size <= 0 || size > 65535 )
 535:                 cerror("structure size <0=0 or >65535");
 536: 
 537:             switch(size) {
 538:                 case 1:
 539:                     putstr("	movb	");
 540:                     break;
 541:                 case 2:
 542:                     putstr("	movw	");
 543:                     break;
 544:                 case 4:
 545:                     putstr("	movl	");
 546:                     break;
 547:                 case 8:
 548:                     putstr("	movq	");
 549:                     break;
 550:                 default:
 551:                     printf("	movc3	$%d,", size);
 552:                     break;
 553:             }
 554:             adrput(r);
 555:             if( p->in.op == STASG ){
 556:                 putchar(',');
 557:                 adrput(l);
 558:                 putchar('\n');
 559:                 }
 560:             else
 561:                 putstr(",(sp)\n");
 562: 
 563:             if( r->in.op == NAME ) r->in.op = ICON;
 564:             else if( r->in.op == OREG ) r->in.op = REG;
 565: 
 566:             }
 567:         break;
 568: 
 569:     default:
 570:         cerror( "illegal zzzcode" );
 571:         }
 572:     }
 573: 
 574: /*
 575:  * collapsible(dest, src) -- if a conversion with a register destination
 576:  *	can be accomplished in one instruction, return the type of src
 577:  *	that will do the job correctly; otherwise return 0.  Note that
 578:  *	a register must always end up having type INT or UNSIGNED.
 579:  */
 580: int
 581: collapsible(dest, src)
 582: NODE *dest, *src;
 583: {
 584:     int st = src->in.type;
 585:     int dt = dest->in.type;
 586:     int newt = 0;
 587: 
 588:     /*
 589: 	 * Are there side effects of evaluating src?
 590: 	 * If the derived type will not be the same size as src,
 591: 	 * we may have to use two steps.
 592: 	 */
 593:     if (tlen(src) > tlen(dest)) {
 594:         if (tshape(src, STARREG))
 595:             return (0);
 596:         if (src->in.op == OREG && R2TEST(src->tn.rval))
 597:             return (0);
 598:         }
 599: 
 600:     /*
 601: 	 * Can we get an object of dest's type by punning src?
 602: 	 * Praises be to great Cthulhu for little-endian machines...
 603: 	 */
 604:     if (st == CHAR && dt == USHORT)
 605:         /*
 606: 		 * Special case -- we must sign-extend to 16 bits.
 607: 		 */
 608:         return (0);
 609: 
 610:     if (tlen(src) < tlen(dest))
 611:         newt = st;
 612:     else
 613:         newt = dt;
 614: 
 615:     return (newt);
 616:     }
 617: 
 618: rmove( rt, rs, t ) TWORD t; {
 619:     printf( "	%s	%s,%s\n",
 620: #ifdef FORT
 621:         !Oflag ? (t==DOUBLE ? "movq" : "movl") :
 622: #endif
 623:         (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")),
 624:         rnames[rs], rnames[rt] );
 625:     }
 626: 
 627: struct respref
 628: respref[] = {
 629:     INTAREG|INTBREG,    INTAREG|INTBREG,
 630:     INAREG|INBREG,  INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON,
 631:     INTEMP, INTEMP,
 632:     FORARG, FORARG,
 633:     INTEMP, INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM,
 634:     0,  0 };
 635: 
 636: setregs(){ /* set up temporary registers */
 637:     fregs = 6;  /* tbl- 6 free regs on VAX (0-5) */
 638:     ;
 639:     }
 640: 
 641: rewfld( p ) NODE *p; {
 642:     return(1);
 643:     }
 644: 
 645: callreg(p) NODE *p; {
 646:     return( R0 );
 647:     }
 648: 
 649: base( p ) register NODE *p; {
 650:     register int o = p->in.op;
 651: 
 652:     if( (o==ICON && p->in.name[0] != '\0')) return( 100 ); /* ie no base reg */
 653:     if( o==REG ) return( p->tn.rval );
 654:     if( (o==PLUS || o==MINUS) && p->in.left->in.op == REG && p->in.right->in.op==ICON)
 655:         return( p->in.left->tn.rval );
 656:     if( o==OREG && !R2TEST(p->tn.rval) && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) )
 657:         return( p->tn.rval + 0200*1 );
 658:     if( o==INCR && p->in.left->in.op==REG ) return( p->in.left->tn.rval + 0200*2 );
 659:     if( o==ASG MINUS && p->in.left->in.op==REG) return( p->in.left->tn.rval + 0200*4 );
 660:     if( o==UNARY MUL && p->in.left->in.op==INCR && p->in.left->in.left->in.op==REG
 661:       && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) )
 662:         return( p->in.left->in.left->tn.rval + 0200*(1+2) );
 663:     return( -1 );
 664:     }
 665: 
 666: offset( p, tyl ) register NODE *p; int tyl; {
 667: 
 668:     if( tyl==1 &&
 669:         p->in.op==REG &&
 670:         (p->in.type==INT || p->in.type==UNSIGNED) )
 671:         return( p->tn.rval );
 672:     if( p->in.op==LS &&
 673:         p->in.left->in.op==REG &&
 674:         (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) &&
 675:         p->in.right->in.op==ICON &&
 676:         p->in.right->in.name[0]=='\0' &&
 677:         (1<<p->in.right->tn.lval)==tyl)
 678:         return( p->in.left->tn.rval );
 679:     if( tyl==2 &&
 680:         p->in.op==PLUS &&
 681:         (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) &&
 682:         p->in.left->in.op==REG &&
 683:         p->in.right->in.op==REG &&
 684:         p->in.left->tn.rval==p->in.right->tn.rval )
 685:         return( p->in.left->tn.rval );
 686:     return( -1 );
 687:     }
 688: 
 689: makeor2( p, q, b, o) register NODE *p, *q; register int b, o; {
 690:     register NODE *t;
 691:     register int i;
 692:     NODE *f;
 693: 
 694:     p->in.op = OREG;
 695:     f = p->in.left;     /* have to free this subtree later */
 696: 
 697:     /* init base */
 698:     switch (q->in.op) {
 699:         case ICON:
 700:         case REG:
 701:         case OREG:
 702:             t = q;
 703:             break;
 704: 
 705:         case MINUS:
 706:             q->in.right->tn.lval = -q->in.right->tn.lval;
 707:         case PLUS:
 708:             t = q->in.right;
 709:             break;
 710: 
 711:         case INCR:
 712:         case ASG MINUS:
 713:             t = q->in.left;
 714:             break;
 715: 
 716:         case UNARY MUL:
 717:             t = q->in.left->in.left;
 718:             break;
 719: 
 720:         default:
 721:             cerror("illegal makeor2");
 722:     }
 723: 
 724:     p->tn.lval = t->tn.lval;
 725: #ifndef FLEXNAMES
 726:     for(i=0; i<NCHNAM; ++i)
 727:         p->in.name[i] = t->in.name[i];
 728: #else
 729:     p->in.name = t->in.name;
 730: #endif
 731: 
 732:     /* init offset */
 733:     p->tn.rval = R2PACK( (b & 0177), o, (b>>7) );
 734: 
 735:     tfree(f);
 736:     return;
 737:     }
 738: 
 739: canaddr( p ) NODE *p; {
 740:     register int o = p->in.op;
 741: 
 742:     if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1);
 743:     return(0);
 744:     }
 745: 
 746: flshape( p ) register NODE *p; {
 747:     return( p->in.op == REG || p->in.op == NAME || p->in.op == ICON ||
 748:         (p->in.op == OREG && (!R2TEST(p->tn.rval) || tlen(p) == 1)) );
 749:     }
 750: 
 751: shtemp( p ) register NODE *p; {
 752:     if( p->in.op == STARG ) p = p->in.left;
 753:     return( p->in.op==NAME || p->in.op ==ICON || p->in.op == OREG || (p->in.op==UNARY MUL && shumul(p->in.left)) );
 754:     }
 755: 
 756: shumul( p ) register NODE *p; {
 757:     register o;
 758:     extern int xdebug;
 759: 
 760:     if (xdebug) {
 761:          printf("\nshumul:op=%d,lop=%d,rop=%d", p->in.op, p->in.left->in.op, p->in.right->in.op);
 762:         printf(" prname=%s,plty=%d, prlval=%D\n", p->in.right->in.name, p->in.left->in.type, p->in.right->tn.lval);
 763:         }
 764: 
 765: 
 766:     o = p->in.op;
 767:     if( o == NAME || (o == OREG && !R2TEST(p->tn.rval)) || o == ICON ) return( STARNM );
 768: 
 769:     if( ( o == INCR || o == ASG MINUS ) &&
 770:         ( p->in.left->in.op == REG && p->in.right->in.op == ICON ) &&
 771:         p->in.right->in.name[0] == '\0' )
 772:         {
 773:         switch (p->in.type)
 774:             {
 775:             case CHAR|PTR:
 776:             case UCHAR|PTR:
 777:                 o = 1;
 778:                 break;
 779: 
 780:             case SHORT|PTR:
 781:             case USHORT|PTR:
 782:                 o = 2;
 783:                 break;
 784: 
 785:             case INT|PTR:
 786:             case UNSIGNED|PTR:
 787:             case LONG|PTR:
 788:             case ULONG|PTR:
 789:             case FLOAT|PTR:
 790:                 o = 4;
 791:                 break;
 792: 
 793:             case DOUBLE|PTR:
 794:                 o = 8;
 795:                 break;
 796: 
 797:             default:
 798:                 if ( ISPTR(p->in.type) &&
 799:                      ISPTR(DECREF(p->in.type)) ) {
 800:                     o = 4;
 801:                     break;
 802:                     }
 803:                 else return(0);
 804:             }
 805:         return( p->in.right->tn.lval == o ? STARREG : 0);
 806:         }
 807: 
 808:     return( 0 );
 809:     }
 810: 
 811: adrcon( val ) CONSZ val; {
 812:     putchar( '$' );
 813:     printf( CONFMT, val );
 814:     }
 815: 
 816: conput( p ) register NODE *p; {
 817:     switch( p->in.op ){
 818: 
 819:     case ICON:
 820:         acon( p );
 821:         return;
 822: 
 823:     case REG:
 824:         putstr( rnames[p->tn.rval] );
 825:         return;
 826: 
 827:     default:
 828:         cerror( "illegal conput" );
 829:         }
 830:     }
 831: 
 832: insput( p ) register NODE *p; {
 833:     cerror( "insput" );
 834:     }
 835: 
 836: upput( p ) register NODE *p; {
 837:     cerror( "upput" );
 838:     }
 839: 
 840: adrput( p ) register NODE *p; {
 841:     register int r;
 842:     /* output an address, with offsets, from p */
 843: 
 844:     if( p->in.op == FLD ){
 845:         p = p->in.left;
 846:         }
 847:     switch( p->in.op ){
 848: 
 849:     case NAME:
 850:         acon( p );
 851:         return;
 852: 
 853:     case ICON:
 854:         /* addressable value of the constant */
 855:         putchar( '$' );
 856:         acon( p );
 857:         return;
 858: 
 859:     case REG:
 860:         putstr( rnames[p->tn.rval] );
 861:         return;
 862: 
 863:     case OREG:
 864:         r = p->tn.rval;
 865:         if( R2TEST(r) ){ /* double indexing */
 866:             register int flags;
 867: 
 868:             flags = R2UPK3(r);
 869:             if( flags & 1 ) putchar('*');
 870:             if( flags & 4 ) putchar('-');
 871:             if( p->tn.lval != 0 || p->in.name[0] != '\0' ) acon(p);
 872:             if( R2UPK1(r) != 100) printf( "(%s)", rnames[R2UPK1(r)] );
 873:             if( flags & 2 ) putchar('+');
 874:             printf( "[%s]", rnames[R2UPK2(r)] );
 875:             return;
 876:             }
 877:         if( r == AP ){  /* in the argument region */
 878:             if( p->tn.lval <= 0 || p->in.name[0] != '\0' ) werror( "bad arg temp" );
 879:             printf( CONFMT, p->tn.lval );
 880:             putstr( "(ap)" );
 881:             return;
 882:             }
 883:         if( p->tn.lval != 0 || p->in.name[0] != '\0') acon( p );
 884:         printf( "(%s)", rnames[p->tn.rval] );
 885:         return;
 886: 
 887:     case UNARY MUL:
 888:         /* STARNM or STARREG found */
 889:         if( tshape(p, STARNM) ) {
 890:             putchar( '*' );
 891:             adrput( p->in.left);
 892:             }
 893:         else {  /* STARREG - really auto inc or dec */
 894:             register NODE *q;
 895: 
 896: /* tbl
 897: 			p = p->in.left;
 898: 			p->in.left->in.op = OREG;
 899: 			if( p->in.op == INCR ) {
 900: 				adrput( p->in.left );
 901: 				putchar( '+' );
 902: 				}
 903: 			else {
 904: 				putchar( '-' );
 905: 				adrput( p->in.left );
 906: 				}
 907:    tbl */
 908:             q = p->in.left;
 909:             if( q->in.right->tn.lval != tlen(p) )
 910:                 cerror("adrput: bad auto-increment/decrement");
 911:             printf("%s(%s)%s", (q->in.op==INCR ? "" : "-"),
 912:                 rnames[q->in.left->tn.rval],
 913:                 (q->in.op==INCR ? "+" : "") );
 914:             p->in.op = OREG;
 915:             p->tn.rval = q->in.left->tn.rval;
 916:             p->tn.lval = (q->in.op == INCR ? -q->in.right->tn.lval : 0);
 917: #ifndef FLEXNAMES
 918:             p->in.name[0] = '\0';
 919: #else
 920:             p->in.name = "";
 921: #endif
 922:             tfree(q);
 923:         }
 924:         return;
 925: 
 926:     default:
 927:         cerror( "illegal address" );
 928:         return;
 929: 
 930:         }
 931: 
 932:     }
 933: 
 934: acon( p ) register NODE *p; { /* print out a constant */
 935: 
 936:     if( p->in.name[0] == '\0' ){
 937:         printf( CONFMT, p->tn.lval);
 938:         }
 939:     else if( p->tn.lval == 0 ) {
 940: #ifndef FLEXNAMES
 941:         printf( "%.8s", p->in.name );
 942: #else
 943:         putstr( p->in.name );
 944: #endif
 945:         }
 946:     else {
 947: #ifndef FLEXNAMES
 948:         printf( "%.8s+", p->in.name );
 949: #else
 950:         printf( "%s+", p->in.name );
 951: #endif
 952:         printf( CONFMT, p->tn.lval );
 953:         }
 954:     }
 955: 
 956: /*
 957: aacon( p ) register NODE *p; { /* print out a constant */
 958: /*
 959: 
 960: 	if( p->in.name[0] == '\0' ){
 961: 		printf( CONFMT, p->tn.lval);
 962: 		return( 0 );
 963: 		}
 964: 	else if( p->tn.lval == 0 ) {
 965: #ifndef FLEXNAMES
 966: 		printf( "$%.8s", p->in.name );
 967: #else
 968: 		printf( "$%s", p->in.name );
 969: #endif
 970: 		return( 1 );
 971: 		}
 972: 	else {
 973: 		printf( "$(" );
 974: 		printf( CONFMT, p->tn.lval );
 975: 		printf( "+" );
 976: #ifndef FLEXNAMES
 977: 		printf( "%.8s)", p->in.name );
 978: #else
 979: 		printf( "%s)", p->in.name );
 980: #endif
 981: 		return(1);
 982: 		}
 983: 	}
 984:  */
 985: 
 986: genscall( p, cookie ) register NODE *p; {
 987:     /* structure valued call */
 988:     return( gencall( p, cookie ) );
 989:     }
 990: 
 991: /* tbl */
 992: int gc_numbytes;
 993: /* tbl */
 994: 
 995: gencall( p, cookie ) register NODE *p; {
 996:     /* generate the call given by p */
 997:     register NODE *p1;
 998:     register temp, temp1;
 999:     register m;
1000: 
1001:     if( p->in.right ) temp = argsize( p->in.right );
1002:     else temp = 0;
1003: 
1004:     if( p->in.op == STCALL || p->in.op == UNARY STCALL ){
1005:         /* set aside room for structure return */
1006: 
1007:         if( p->stn.stsize > temp ) temp1 = p->stn.stsize;
1008:         else temp1 = temp;
1009:         }
1010: 
1011:     if( temp > maxargs ) maxargs = temp;
1012:     SETOFF(temp1,4);
1013: 
1014:     if( p->in.right ){ /* make temp node, put offset in, and generate args */
1015:         genargs( p->in.right );
1016:         }
1017: 
1018:     p1 = p->in.left;
1019:     if( p1->in.op != ICON ){
1020:         if( p1->in.op != REG ){
1021:             if( p1->in.op != OREG || R2TEST(p1->tn.rval) ){
1022:                 if( p1->in.op != NAME ){
1023:                     order( p1, INAREG );
1024:                     }
1025:                 }
1026:             }
1027:         }
1028: 
1029: /*
1030: 	if( p1->in.op == REG && p->tn.rval == R5 ){
1031: 		cerror( "call register overwrite" );
1032: 		}
1033:  */
1034: /* tbl
1035: 	setup gc_numbytes so reference to ZC works */
1036: 
1037:     gc_numbytes = temp&(0x3ff);
1038: /* tbl */
1039: 
1040:     p->in.op = UNARY CALL;
1041:     m = match( p, INTAREG|INTBREG );
1042: 
1043:     /* compensate for deficiency in 'ret' instruction ... wah,kre */
1044:     /* (plus in assignment to gc_numbytes above, for neatness only) */
1045:     if (temp >= 1024)
1046:         printf("	addl2	$%d,sp\n", (temp&(~0x3ff)));
1047: 
1048: /* tbl
1049: 	switch( temp ) {
1050: 	case 0:
1051: 		break;
1052: 	case 2:
1053: 		printf( "	tst	(sp)+\n" );
1054: 		break;
1055: 	case 4:
1056: 		printf( "	cmp	(sp)+,(sp)+\n" );
1057: 		break;
1058: 	default:
1059: 		printf( "	add	$%d,sp\n", temp);
1060: 		}
1061:    tbl */
1062:     return(m != MDONE);
1063:     }
1064: 
1065: /* tbl */
1066: char *
1067: ccbranches[] = {
1068:     "	jeql	L%d\n",
1069:     "	jneq	L%d\n",
1070:     "	jleq	L%d\n",
1071:     "	jlss	L%d\n",
1072:     "	jgeq	L%d\n",
1073:     "	jgtr	L%d\n",
1074:     "	jlequ	L%d\n",
1075:     "	jlssu	L%d\n",
1076:     "	jgequ	L%d\n",
1077:     "	jgtru	L%d\n",
1078:     };
1079: /* tbl */
1080: 
1081: cbgen( o, lab, mode ) { /*   printf conditional and unconditional branches */
1082: 
1083: /* tbl */
1084:     if( o == 0 ) printf( "	jbr	L%d\n", lab );
1085: /* tbl */
1086:     else {
1087:         if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] );
1088:         printf( ccbranches[o-EQ], lab );
1089:         }
1090:     }
1091: 
1092: nextcook( p, cookie ) NODE *p; {
1093:     /* we have failed to match p with cookie; try another */
1094:     if( cookie == FORREW ) return( 0 );  /* hopeless! */
1095:     if( !(cookie&(INTAREG|INTBREG)) ) return( INTAREG|INTBREG );
1096:     if( !(cookie&INTEMP) && asgop(p->in.op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG );
1097:     return( FORREW );
1098:     }
1099: 
1100: lastchance( p, cook ) NODE *p; {
1101:     /* forget it! */
1102:     return(0);
1103:     }
1104: 
1105: optim2( p ) register NODE *p; {
1106:     /* do local tree transformations and optimizations */
1107: 
1108:     register NODE *l, *r;
1109:     int m, ml;
1110: 
1111:     switch( p->in.op ) {
1112: 
1113:     case AND:
1114:         /* commute L and R to eliminate complements and constants */
1115:         if( (l = p->in.left)->in.op == ICON && l->in.name[0] == 0 ||
1116:             l->in.op == COMPL ) {
1117:             p->in.left = p->in.right;
1118:             p->in.right = l;
1119:             }
1120:     case ASG AND:
1121:         /* change meaning of AND to ~R&L - bic on pdp11 */
1122:         r = p->in.right;
1123:         if( r->in.op==ICON && r->in.name[0]==0 ) { /* complement constant */
1124:             r->tn.lval = ~r->tn.lval;
1125:             }
1126:         else if( r->in.op==COMPL ) { /* ~~A => A */
1127:             r->in.op = FREE;
1128:             p->in.right = r->in.left;
1129:             }
1130:         else { /* insert complement node */
1131:             p->in.right = l = talloc();
1132:             l->in.op = COMPL;
1133:             l->in.rall = NOPREF;
1134:             l->in.type = r->in.type;
1135:             l->in.left = r;
1136:             l->in.right = NULL;
1137:             }
1138:         break;
1139: 
1140:     case SCONV:
1141:         l = p->in.left;
1142: #if defined(FORT) || defined(SPRECC)
1143:         if( p->in.type == FLOAT || p->in.type == DOUBLE ||
1144:             l->in.type == FLOAT || l->in.type == DOUBLE )
1145:             return;
1146: #else
1147:         if( mixtypes(p, l) ) return;
1148: #endif
1149:         if( l->in.op == PCONV )
1150:             return;
1151: 
1152:         /* Only trust it to get it right if the size is the same */
1153:         if( tlen(p) != tlen(l) )
1154:             return;
1155: 
1156:         /* clobber conversion */
1157:         if( l->in.op != FLD )
1158:             l->in.type = p->in.type;
1159:         ncopy( p, l );
1160:         l->in.op = FREE;
1161: 
1162:         break;
1163: 
1164:     case ASSIGN:
1165:         /*
1166: 		 * Conversions are equivalent to assignments;
1167: 		 * when the two operations are combined,
1168: 		 * we can sometimes zap the conversion.
1169: 		 */
1170:         r = p->in.right;
1171:         l = p->in.left;
1172:         if ( r->in.op == SCONV &&
1173:              !mixtypes(l, r) &&
1174:              tlen(l) == tlen(r) ) {
1175:                 p->in.right = r->in.left;
1176:                 r->in.op = FREE;
1177:             }
1178:         break;
1179: 
1180:         }
1181:     }
1182: 
1183: NODE * addroreg(l) NODE *l;
1184:                 /* OREG was built in clocal()
1185: 				 * for an auto or formal parameter
1186: 				 * now its address is being taken
1187: 				 * local code must unwind it
1188: 				 * back to PLUS/MINUS REG ICON
1189: 				 * according to local conventions
1190: 				 */
1191: {
1192:     cerror("address of OREG taken");
1193:     /*NOTREACHED*/
1194: }
1195: 
1196: 
1197: 
1198: # ifndef ONEPASS
1199: main( argc, argv ) char *argv[]; {
1200:     return( mainp2( argc, argv ) );
1201:     }
1202: # endif
1203: 
1204: 
1205: /* added by jwf */
1206: struct functbl {
1207:     int fop;
1208:     TWORD ftype;
1209:     char *func;
1210:     } opfunc[] = {
1211:     DIV,        TANY,   "udiv",
1212:     MOD,        TANY,   "urem",
1213:     ASG DIV,    TANY,   "audiv",
1214:     ASG MOD,    TANY,   "aurem",
1215:     0,  0,  0 };
1216: 
1217: hardops(p)  register NODE *p; {
1218:     /* change hard to do operators into function calls.  */
1219:     register NODE *q;
1220:     register struct functbl *f;
1221:     register o;
1222:     NODE *old,*temp;
1223: 
1224:     o = p->in.op;
1225:     if( ! (optype(o)==BITYPE &&
1226:            (ISUNSIGNED(p->in.left->in.type) ||
1227:         ISUNSIGNED(p->in.right->in.type))) )
1228:         return;
1229: 
1230:     for( f=opfunc; f->fop; f++ ) {
1231:         if( o==f->fop ) goto convert;
1232:         }
1233:     return;
1234: 
1235:     convert:
1236:     if( asgop( o ) ) {
1237:         old = NIL;
1238:         switch( p->in.left->in.op ){
1239:         case FLD:
1240:             q = p->in.left->in.left;
1241:             /*
1242: 			 * rewrite (lval.fld /= rval); as
1243: 			 *  ((*temp).fld = udiv((*(temp = &lval)).fld,rval));
1244: 			 * else the compiler will evaluate lval twice.
1245: 			 */
1246:             if( q->in.op == UNARY MUL ){
1247:                 /* first allocate a temp storage */
1248:                 temp = talloc();
1249:                 temp->in.op = OREG;
1250:                 temp->tn.rval = TMPREG;
1251:                 temp->tn.lval = BITOOR(freetemp(1));
1252:                 temp->in.type = INCREF(p->in.type);
1253: #ifdef FLEXNAMES
1254:                 temp->in.name = "";
1255: #else
1256:                 temp->in.name[0] = '\0';
1257: #endif
1258:                 old = q->in.left;
1259:                 q->in.left = temp;
1260:             }
1261:             /* fall thru ... */
1262: 
1263:         case REG:
1264:         case NAME:
1265:         case OREG:
1266:             /* change ASG OP to a simple OP */
1267:             q = talloc();
1268:             q->in.op = NOASG p->in.op;
1269:             q->in.rall = NOPREF;
1270:             q->in.type = p->in.type;
1271:             q->in.left = tcopy(p->in.left);
1272:             q->in.right = p->in.right;
1273:             p->in.op = ASSIGN;
1274:             p->in.right = q;
1275:             p = q;
1276:             f -= 2; /* Note: this depends on the table order */
1277:             /* on the right side only - replace *temp with
1278: 			 *(temp = &lval), build the assignment node */
1279:             if( old ){
1280:                 temp = q->in.left->in.left; /* the "*" node */
1281:                 q = talloc();
1282:                 q->in.op = ASSIGN;
1283:                 q->in.left = temp->in.left;
1284:                 q->in.right = old;
1285:                 q->in.type = old->in.type;
1286: #ifdef FLEXNAMES
1287:                 q->in.name = "";
1288: #else
1289:                 q->in.name[0] = '\0';
1290: #endif
1291:                 temp->in.left = q;
1292:             }
1293:             break;
1294: 
1295:         case UNARY MUL:
1296:             /* avoid doing side effects twice */
1297:             q = p->in.left;
1298:             p->in.left = q->in.left;
1299:             q->in.op = FREE;
1300:             break;
1301: 
1302:         default:
1303:             cerror( "hardops: can't compute & LHS" );
1304:             }
1305:         }
1306: 
1307:     /* build comma op for args to function */
1308:     q = talloc();
1309:     q->in.op = CM;
1310:     q->in.rall = NOPREF;
1311:     q->in.type = INT;
1312:     q->in.left = p->in.left;
1313:     q->in.right = p->in.right;
1314:     p->in.op = CALL;
1315:     p->in.right = q;
1316: 
1317:     /* put function name in left node of call */
1318:     p->in.left = q = talloc();
1319:     q->in.op = ICON;
1320:     q->in.rall = NOPREF;
1321:     q->in.type = INCREF( FTN + p->in.type );
1322: #ifndef FLEXNAMES
1323:     strcpy( q->in.name, f->func );
1324: #else
1325:     q->in.name = f->func;
1326: #endif
1327:     q->tn.lval = 0;
1328:     q->tn.rval = 0;
1329: 
1330:     }
1331: 
1332: zappost(p) NODE *p; {
1333:     /* look for ++ and -- operators and remove them */
1334: 
1335:     register o, ty;
1336:     register NODE *q;
1337:     o = p->in.op;
1338:     ty = optype( o );
1339: 
1340:     switch( o ){
1341: 
1342:     case INCR:
1343:     case DECR:
1344:             q = p->in.left;
1345:             p->in.right->in.op = FREE;  /* zap constant */
1346:             ncopy( p, q );
1347:             q->in.op = FREE;
1348:             return;
1349: 
1350:         }
1351: 
1352:     if( ty == BITYPE ) zappost( p->in.right );
1353:     if( ty != LTYPE ) zappost( p->in.left );
1354: }
1355: 
1356: fixpre(p) NODE *p; {
1357: 
1358:     register o, ty;
1359:     o = p->in.op;
1360:     ty = optype( o );
1361: 
1362:     switch( o ){
1363: 
1364:     case ASG PLUS:
1365:             p->in.op = PLUS;
1366:             break;
1367:     case ASG MINUS:
1368:             p->in.op = MINUS;
1369:             break;
1370:         }
1371: 
1372:     if( ty == BITYPE ) fixpre( p->in.right );
1373:     if( ty != LTYPE ) fixpre( p->in.left );
1374: }
1375: 
1376: strip(p) register NODE *p; {
1377:     NODE *q;
1378: 
1379:     /* strip nodes off the top when no side effects occur */
1380:     for( ; ; ) {
1381:         switch( p->in.op ) {
1382:         case SCONV:         /* remove lint tidbits */
1383:             q = p->in.left;
1384:             ncopy( p, q );
1385:             q->in.op = FREE;
1386:             break;
1387:         /* could probably add a few more here */
1388:         default:
1389:             return;
1390:             }
1391:         }
1392:     }
1393: 
1394: myreader(p) register NODE *p; {
1395:     strip( p );     /* strip off operations with no side effects */
1396:     canon( p );     /* expands r-vals for fields */
1397:     walkf( p, hardops );    /* convert ops to function calls */
1398:     walkf( p, optim2 );
1399:     /* jwf toff = 0;  /* stack offset swindle */
1400:     }

Defined functions

Defined variables

Defined struct's

Defined macros