![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reader.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd / mip|
Return to reader.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / mip |
1.1 ! root 1: static char *sccsid ="%W% (Berkeley) %G%"; ! 2: # include "mfile2" ! 3: ! 4: /* some storage declarations */ ! 5: ! 6: # ifndef ONEPASS ! 7: NODE node[TREESZ]; ! 8: char filename[100] = ""; /* the name of the file */ ! 9: int ftnno; /* number of current function */ ! 10: int lineno; ! 11: # else ! 12: # define NOMAIN ! 13: #endif ! 14: ! 15: int nrecur; ! 16: int lflag; ! 17: extern int Wflag; ! 18: int edebug = 0; ! 19: int xdebug = 0; ! 20: int udebug = 0; ! 21: int vdebug = 0; ! 22: ! 23: OFFSZ tmpoff; /* offset for first temporary, in bits for current block */ ! 24: OFFSZ maxoff; /* maximum temporary offset over all blocks in current ftn, in bits */ ! 25: int maxtreg; ! 26: ! 27: NODE *stotree; ! 28: int stocook; ! 29: ! 30: OFFSZ baseoff = 0; ! 31: OFFSZ maxtemp = 0; ! 32: ! 33: p2init( argc, argv ) char *argv[];{ ! 34: /* set the values of the pass 2 arguments */ ! 35: ! 36: register int c; ! 37: register char *cp; ! 38: register files; ! 39: ! 40: allo0(); /* free all regs */ ! 41: files = 0; ! 42: ! 43: for( c=1; c<argc; ++c ){ ! 44: if( *(cp=argv[c]) == '-' ){ ! 45: while( *++cp ){ ! 46: switch( *cp ){ ! 47: ! 48: case 'X': /* pass1 flags */ ! 49: while( *++cp ) { /* VOID */ } ! 50: --cp; ! 51: break; ! 52: ! 53: case 'l': /* linenos */ ! 54: ++lflag; ! 55: break; ! 56: ! 57: case 'e': /* expressions */ ! 58: ++edebug; ! 59: break; ! 60: ! 61: case 'o': /* orders */ ! 62: ++odebug; ! 63: break; ! 64: ! 65: case 'r': /* register allocation */ ! 66: ++rdebug; ! 67: break; ! 68: ! 69: case 'a': /* rallo */ ! 70: ++radebug; ! 71: break; ! 72: ! 73: case 'v': ! 74: ++vdebug; ! 75: break; ! 76: ! 77: case 't': /* ttype calls */ ! 78: ++tdebug; ! 79: break; ! 80: ! 81: case 's': /* shapes */ ! 82: ++sdebug; ! 83: break; ! 84: ! 85: case 'u': /* Sethi-Ullman testing (machine dependent) */ ! 86: ++udebug; ! 87: break; ! 88: ! 89: case 'x': /* general machine-dependent debugging flag */ ! 90: ++xdebug; ! 91: break; ! 92: ! 93: case 'w': ! 94: case 'W': /* shut up warnings */ ! 95: ! 96: ++Wflag; ! 97: break; ! 98: ! 99: default: ! 100: cerror( "bad option: %c", *cp ); ! 101: } ! 102: } ! 103: } ! 104: else files = 1; /* assumed to be a filename */ ! 105: } ! 106: ! 107: mkdope(); ! 108: setrew(); ! 109: return( files ); ! 110: ! 111: } ! 112: ! 113: # ifndef NOMAIN ! 114: ! 115: unsigned int caloff(); ! 116: unsigned int offsz; ! 117: mainp2( argc, argv ) char *argv[]; { ! 118: register files; ! 119: register temp; ! 120: register c; ! 121: register char *cp; ! 122: register NODE *p; ! 123: ! 124: offsz = caloff(); ! 125: files = p2init( argc, argv ); ! 126: tinit(); ! 127: ! 128: reread: ! 129: ! 130: if( files ){ ! 131: while( files < argc && argv[files][0] == '-' ) { ! 132: ++files; ! 133: } ! 134: if( files > argc ) return( nerrors ); ! 135: freopen( argv[files], "r", stdin ); ! 136: } ! 137: while( (c=getchar()) > 0 ) switch( c ){ ! 138: case ')': ! 139: default: ! 140: /* copy line unchanged */ ! 141: if ( c != ')' ) ! 142: PUTCHAR( c ); /* initial tab */ ! 143: while( (c=getchar()) > 0 ){ ! 144: PUTCHAR(c); ! 145: if( c == '\n' ) break; ! 146: } ! 147: continue; ! 148: ! 149: case BBEG: ! 150: /* beginning of a block */ ! 151: temp = rdin(10); /* ftnno */ ! 152: tmpoff = baseoff = (unsigned int) rdin(10); /* autooff for block gives max offset of autos in block */ ! 153: maxtreg = rdin(10); ! 154: if( getchar() != '\n' ) cerror( "intermediate file format error"); ! 155: ! 156: if( temp != ftnno ){ /* beginning of function */ ! 157: maxoff = baseoff; ! 158: ftnno = temp; ! 159: maxtemp = 0; ! 160: } ! 161: else { ! 162: if( baseoff > maxoff ) maxoff = baseoff; ! 163: /* maxoff at end of ftn is max of autos and temps ! 164: over all blocks in the function */ ! 165: } ! 166: setregs(); ! 167: continue; ! 168: ! 169: case BEND: /* end of block */ ! 170: SETOFF( maxoff, ALSTACK ); ! 171: eobl2(); ! 172: while( (c=getchar()) != '\n' ){ ! 173: if( c <= 0 ) cerror( "intermediate file format eof" ); ! 174: } ! 175: continue; ! 176: ! 177: case EXPR: ! 178: /* compile code for an expression */ ! 179: lineno = rdin( 10 ); ! 180: for( cp=filename; (*cp=getchar()) != '\n'; ++cp ) ; /* VOID, reads filename */ ! 181: *cp = '\0'; ! 182: if( lflag ) lineid( lineno, filename ); ! 183: ! 184: tmpoff = baseoff; /* expression at top level reuses temps */ ! 185: p = eread(); ! 186: ! 187: # ifndef BUG4 ! 188: if( edebug ) fwalk( p, eprint, 0 ); ! 189: # endif ! 190: ! 191: # ifdef MYREADER ! 192: MYREADER(p); /* do your own laundering of the input */ ! 193: # endif ! 194: ! 195: nrecur = 0; ! 196: delay( p ); /* expression statement throws out results */ ! 197: reclaim( p, RNULL, 0 ); ! 198: ! 199: allchk(); ! 200: tcheck(); ! 201: continue; ! 202: ! 203: default: ! 204: cerror( "intermediate file format error" ); ! 205: ! 206: } ! 207: ! 208: /* EOF */ ! 209: if( files ) goto reread; ! 210: return(nerrors); ! 211: ! 212: } ! 213: ! 214: # endif ! 215: ! 216: # ifdef ONEPASS ! 217: ! 218: p2compile( p ) NODE *p; { ! 219: ! 220: if( lflag ) lineid( lineno, filename ); ! 221: tmpoff = baseoff; /* expression at top level reuses temps */ ! 222: /* generate code for the tree p */ ! 223: # ifndef BUG4 ! 224: if( edebug ) fwalk( p, eprint, 0 ); ! 225: # endif ! 226: ! 227: # ifdef MYREADER ! 228: MYREADER(p); /* do your own laundering of the input */ ! 229: # endif ! 230: nrecur = 0; ! 231: delay( p ); /* do the code generation */ ! 232: reclaim( p, RNULL, 0 ); ! 233: allchk(); ! 234: /* can't do tcheck here; some stuff (e.g., attributes) may be around from first pass */ ! 235: /* first pass will do it... */ ! 236: } ! 237: ! 238: p2bbeg( aoff, myreg ) { ! 239: static int myftn = -1; ! 240: ! 241: tmpoff = baseoff = (unsigned int) aoff; ! 242: maxtreg = myreg; ! 243: if( myftn != ftnno ){ /* beginning of function */ ! 244: maxoff = baseoff; ! 245: myftn = ftnno; ! 246: maxtemp = 0; ! 247: } ! 248: else { ! 249: if( baseoff > maxoff ) maxoff = baseoff; ! 250: /* maxoff at end of ftn is max of autos and temps over all blocks */ ! 251: } ! 252: setregs(); ! 253: } ! 254: ! 255: p2bend(){ ! 256: SETOFF( maxoff, ALSTACK ); ! 257: eobl2(); ! 258: } ! 259: ! 260: # endif ! 261: ! 262: NODE *deltrees[DELAYS]; ! 263: int deli; ! 264: ! 265: delay( p ) register NODE *p; { ! 266: /* look in all legal places for COMOP's and ++ and -- ops to delay */ ! 267: /* note; don't delay ++ and -- within calls or things like ! 268: /* getchar (in their macro forms) will start behaving strangely */ ! 269: register i; ! 270: ! 271: /* look for visible COMOPS, and rewrite repeatedly */ ! 272: ! 273: while( delay1( p ) ) { /* VOID */ } ! 274: ! 275: /* look for visible, delayable ++ and -- */ ! 276: ! 277: deli = 0; ! 278: delay2( p ); ! 279: codgen( p, FOREFF ); /* do what is left */ ! 280: for( i = 0; i<deli; ++i ) codgen( deltrees[i], FOREFF ); /* do the rest */ ! 281: } ! 282: ! 283: delay1( p ) register NODE *p; { /* look for COMOPS */ ! 284: register o, ty; ! 285: ! 286: o = p->in.op; ! 287: ty = optype( o ); ! 288: if( ty == LTYPE ) return( 0 ); ! 289: else if( ty == UTYPE ) return( delay1( p->in.left ) ); ! 290: ! 291: switch( o ){ ! 292: ! 293: case QUEST: ! 294: case ANDAND: ! 295: case OROR: ! 296: /* don't look on RHS */ ! 297: return( delay1(p->in.left ) ); ! 298: ! 299: case COMOP: /* the meat of the routine */ ! 300: delay( p->in.left ); /* completely evaluate the LHS */ ! 301: /* rewrite the COMOP */ ! 302: { register NODE *q; ! 303: q = p->in.right; ! 304: ncopy( p, p->in.right ); ! 305: q->in.op = FREE; ! 306: } ! 307: return( 1 ); ! 308: } ! 309: ! 310: return( delay1(p->in.left) || delay1(p->in.right ) ); ! 311: } ! 312: ! 313: delay2( p ) register NODE *p; { ! 314: ! 315: /* look for delayable ++ and -- operators */ ! 316: ! 317: register o, ty; ! 318: o = p->in.op; ! 319: ty = optype( o ); ! 320: ! 321: switch( o ){ ! 322: ! 323: case NOT: ! 324: case QUEST: ! 325: case ANDAND: ! 326: case OROR: ! 327: case CALL: ! 328: case UNARY CALL: ! 329: case STCALL: ! 330: case UNARY STCALL: ! 331: case FORTCALL: ! 332: case UNARY FORTCALL: ! 333: case COMOP: ! 334: case CBRANCH: ! 335: /* for the moment, don7t delay past a conditional context, or ! 336: /* inside of a call */ ! 337: return; ! 338: ! 339: case UNARY MUL: ! 340: /* if *p++, do not rewrite */ ! 341: if( autoincr( p ) ) return; ! 342: break; ! 343: ! 344: case INCR: ! 345: case DECR: ! 346: if( deltest( p ) ){ ! 347: if( deli < DELAYS ){ ! 348: register NODE *q; ! 349: deltrees[deli++] = tcopy(p); ! 350: q = p->in.left; ! 351: p->in.right->in.op = FREE; /* zap constant */ ! 352: ncopy( p, q ); ! 353: q->in.op = FREE; ! 354: return; ! 355: } ! 356: } ! 357: ! 358: } ! 359: ! 360: if( ty == BITYPE ) delay2( p->in.right ); ! 361: if( ty != LTYPE ) delay2( p->in.left ); ! 362: } ! 363: ! 364: codgen( p, cookie ) NODE *p; { ! 365: ! 366: /* generate the code for p; ! 367: order may call codgen recursively */ ! 368: /* cookie is used to describe the context */ ! 369: ! 370: for(;;){ ! 371: canon(p); /* creats OREG from * if possible and does sucomp */ ! 372: stotree = NIL; ! 373: # ifndef BUG4 ! 374: if( edebug ){ ! 375: printf( "store called on:\n" ); ! 376: fwalk( p, eprint, 0 ); ! 377: } ! 378: # endif ! 379: store(p); ! 380: if( stotree==NIL ) break; ! 381: ! 382: /* because it's minimal, can do w.o. stores */ ! 383: ! 384: order( stotree, stocook ); ! 385: } ! 386: ! 387: order( p, cookie ); ! 388: ! 389: } ! 390: ! 391: # ifndef BUG4 ! 392: char *cnames[] = { ! 393: "SANY", ! 394: "SAREG", ! 395: "STAREG", ! 396: "SBREG", ! 397: "STBREG", ! 398: "SCC", ! 399: "SNAME", ! 400: "SCON", ! 401: "SFLD", ! 402: "SOREG", ! 403: # ifdef WCARD1 ! 404: "WCARD1", ! 405: # else ! 406: "STARNM", ! 407: # endif ! 408: # ifdef WCARD2" ! 409: "WCARD2", ! 410: # else ! 411: "STARREG", ! 412: # endif ! 413: "INTEMP", ! 414: "FORARG", ! 415: "SWADD", ! 416: 0, ! 417: }; ! 418: ! 419: prcook( cookie ){ ! 420: ! 421: /* print a nice-looking description of cookie */ ! 422: ! 423: int i, flag; ! 424: ! 425: if( cookie & SPECIAL ){ ! 426: if( cookie == SZERO ) printf( "SZERO" ); ! 427: else if( cookie == SONE ) printf( "SONE" ); ! 428: else if( cookie == SMONE ) printf( "SMONE" ); ! 429: else printf( "SPECIAL+%d", cookie & ~SPECIAL ); ! 430: return; ! 431: } ! 432: ! 433: flag = 0; ! 434: for( i=0; cnames[i]; ++i ){ ! 435: if( cookie & (1<<i) ){ ! 436: if( flag ) printf( "|" ); ! 437: ++flag; ! 438: printf( cnames[i] ); ! 439: } ! 440: } ! 441: ! 442: } ! 443: # endif ! 444: ! 445: int odebug = 0; ! 446: ! 447: order(p,cook) NODE *p; { ! 448: ! 449: register o, ty, m; ! 450: int m1; ! 451: int cookie; ! 452: NODE *p1, *p2; ! 453: ! 454: cookie = cook; ! 455: rcount(); ! 456: canon(p); ! 457: rallo( p, p->in.rall ); ! 458: goto first; ! 459: /* by this time, p should be able to be generated without stores; ! 460: the only question is how */ ! 461: ! 462: again: ! 463: ! 464: if ( p->in.op == FREE ) ! 465: return; /* whole tree was done */ ! 466: cookie = cook; ! 467: rcount(); ! 468: canon(p); ! 469: rallo( p, p->in.rall ); ! 470: /* if any rewriting and canonicalization has put ! 471: * the tree (p) into a shape that cook is happy ! 472: * with (exclusive of FOREFF, FORREW, and INTEMP) ! 473: * then we are done. ! 474: * this allows us to call order with shapes in ! 475: * addition to cookies and stop short if possible. ! 476: */ ! 477: if( tshape(p, cook &(~(FOREFF|FORREW|INTEMP))) )return; ! 478: ! 479: first: ! 480: # ifndef BUG4 ! 481: if( odebug ){ ! 482: printf( "order( %o, ", p ); ! 483: prcook( cookie ); ! 484: printf( " )\n" ); ! 485: fwalk( p, eprint, 0 ); ! 486: } ! 487: # endif ! 488: ! 489: o = p->in.op; ! 490: ty = optype(o); ! 491: ! 492: /* first of all, for most ops, see if it is in the table */ ! 493: ! 494: /* look for ops */ ! 495: ! 496: switch( m = p->in.op ){ ! 497: ! 498: default: ! 499: /* look for op in table */ ! 500: for(;;){ ! 501: if( (m = match( p, cookie ) ) == MDONE ) goto cleanup; ! 502: else if( m == MNOPE ){ ! 503: if( !(cookie = nextcook( p, cookie ) ) ) goto nomat; ! 504: continue; ! 505: } ! 506: else break; ! 507: } ! 508: break; ! 509: ! 510: case COMOP: ! 511: case FORCE: ! 512: case CBRANCH: ! 513: case QUEST: ! 514: case ANDAND: ! 515: case OROR: ! 516: case NOT: ! 517: case UNARY CALL: ! 518: case CALL: ! 519: case UNARY STCALL: ! 520: case STCALL: ! 521: case UNARY FORTCALL: ! 522: case FORTCALL: ! 523: /* don't even go near the table... */ ! 524: ; ! 525: ! 526: } ! 527: /* get here to do rewriting if no match or ! 528: fall through from above for hard ops */ ! 529: ! 530: p1 = p->in.left; ! 531: if( ty == BITYPE ) p2 = p->in.right; ! 532: else p2 = NIL; ! 533: ! 534: # ifndef BUG4 ! 535: if( odebug ){ ! 536: printf( "order( %o, ", p ); ! 537: prcook( cook ); ! 538: printf( " ), cookie " ); ! 539: prcook( cookie ); ! 540: printf( ", rewrite %s\n", opst[m] ); ! 541: } ! 542: # endif ! 543: switch( m ){ ! 544: default: ! 545: nomat: ! 546: cerror( "no table entry for op %s", opst[p->in.op] ); ! 547: ! 548: case COMOP: ! 549: codgen( p1, FOREFF ); ! 550: p2->in.rall = p->in.rall; ! 551: codgen( p2, cookie ); ! 552: ncopy( p, p2 ); ! 553: p2->in.op = FREE; ! 554: goto cleanup; ! 555: ! 556: case FORCE: ! 557: /* recurse, letting the work be done by rallo */ ! 558: p = p->in.left; ! 559: cook = INTAREG|INTBREG; ! 560: goto again; ! 561: ! 562: case CBRANCH: ! 563: o = p2->tn.lval; ! 564: cbranch( p1, -1, o ); ! 565: p2->in.op = FREE; ! 566: p->in.op = FREE; ! 567: return; ! 568: ! 569: case QUEST: ! 570: cbranch( p1, -1, m=getlab() ); ! 571: p2->in.left->in.rall = p->in.rall; ! 572: codgen( p2->in.left, INTAREG|INTBREG ); ! 573: /* force right to compute result into same reg used by left */ ! 574: p2->in.right->in.rall = p2->in.left->tn.rval|MUSTDO; ! 575: reclaim( p2->in.left, RNULL, 0 ); ! 576: cbgen( 0, m1 = getlab(), 'I' ); ! 577: deflab( m ); ! 578: codgen( p2->in.right, INTAREG|INTBREG ); ! 579: deflab( m1 ); ! 580: p->in.op = REG; /* set up node describing result */ ! 581: p->tn.lval = 0; ! 582: p->tn.rval = p2->in.right->tn.rval; ! 583: p->in.type = p2->in.right->in.type; ! 584: tfree( p2->in.right ); ! 585: p2->in.op = FREE; ! 586: goto cleanup; ! 587: ! 588: case ANDAND: ! 589: case OROR: ! 590: case NOT: /* logical operators */ ! 591: /* if here, must be a logical operator for 0-1 value */ ! 592: cbranch( p, -1, m=getlab() ); ! 593: p->in.op = CCODES; ! 594: p->bn.label = m; ! 595: order( p, INTAREG ); ! 596: goto cleanup; ! 597: ! 598: case FLD: /* fields of funny type */ ! 599: if ( p1->in.op == UNARY MUL ){ ! 600: offstar( p1->in.left, cook ); ! 601: goto again; ! 602: } ! 603: ! 604: case UNARY MINUS: ! 605: order( p1, INBREG|INAREG ); ! 606: goto again; ! 607: ! 608: case NAME: ! 609: /* all leaves end up here ... */ ! 610: if( o == REG ) goto nomat; ! 611: order( p, INTAREG|INTBREG ); ! 612: goto again; ! 613: ! 614: case INIT: ! 615: uerror( "illegal initialization" ); ! 616: return; ! 617: ! 618: case UNARY FORTCALL: ! 619: p->in.right = NIL; ! 620: case FORTCALL: ! 621: o = p->in.op = UNARY FORTCALL; ! 622: if( genfcall( p, cookie ) ) goto nomat; ! 623: goto cleanup; ! 624: ! 625: case UNARY CALL: ! 626: p->in.right = NIL; ! 627: case CALL: ! 628: o = p->in.op = UNARY CALL; ! 629: if( gencall( p, cookie ) ) goto nomat; ! 630: goto cleanup; ! 631: ! 632: case UNARY STCALL: ! 633: p->in.right = NIL; ! 634: case STCALL: ! 635: o = p->in.op = UNARY STCALL; ! 636: if( genscall( p, cookie ) ) goto nomat; ! 637: goto cleanup; ! 638: ! 639: /* if arguments are passed in register, care must be taken that reclaim ! 640: /* not throw away the register which now has the result... */ ! 641: ! 642: case UNARY MUL: ! 643: if( cook == FOREFF ){ ! 644: /* do nothing */ ! 645: order( p->in.left, FOREFF ); ! 646: p->in.op = FREE; ! 647: return; ! 648: } ! 649: offstar( p->in.left, cook ); ! 650: goto again; ! 651: ! 652: case INCR: /* INCR and DECR */ ! 653: if( setincr(p, cook) ) goto again; ! 654: ! 655: /* x++ becomes (x += 1) -1; */ ! 656: ! 657: if( cook & FOREFF ){ /* result not needed so inc or dec and be done with it */ ! 658: /* x++ => x += 1 */ ! 659: p->in.op = (p->in.op==INCR)?ASG PLUS:ASG MINUS; ! 660: goto again; ! 661: } ! 662: ! 663: p1 = tcopy(p); ! 664: reclaim( p->in.left, RNULL, 0 ); ! 665: p->in.left = p1; ! 666: p1->in.op = (p->in.op==INCR)?ASG PLUS:ASG MINUS; ! 667: p->in.op = (p->in.op==INCR)?MINUS:PLUS; ! 668: goto again; ! 669: ! 670: case STASG: ! 671: if( setstr( p, cook ) ) goto again; ! 672: goto nomat; ! 673: ! 674: case ASG PLUS: /* and other assignment ops */ ! 675: if( setasop(p, cook) ) goto again; ! 676: ! 677: /* there are assumed to be no side effects in LHS */ ! 678: ! 679: p2 = tcopy(p); ! 680: p->in.op = ASSIGN; ! 681: reclaim( p->in.right, RNULL, 0 ); ! 682: p->in.right = p2; ! 683: canon(p); ! 684: rallo( p, p->in.rall ); ! 685: ! 686: # ifndef BUG4 ! 687: if( odebug ) fwalk( p, eprint, 0 ); ! 688: # endif ! 689: ! 690: order( p2->in.left, INTBREG|INTAREG ); ! 691: order( p2, INTBREG|INTAREG ); ! 692: goto again; ! 693: ! 694: case ASSIGN: ! 695: if( setasg( p, cook ) ) goto again; ! 696: goto nomat; ! 697: ! 698: ! 699: case BITYPE: ! 700: if( setbin( p, cook ) ) goto again; ! 701: /* try to replace binary ops by =ops */ ! 702: switch(o){ ! 703: ! 704: case PLUS: ! 705: case MINUS: ! 706: case MUL: ! 707: case DIV: ! 708: case MOD: ! 709: case AND: ! 710: case OR: ! 711: case ER: ! 712: case LS: ! 713: case RS: ! 714: p->in.op = ASG o; ! 715: goto again; ! 716: } ! 717: goto nomat; ! 718: ! 719: } ! 720: ! 721: cleanup: ! 722: ! 723: /* if it is not yet in the right state, put it there */ ! 724: ! 725: if( cook & FOREFF ){ ! 726: reclaim( p, RNULL, 0 ); ! 727: return; ! 728: } ! 729: ! 730: if( p->in.op==FREE ) return; ! 731: ! 732: if( tshape( p, cook ) ) return; ! 733: ! 734: if( (m=match(p,cook) ) == MDONE ) return; ! 735: ! 736: /* we are in bad shape, try one last chance */ ! 737: if( lastchance( p, cook ) ) goto again; ! 738: ! 739: goto nomat; ! 740: } ! 741: ! 742: int callflag; ! 743: int fregs; ! 744: ! 745: store( p ) register NODE *p; { ! 746: ! 747: /* find a subtree of p which should be stored */ ! 748: ! 749: register o, ty; ! 750: ! 751: o = p->in.op; ! 752: ty = optype(o); ! 753: ! 754: if( ty == LTYPE ) return; ! 755: ! 756: switch( o ){ ! 757: ! 758: case UNARY CALL: ! 759: case UNARY FORTCALL: ! 760: case UNARY STCALL: ! 761: ++callflag; ! 762: break; ! 763: ! 764: case UNARY MUL: ! 765: if( asgop(p->in.left->in.op) ) stoasg( p->in.left, UNARY MUL ); ! 766: break; ! 767: ! 768: case CALL: ! 769: case FORTCALL: ! 770: case STCALL: ! 771: store( p->in.left ); ! 772: stoarg( p->in.right, o ); ! 773: ++callflag; ! 774: return; ! 775: ! 776: case COMOP: ! 777: markcall( p->in.right ); ! 778: if( p->in.right->in.su > fregs ) SETSTO( p, INTEMP ); ! 779: store( p->in.left ); ! 780: return; ! 781: ! 782: case ANDAND: ! 783: case OROR: ! 784: case QUEST: ! 785: markcall( p->in.right ); ! 786: if( p->in.right->in.su > fregs ) SETSTO( p, INTEMP ); ! 787: case CBRANCH: /* to prevent complicated expressions on the LHS from being stored */ ! 788: case NOT: ! 789: constore( p->in.left ); ! 790: return; ! 791: ! 792: } ! 793: ! 794: if( ty == UTYPE ){ ! 795: store( p->in.left ); ! 796: return; ! 797: } ! 798: ! 799: if( asgop( p->in.right->in.op ) ) stoasg( p->in.right, o ); ! 800: ! 801: if( p->in.su>fregs ){ /* must store */ ! 802: mkadrs( p ); /* set up stotree and stocook to subtree ! 803: that must be stored */ ! 804: } ! 805: ! 806: store( p->in.right ); ! 807: store( p->in.left ); ! 808: } ! 809: ! 810: constore( p ) register NODE *p; { ! 811: ! 812: /* store conditional expressions */ ! 813: /* the point is, avoid storing expressions in conditional ! 814: conditional context, since the evaluation order is predetermined */ ! 815: ! 816: switch( p->in.op ) { ! 817: ! 818: case ANDAND: ! 819: case OROR: ! 820: case QUEST: ! 821: markcall( p->in.right ); ! 822: case NOT: ! 823: constore( p->in.left ); ! 824: return; ! 825: ! 826: } ! 827: ! 828: store( p ); ! 829: } ! 830: ! 831: markcall( p ) register NODE *p; { /* mark off calls below the current node */ ! 832: ! 833: again: ! 834: switch( p->in.op ){ ! 835: ! 836: case UNARY CALL: ! 837: case UNARY STCALL: ! 838: case UNARY FORTCALL: ! 839: case CALL: ! 840: case STCALL: ! 841: case FORTCALL: ! 842: ++callflag; ! 843: return; ! 844: ! 845: } ! 846: ! 847: switch( optype( p->in.op ) ){ ! 848: ! 849: case BITYPE: ! 850: markcall( p->in.right ); ! 851: case UTYPE: ! 852: p = p->in.left; ! 853: /* eliminate recursion (aren't I clever...) */ ! 854: goto again; ! 855: case LTYPE: ! 856: return; ! 857: } ! 858: ! 859: } ! 860: ! 861: stoarg( p, calltype ) register NODE *p; { ! 862: /* arrange to store the args */ ! 863: ! 864: if( p->in.op == CM ){ ! 865: stoarg( p->in.left, calltype ); ! 866: p = p->in.right ; ! 867: } ! 868: if( calltype == CALL ){ ! 869: STOARG(p); ! 870: } ! 871: else if( calltype == STCALL ){ ! 872: STOSTARG(p); ! 873: } ! 874: else { ! 875: STOFARG(p); ! 876: } ! 877: callflag = 0; ! 878: store(p); ! 879: # ifndef NESTCALLS ! 880: if( callflag ){ /* prevent two calls from being active at once */ ! 881: SETSTO(p,INTEMP); ! 882: store(p); /* do again to preserve bottom up nature.... */ ! 883: } ! 884: #endif ! 885: } ! 886: ! 887: int negrel[] = { NE, EQ, GT, GE, LT, LE, UGT, UGE, ULT, ULE } ; /* negatives of relationals */ ! 888: ! 889: cbranch( p, true, false ) NODE *p; { ! 890: /* evaluate p for truth value, and branch to true or false ! 891: /* accordingly: label <0 means fall through */ ! 892: ! 893: register o, lab, flab, tlab; ! 894: ! 895: lab = -1; ! 896: ! 897: switch( o=p->in.op ){ ! 898: ! 899: case ULE: ! 900: case ULT: ! 901: case UGE: ! 902: case UGT: ! 903: case EQ: ! 904: case NE: ! 905: case LE: ! 906: case LT: ! 907: case GE: ! 908: case GT: ! 909: if( true < 0 ){ ! 910: o = p->in.op = negrel[ o-EQ ]; ! 911: true = false; ! 912: false = -1; ! 913: } ! 914: #ifndef NOOPT ! 915: if( p->in.right->in.op == ICON && p->in.right->tn.lval == 0 && p->in.right->in.name[0] == '\0' ){ ! 916: switch( o ){ ! 917: ! 918: case UGT: ! 919: case ULE: ! 920: o = p->in.op = (o==UGT)?NE:EQ; ! 921: case EQ: ! 922: case NE: ! 923: case LE: ! 924: case LT: ! 925: case GE: ! 926: case GT: ! 927: if( logop(p->in.left->in.op) ){ ! 928: /* strange situation: e.g., (a!=0) == 0 */ ! 929: /* must prevent reference to p->in.left->lable, so get 0/1 */ ! 930: /* we could optimize, but why bother */ ! 931: codgen( p->in.left, INAREG|INBREG ); ! 932: } ! 933: codgen( p->in.left, FORCC ); ! 934: cbgen( o, true, 'I' ); ! 935: break; ! 936: ! 937: case UGE: ! 938: codgen(p->in.left, FORCC); ! 939: cbgen( 0, true, 'I' ); /* unconditional branch */ ! 940: break; ! 941: case ULT: ! 942: codgen(p->in.left, FORCC); ! 943: } ! 944: } ! 945: else ! 946: #endif ! 947: { ! 948: p->bn.label = true; ! 949: codgen( p, FORCC ); ! 950: } ! 951: if( false>=0 ) cbgen( 0, false, 'I' ); ! 952: reclaim( p, RNULL, 0 ); ! 953: return; ! 954: ! 955: case ANDAND: ! 956: lab = false<0 ? getlab() : false ; ! 957: cbranch( p->in.left, -1, lab ); ! 958: cbranch( p->in.right, true, false ); ! 959: if( false < 0 ) deflab( lab ); ! 960: p->in.op = FREE; ! 961: return; ! 962: ! 963: case OROR: ! 964: lab = true<0 ? getlab() : true; ! 965: cbranch( p->in.left, lab, -1 ); ! 966: cbranch( p->in.right, true, false ); ! 967: if( true < 0 ) deflab( lab ); ! 968: p->in.op = FREE; ! 969: return; ! 970: ! 971: case NOT: ! 972: cbranch( p->in.left, false, true ); ! 973: p->in.op = FREE; ! 974: break; ! 975: ! 976: case COMOP: ! 977: codgen( p->in.left, FOREFF ); ! 978: p->in.op = FREE; ! 979: cbranch( p->in.right, true, false ); ! 980: return; ! 981: ! 982: case QUEST: ! 983: flab = false<0 ? getlab() : false; ! 984: tlab = true<0 ? getlab() : true; ! 985: cbranch( p->in.left, -1, lab = getlab() ); ! 986: cbranch( p->in.right->in.left, tlab, flab ); ! 987: deflab( lab ); ! 988: cbranch( p->in.right->in.right, true, false ); ! 989: if( true < 0 ) deflab( tlab); ! 990: if( false < 0 ) deflab( flab ); ! 991: p->in.right->in.op = FREE; ! 992: p->in.op = FREE; ! 993: return; ! 994: ! 995: case ICON: ! 996: if( p->in.type != FLOAT && p->in.type != DOUBLE ){ ! 997: ! 998: if( p->tn.lval || p->in.name[0] ){ ! 999: /* addresses of C objects are never 0 */ ! 1000: if( true>=0 ) cbgen( 0, true, 'I' ); ! 1001: } ! 1002: else if( false>=0 ) cbgen( 0, false, 'I' ); ! 1003: p->in.op = FREE; ! 1004: return; ! 1005: } ! 1006: /* fall through to default with other strange constants */ ! 1007: ! 1008: default: ! 1009: /* get condition codes */ ! 1010: codgen( p, FORCC ); ! 1011: if( true >= 0 ) cbgen( NE, true, 'I' ); ! 1012: if( false >= 0 ) cbgen( true >= 0 ? 0 : EQ, false, 'I' ); ! 1013: reclaim( p, RNULL, 0 ); ! 1014: return; ! 1015: ! 1016: } ! 1017: ! 1018: } ! 1019: ! 1020: rcount(){ /* count recursions */ ! 1021: if( ++nrecur > NRECUR ){ ! 1022: cerror( "expression causes compiler loop: try simplifying" ); ! 1023: } ! 1024: ! 1025: } ! 1026: ! 1027: # ifndef BUG4 ! 1028: eprint( p, down, a, b ) NODE *p; int *a, *b; { ! 1029: ! 1030: *a = *b = down+1; ! 1031: while( down >= 2 ){ ! 1032: printf( "\t" ); ! 1033: down -= 2; ! 1034: } ! 1035: if( down-- ) printf( " " ); ! 1036: ! 1037: ! 1038: printf( "%o) %s", p, opst[p->in.op] ); ! 1039: switch( p->in.op ) { /* special cases */ ! 1040: ! 1041: case REG: ! 1042: printf( " %s", rnames[p->tn.rval] ); ! 1043: break; ! 1044: ! 1045: case ICON: ! 1046: case NAME: ! 1047: case OREG: ! 1048: printf( " " ); ! 1049: adrput( p ); ! 1050: break; ! 1051: ! 1052: case STCALL: ! 1053: case UNARY STCALL: ! 1054: case STARG: ! 1055: case STASG: ! 1056: printf( " size=%d", p->stn.stsize ); ! 1057: printf( " align=%d", p->stn.stalign ); ! 1058: break; ! 1059: } ! 1060: ! 1061: printf( ", " ); ! 1062: tprint( p->in.type ); ! 1063: printf( ", " ); ! 1064: if( p->in.rall == NOPREF ) printf( "NOPREF" ); ! 1065: else { ! 1066: if( p->in.rall & MUSTDO ) printf( "MUSTDO " ); ! 1067: else printf( "PREF " ); ! 1068: printf( "%s", rnames[p->in.rall&~MUSTDO]); ! 1069: } ! 1070: printf( ", SU= %d\n", p->in.su ); ! 1071: ! 1072: } ! 1073: # endif ! 1074: ! 1075: # ifndef NOMAIN ! 1076: NODE * ! 1077: eread(){ ! 1078: ! 1079: /* call eread recursively to get subtrees, if any */ ! 1080: ! 1081: register NODE *p; ! 1082: register i, c; ! 1083: register char *pc; ! 1084: register j; ! 1085: ! 1086: i = rdin( 10 ); ! 1087: ! 1088: p = talloc(); ! 1089: ! 1090: p->in.op = i; ! 1091: ! 1092: i = optype(i); ! 1093: ! 1094: if( i == LTYPE ) p->tn.lval = rdin( 10 ); ! 1095: if( i != BITYPE ) p->tn.rval = rdin( 10 ); ! 1096: ! 1097: p->in.type = rdin(8 ); ! 1098: p->in.rall = NOPREF; /* register allocation information */ ! 1099: ! 1100: if( p->in.op == STASG || p->in.op == STARG || p->in.op == STCALL || p->in.op == UNARY STCALL ){ ! 1101: p->stn.stsize = (rdin( 10 ) + (SZCHAR-1) )/SZCHAR; ! 1102: p->stn.stalign = rdin(10) / SZCHAR; ! 1103: if( getchar() != '\n' ) cerror( "illegal \n" ); ! 1104: } ! 1105: else { /* usual case */ ! 1106: if( p->in.op == REG ) rbusy( p->tn.rval, p->in.type ); /* non usually, but sometimes justified */ ! 1107: #ifndef FLEXNAMES ! 1108: for( pc=p->in.name,j=0; ( c = getchar() ) != '\n'; ++j ){ ! 1109: if( j < NCHNAM ) *pc++ = c; ! 1110: } ! 1111: if( j < NCHNAM ) *pc = '\0'; ! 1112: #else ! 1113: { char buf[BUFSIZ]; ! 1114: for( pc=buf,j=0; ( c = getchar() ) != '\n'; ++j ){ ! 1115: if( j < BUFSIZ ) *pc++ = c; ! 1116: } ! 1117: if( j < BUFSIZ ) *pc = '\0'; ! 1118: p->in.name = tstr(buf); ! 1119: } ! 1120: #endif ! 1121: } ! 1122: ! 1123: /* now, recursively read descendents, if any */ ! 1124: ! 1125: if( i != LTYPE ) p->in.left = eread(); ! 1126: if( i == BITYPE ) p->in.right = eread(); ! 1127: ! 1128: return( p ); ! 1129: ! 1130: } ! 1131: ! 1132: CONSZ ! 1133: rdin( base ){ ! 1134: register sign, c; ! 1135: CONSZ val; ! 1136: ! 1137: sign = 1; ! 1138: val = 0; ! 1139: ! 1140: while( (c=getchar()) > 0 ) { ! 1141: if( c == '-' ){ ! 1142: if( val != 0 ) cerror( "illegal -"); ! 1143: sign = -sign; ! 1144: continue; ! 1145: } ! 1146: if( c == '\t' ) break; ! 1147: if( c>='0' && c<='9' ) { ! 1148: val *= base; ! 1149: if( sign > 0 ) ! 1150: val += c-'0'; ! 1151: else ! 1152: val -= c-'0'; ! 1153: continue; ! 1154: } ! 1155: cerror( "illegal character `%c' on intermediate file", c ); ! 1156: break; ! 1157: } ! 1158: ! 1159: if( c <= 0 ) { ! 1160: cerror( "unexpected EOF"); ! 1161: } ! 1162: return( val ); ! 1163: } ! 1164: # endif ! 1165: ! 1166: #ifndef FIELDOPS ! 1167: /* do this if there is no special hardware support for fields */ ! 1168: ! 1169: ffld( p, down, down1, down2 ) NODE *p; int *down1, *down2; { ! 1170: /* look for fields that are not in an lvalue context, and rewrite them... */ ! 1171: register NODE *shp; ! 1172: register s, o, v, ty; ! 1173: ! 1174: *down1 = asgop( p->in.op ); ! 1175: *down2 = 0; ! 1176: ! 1177: if( !down && p->in.op == FLD ){ /* rewrite the node */ ! 1178: ! 1179: if( !rewfld(p) ) return; ! 1180: ! 1181: ty = (szty(p->in.type) == 2)? LONG: INT; ! 1182: v = p->tn.rval; ! 1183: s = UPKFSZ(v); ! 1184: # ifdef RTOLBYTES ! 1185: o = UPKFOFF(v); /* amount to shift */ ! 1186: # else ! 1187: o = szty(p->in.type)*SZINT - s - UPKFOFF(v); /* amount to shift */ ! 1188: #endif ! 1189: ! 1190: /* make & mask part */ ! 1191: ! 1192: p->in.left->in.type = ty; ! 1193: ! 1194: p->in.op = AND; ! 1195: p->in.right = talloc(); ! 1196: p->in.right->in.op = ICON; ! 1197: p->in.right->in.rall = NOPREF; ! 1198: p->in.right->in.type = ty; ! 1199: p->in.right->tn.lval = 1; ! 1200: p->in.right->tn.rval = 0; ! 1201: #ifndef FLEXNAMES ! 1202: p->in.right->in.name[0] = '\0'; ! 1203: #else ! 1204: p->in.right->in.name = ""; ! 1205: #endif ! 1206: p->in.right->tn.lval <<= s; ! 1207: p->in.right->tn.lval--; ! 1208: ! 1209: /* now, if a shift is needed, do it */ ! 1210: ! 1211: if( o != 0 ){ ! 1212: shp = talloc(); ! 1213: shp->in.op = RS; ! 1214: shp->in.rall = NOPREF; ! 1215: shp->in.type = ty; ! 1216: shp->in.left = p->in.left; ! 1217: shp->in.right = talloc(); ! 1218: shp->in.right->in.op = ICON; ! 1219: shp->in.right->in.rall = NOPREF; ! 1220: shp->in.right->in.type = ty; ! 1221: shp->in.right->tn.rval = 0; ! 1222: shp->in.right->tn.lval = o; /* amount to shift */ ! 1223: #ifndef FLEXNAMES ! 1224: shp->in.right->in.name[0] = '\0'; ! 1225: #else ! 1226: shp->in.right->in.name = ""; ! 1227: #endif ! 1228: p->in.left = shp; ! 1229: /* whew! */ ! 1230: } ! 1231: } ! 1232: } ! 1233: #endif ! 1234: ! 1235: oreg2( p ) register NODE *p; { ! 1236: ! 1237: /* look for situations where we can turn * into OREG */ ! 1238: ! 1239: NODE *q; ! 1240: register i; ! 1241: register r; ! 1242: register char *cp; ! 1243: register NODE *ql, *qr; ! 1244: CONSZ temp; ! 1245: ! 1246: if( p->in.op == UNARY MUL ){ ! 1247: q = p->in.left; ! 1248: if( q->in.op == REG ){ ! 1249: temp = q->tn.lval; ! 1250: r = q->tn.rval; ! 1251: cp = q->in.name; ! 1252: goto ormake; ! 1253: } ! 1254: ! 1255: if( q->in.op != PLUS && q->in.op != MINUS ) return; ! 1256: ql = q->in.left; ! 1257: qr = q->in.right; ! 1258: ! 1259: #ifdef R2REGS ! 1260: ! 1261: /* look for doubly indexed expressions */ ! 1262: ! 1263: if( q->in.op == PLUS) { ! 1264: if( (r=base(ql))>=0 && (i=offset(qr, tlen(p)))>=0) { ! 1265: makeor2(p, ql, r, i); ! 1266: return; ! 1267: } else if( (r=base(qr))>=0 && (i=offset(ql, tlen(p)))>=0) { ! 1268: makeor2(p, qr, r, i); ! 1269: return; ! 1270: } ! 1271: } ! 1272: ! 1273: ! 1274: #endif ! 1275: ! 1276: if( (q->in.op==PLUS || q->in.op==MINUS) && qr->in.op == ICON && ! 1277: ql->in.op==REG && szty(qr->in.type)==1) { ! 1278: temp = qr->tn.lval; ! 1279: if( q->in.op == MINUS ) temp = -temp; ! 1280: r = ql->tn.rval; ! 1281: temp += ql->tn.lval; ! 1282: cp = qr->in.name; ! 1283: if( *cp && ( q->in.op == MINUS || *ql->in.name ) ) return; ! 1284: if( !*cp ) cp = ql->in.name; ! 1285: ! 1286: ormake: ! 1287: if( notoff( p->in.type, r, temp, cp ) ) return; ! 1288: p->in.op = OREG; ! 1289: p->tn.rval = r; ! 1290: p->tn.lval = temp; ! 1291: #ifndef FLEXNAMES ! 1292: for( i=0; i<NCHNAM; ++i ) ! 1293: p->in.name[i] = *cp++; ! 1294: #else ! 1295: p->in.name = cp; ! 1296: #endif ! 1297: tfree(q); ! 1298: return; ! 1299: } ! 1300: } ! 1301: ! 1302: } ! 1303: ! 1304: canon(p) NODE *p; { ! 1305: /* put p in canonical form */ ! 1306: int oreg2(), sucomp(); ! 1307: ! 1308: #ifndef FIELDOPS ! 1309: int ffld(); ! 1310: fwalk( p, ffld, 0 ); /* look for field operators */ ! 1311: # endif ! 1312: walkf( p, oreg2 ); /* look for and create OREG nodes */ ! 1313: #ifdef MYCANON ! 1314: MYCANON(p); /* your own canonicalization routine(s) */ ! 1315: #endif ! 1316: walkf( p, sucomp ); /* do the Sethi-Ullman computation */ ! 1317: ! 1318: } ! 1319:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.