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