![[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 [Research Unix] / researchv10no / cmd / ccom / common|
Return to reader.c CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / common |
1.1 ! root 1: /* @(#) reader.c : 1.7 3/5/84 */ ! 2: ! 3: # include "mfile2.h" ! 4: ! 5: /* some storage declarations */ ! 6: ! 7: # ifdef TWOPASS ! 8: NODE node[TREESZ]; ! 9: char ftitle[100] = "\"\""; /* the name of the file */ ! 10: int ftnno; /* number of current function */ ! 11: int lineno; ! 12: #endif ! 13: ! 14: int lflag; ! 15: int e2debug; ! 16: int udebug; ! 17: int fast; ! 18: ! 19: /* maxtemp is the maximum size (in bits) needed for temps so far */ ! 20: /* maxarg is ditto for outgoing arguments */ ! 21: /* maxboff is ditto for automatic variables */ ! 22: /* earlier attempts to keep these on a per-block basis were silly */ ! 23: int maxtemp; ! 24: extern int maxarg; ! 25: int maxboff; ! 26: NODE *condit(), *prepass(); ! 27: ! 28: NODE * ! 29: force(p) ! 30: register NODE *p; ! 31: { ! 32: register NODE *q, *r; ! 33: if( !p ) cerror( "force" ); ! 34: q = talloc(); ! 35: *q = *p; ! 36: r = talloc(); ! 37: *r = *p; ! 38: q->tn.op = ASSIGN; ! 39: q->in.right = p; ! 40: q->in.left = r; ! 41: r->tn.op = QNODE; ! 42: r->tn.rval = callreg(p); /* the reg where the value will be forced */ ! 43: return( q ); ! 44: } ! 45: ! 46: int odebug = 0, rdebug = 0, sdebug = 0; ! 47: ! 48: p2init( argc, argv ) ! 49: char *argv[]; ! 50: { ! 51: /* set the values of the pass 2 arguments */ ! 52: ! 53: register int c; extern int syncstdio; ! 54: register char *cp; ! 55: register files; ! 56: ! 57: allo0(); /* free all regs */ ! 58: files = 0; ! 59: ! 60: for( c=1; c<argc; ++c ) ! 61: { ! 62: if( *(cp=argv[c]) == '-' ) ! 63: { ! 64: while( *++cp ) ! 65: { ! 66: switch(++syncstdio, *cp) ! 67: { ! 68: ! 69: case 'X': /* pass1 flags */ ! 70: while( *++cp ) ! 71: { ! 72: /* VOID */ ! 73: } ! 74: --syncstdio; ! 75: --cp; ! 76: break; ! 77: # ifdef GDEBUG ! 78: #define LL_TOP 0 /* from mfile1.h */ ! 79: case 'g': /* another stab in the back */ ! 80: { ! 81: extern int gdebug; ! 82: extern int wloop_level, floop_level; ! 83: gdebug = !gdebug; ! 84: wloop_level = LL_TOP; /* natural */ ! 85: floop_level = LL_TOP; /* loops */ ! 86: } /* fall through */ ! 87: # endif ! 88: case 'l': /* linenos */ ! 89: --syncstdio; ! 90: ++lflag; ! 91: break; ! 92: ! 93: case 'e': /* expressions */ ! 94: ++e2debug; ! 95: break; ! 96: ! 97: case 'o': /* orders */ ! 98: ++odebug; ! 99: break; ! 100: ! 101: case 'r': /* register allocation */ ! 102: ++rdebug; ! 103: break; ! 104: ! 105: case 's': /* shapes */ ! 106: ++sdebug; ! 107: break; ! 108: ! 109: case 'u': /* Sethi-Ullman testing ! 110: (machine dependent) */ ! 111: ++udebug; ! 112: break; ! 113: ! 114: case 'f': /* try for faster compile speed */ ! 115: ++fast; ! 116: break; ! 117: ! 118: default: ! 119: cerror( "bad option: %c", *cp ); ! 120: } ! 121: } ! 122: } ! 123: else files = 1; /* assumed to be a ftitle */ ! 124: } ! 125: ! 126: mkdope(); ! 127: return( files ); ! 128: } ! 129: ! 130: NODE * ! 131: dlabel( p, l ) ! 132: register NODE *p; ! 133: { ! 134: /* define a label after p is executed */ ! 135: register NODE *q; ! 136: ! 137: /* condit will throw away things, fix here ! 138: /* if( !p ) cerror( "dlabel" ); ! 139: */ ! 140: if (!p) /* create conventional dumb subtree */ ! 141: { ! 142: p = talloc(); ! 143: p->tn.op = ICON; ! 144: p->tn.name = NULL; ! 145: p->tn.lval = 0; ! 146: p->tn.type = TINT; ! 147: } ! 148: q = talloc(); ! 149: q->tn.type = p->tn.type; ! 150: q->in.left = p; ! 151: q->tn.op = GENLAB; ! 152: q->bn.label = l; ! 153: return( q ); ! 154: } ! 155: ! 156: ! 157: NODE * ! 158: genbr( o, l, p ) ! 159: register NODE *p; ! 160: register o,l; ! 161: { ! 162: /* after evaluating p, generate a branch to l */ ! 163: /* if o is 0, unconditional */ ! 164: register NODE *q; ! 165: if( !p ) cerror( "genbr" ); ! 166: if( l < 0 ) cerror( "genbr1" ); ! 167: q = talloc(); ! 168: q->tn.op = o?GENBR:GENUBR; ! 169: q->tn.type = p->tn.type; ! 170: q->in.left = p; ! 171: q->bn.label = l; ! 172: q->bn.lop = o; ! 173: if( o && logop(p->tn.op) && ! 174: (p->tn.op != ANDAND) ! 175: && (p->tn.op != OROR) ! 176: ) p->tn.op = CMP; ! 177: return( q ); ! 178: } ! 179: ! 180: ! 181: static NODE * ! 182: oreff(p) ! 183: register NODE *p; ! 184: { ! 185: register NODE *r, *l; ! 186: NODE *condit(), *seq(); ! 187: int lab, t, f; ! 188: /* oreff is called if an || op is evaluated with goal=CEFF ! 189: The rhs of || ops should be executed only if the ! 190: lhs is false. Since our goal is CEFF, we don't need ! 191: a result of the ||, but we need to ! 192: preserve that dependancy with this special case */ ! 193: ! 194: /* We must catch this case before its children are ! 195: condit() and change the goal on it left child to CCC */ ! 196: ! 197: if (tcond(p->in.left)) { ! 198: tfree(p->in.right); ! 199: p->in.op = FREE; ! 200: p = condit( p->in.left, CEFF, -1, -1); ! 201: } else if (fcond(p->in.left)) { ! 202: p->in.op = COMOP; ! 203: p = condit( p, CEFF, -1, -1); ! 204: } else { ! 205: lab = getlab(); ! 206: l = condit( p->in.left, CCC, lab, -1); ! 207: r = condit( p->in.right, CEFF, -1, -1); ! 208: p->in.op = FREE; ! 209: p = seq(l, r); /* put r after l */ ! 210: p = dlabel(p, lab); ! 211: } ! 212: return p; ! 213: } ! 214: static NODE * ! 215: andeff(p) ! 216: register NODE *p; ! 217: { ! 218: register NODE *r, *l; ! 219: NODE *condit(); ! 220: int lab, t, f; ! 221: /* andeff is called if an && op is evaluated with goal=CEFF ! 222: The rhs of && ops should be executed only if the ! 223: lhs is true. Since our goal is CEFF, we don't need ! 224: a result of the &&, but we need to ! 225: preserve that dependancy with this special case */ ! 226: ! 227: /* We must catch this case before its children are ! 228: condit() and change the goal on it left child to CCC */ ! 229: ! 230: if (fcond(p->in.left)) { ! 231: tfree(p->in.right); ! 232: p->in.op = FREE; ! 233: p = condit( p->in.left, CEFF, -1, -1); ! 234: } else if (tcond(p->in.left)) { ! 235: p->in.op = COMOP; ! 236: p = condit( p, CEFF, -1, -1); ! 237: } else { ! 238: lab = getlab(); ! 239: p->in.op = FREE; ! 240: l = condit( p->in.left, CCC, -1, lab); ! 241: r = condit( p->in.right, CEFF, -1, -1); ! 242: p = seq(l, r); /* put r after l */ ! 243: p = dlabel(p, lab); ! 244: } ! 245: return p; ! 246: } ! 247: int negrel[] = ! 248: { ! 249: NE, EQ, GT, GE, LT, LE, UGT, UGE, ULT, ULE ! 250: } ; /* negatives of relationals */ ! 251: ! 252: tcond( p ) ! 253: register NODE *p; ! 254: { ! 255: /* return 1 if p is always true, 0 otherwise */ ! 256: register o = p->tn.op; ! 257: register NODE *q; ! 258: ! 259: switch( o ) ! 260: { ! 261: ! 262: case ICON: ! 263: return( p->tn.lval || p->tn.name != (char *) 0 ); ! 264: ! 265: case COMOP: ! 266: return( tcond( p->in.right ) ); ! 267: ! 268: case ANDAND: ! 269: return( tcond( p->in.left ) && tcond( p->in.right ) ); ! 270: ! 271: case OROR: ! 272: return( tcond( p->in.left ) || tcond( p->in.right ) ); ! 273: ! 274: case NOT: ! 275: return( fcond( p->in.left ) ); ! 276: ! 277: case QUEST: ! 278: q = p->in.right; ! 279: if( tcond( p->in.left ) ) return( tcond( q->in.left ) ); ! 280: if( fcond( p->in.left ) ) return( tcond( q->in.right ) ); ! 281: return( tcond( q->in.left ) && tcond( q->in.right ) ); ! 282: ! 283: default: ! 284: return( 0 ); ! 285: } ! 286: } ! 287: ! 288: fcond( p ) ! 289: register NODE *p; ! 290: { ! 291: /* return 1 if p is always false, 0 otherwise */ ! 292: register o = p->tn.op; ! 293: register NODE *q; ! 294: ! 295: switch( o ) ! 296: { ! 297: ! 298: case ICON: ! 299: return( !p->tn.lval && p->tn.name == (char *) 0 ); ! 300: ! 301: case COMOP: ! 302: return( fcond( p->in.right ) ); ! 303: ! 304: case ANDAND: ! 305: return( fcond( p->in.left ) || fcond( p->in.right ) ); ! 306: ! 307: case OROR: ! 308: return( fcond( p->in.left ) && fcond( p->in.right ) ); ! 309: ! 310: case NOT: ! 311: return( tcond( p->in.left ) ); ! 312: ! 313: case QUEST: ! 314: q = p->in.right; ! 315: if( tcond( p->in.left ) ) return( fcond( q->in.left ) ); ! 316: if( fcond( p->in.left ) ) return( fcond( q->in.right ) ); ! 317: return( fcond( q->in.left ) && fcond( q->in.right ) ); ! 318: ! 319: default: ! 320: return( 0 ); ! 321: } ! 322: } ! 323: ! 324: NODE * ! 325: rcomma( p ) ! 326: register NODE *p; ! 327: { ! 328: /* p is a COMOP; return the shrunken version thereof */ ! 329: ! 330: if( p->tn.op != COMOP ) cerror( "rcomma" ); ! 331: ! 332: if( p->in.left && p->in.right ) return( p ); ! 333: p->tn.op = FREE; ! 334: if( !p->in.left ) return( p->in.right ); ! 335: return( p->in.left ); ! 336: } ! 337: ! 338: NODE * ! 339: seq( p1, p2 ) ! 340: register NODE *p1, *p2; ! 341: { ! 342: /* execute p then q */ ! 343: register NODE *q; ! 344: ! 345: q = talloc(); ! 346: if (!p1) return p2; ! 347: if (!p2) return p1; ! 348: q->in.op = COMOP; ! 349: /*q->in.type = p2->in.right->in.type; why? */ ! 350: q->in.type = p2->in.type; ! 351: q->in.left = p1; ! 352: q->in.right = p2; ! 353: return q; ! 354: } ! 355: ! 356: NODE * ! 357: gtb( p, l ) ! 358: register NODE *p; ! 359: register l; ! 360: { ! 361: register NODE *q; ! 362: /* replace p by a trivial branch to l */ ! 363: /* if l is -1, return NULL */ ! 364: q = condit( p, CEFF, -1, -1 ); ! 365: if( l<0 ) return( q ); ! 366: if( !q ) ! 367: { ! 368: q = talloc(); ! 369: q->tn.op = ICON; ! 370: q->tn.lval = 0; ! 371: q->tn.name = (char *) 0; ! 372: q->tn.type = TINT; ! 373: } ! 374: return( genbr( 0, l, q ) ); ! 375: } ! 376: ! 377: NODE * ! 378: condit( p, goal, t, f ) ! 379: register NODE *p; ! 380: register goal,t,f; ! 381: { ! 382: /* generate code for conditionals in terms of GENLAB and GENBR nodes */ ! 383: /* goal is either CEFF, NRGS, or CCC */ ! 384: /* also, delete stuff that never needs get done */ ! 385: /* if goal==CEFF, return of null means nothing to be done */ ! 386: ! 387: register o, lt, lf, l; ! 388: register NODE *q, *q1, *q2; ! 389: ! 390: o = p->tn.op; ! 391: ! 392: #ifndef NODBG ! 393: if( odebug >2 ) ! 394: { ! 395: printf( "condit( %d (%s), %s, %d, %d )\n", (int)(p-node), ! 396: opst[o], goal==CCC?"CCC":(goal==NRGS?"NRGS":"CEFF"), ! 397: t, f ); ! 398: } ! 399: #endif ! 400: if( o == CBRANCH ) ! 401: { ! 402: p->in.right->tn.op = p->tn.op = FREE; ! 403: l = p->in.right->tn.lval; ! 404: p = p->in.left; ! 405: if( fcond( p ) ) return( gtb(p,l) ); ! 406: if( tcond( p ) ) return( gtb(p,-1) ); ! 407: return( condit( p, CCC, -1, l ) ); ! 408: } ! 409: ! 410: /* a convenient place to diddle a few special ops */ ! 411: if( callop(o) ) ! 412: { ! 413: if( optype(o) == UTYPE ) p->stn.argsize = 0; ! 414: else p->stn.argsize = argsize(p->in.right); ! 415: if( goal==CEFF ) goal = NRGS; ! 416: /* flow on, so that we can handle if( f(...) )... */ ! 417: } ! 418: else if( goal==CEFF && (asgop(o) || o==STASG || o==INIT)) goal=NRGS; ! 419: ! 420: /* do a bit of optimization */ ! 421: ! 422: if( goal == NRGS ) ! 423: { ! 424: if( logop(o) ) ! 425: { ! 426: /* must make p into ( p ? 1 : 0 ), then recompile */ ! 427: q1 = talloc(); ! 428: q1->tn.op = ICON; ! 429: q1->tn.name = (char *) 0; ! 430: q1->tn.lval = 1; ! 431: q1->tn.type = p->tn.type; ! 432: q2 = talloc(); ! 433: *q2 = *q1; ! 434: q2->tn.lval = 0; ! 435: q = talloc(); ! 436: q->tn.op = COLON; ! 437: q->tn.type = p->tn.type; ! 438: q->in.left = q1; ! 439: q->in.right = q2; ! 440: q1 = talloc(); ! 441: q1->tn.op = o = QUEST; ! 442: q1->tn.type = p->tn.type; ! 443: q1->in.left = p; ! 444: q1->in.right = q; ! 445: p = q1; /* flow on, and compile */ ! 446: } ! 447: } ! 448: ! 449: if( goal != CCC ) ! 450: { ! 451: if( o == QUEST ) ! 452: { ! 453: /* rewrite ? : when goal not CCC */ ! 454: lf = getlab(); ! 455: l = getlab(); ! 456: p->tn.op = COMOP; ! 457: q = p->in.right; ! 458: q1 = condit( q->in.left, goal, -1, -1 ); ! 459: q->in.right = condit( q->in.right, goal, -1, -1 ); ! 460: if( tcond( p->in.left ) ) ! 461: { ! 462: q->tn.op = FREE; ! 463: tfree( q->in.right ); ! 464: p->in.right = q1; ! 465: p->in.left=condit( p->in.left, CEFF, -1, -1 ); ! 466: return( rcomma( p ) ); ! 467: } ! 468: if( fcond( p->in.left ) ) ! 469: { ! 470: q->tn.op = FREE; ! 471: tfree( q1 ); ! 472: p->in.right = q->in.right; ! 473: p->in.left=condit( p->in.left, CEFF, -1, -1 ); ! 474: return( rcomma( p ) ); ! 475: } ! 476: if( !q1 ) ! 477: { ! 478: if( !q->in.right ) ! 479: { ! 480: /* may still have work to do ! 481: ** if left side of ? has effect ! 482: */ ! 483: q1 = condit(p->in.left, goal, ! 484: -1, -1); ! 485: if (!q1) ! 486: { ! 487: tfree( p->in.left ); ! 488: } ! 489: p->tn.op = q->tn.op = FREE; ! 490: return( q1 ); ! 491: } ! 492: /* rhs done if condition is false */ ! 493: p->in.left = condit( p->in.left, CCC, l, -1 ); ! 494: p->in.right = dlabel( q->in.right, l ); ! 495: q->tn.op = FREE; ! 496: return( p ); ! 497: } ! 498: else if( !q->in.right ) ! 499: { ! 500: /* lhs done if condition is true */ ! 501: p->in.left=condit( p->in.left, CCC, -1, lf ); ! 502: p->in.right = dlabel( q1, lf ); ! 503: q->tn.op = FREE; ! 504: return( p ); ! 505: } ! 506: ! 507: /* both sides exist and the condition is nontrivial */ ! 508: p->in.left = condit( p->in.left, CCC, -1, lf ); ! 509: q1 = force(q1); ! 510: q->in.right = force(q->in.right); ! 511: q1 = genbr( 0, l, q1 ); ! 512: q->in.left = dlabel( q1, lf ); ! 513: q->tn.op = COMOP; ! 514: return( dlabel( p, l ) ); ! 515: } ! 516: ! 517: if( goal == CEFF ) ! 518: { ! 519: /* some things may disappear */ ! 520: switch( o ) ! 521: { ! 522: ! 523: case CBRANCH: ! 524: case GENBR: ! 525: case GENUBR: ! 526: case CALL: ! 527: case UNARY CALL: ! 528: case FORTCALL: ! 529: case UNARY FORTCALL: ! 530: case STCALL: ! 531: case UNARY STCALL: ! 532: case STASG: ! 533: case INIT: ! 534: case MOD: /* do these for the side effects */ ! 535: case DIV: ! 536: case UOP0: ! 537: case UOP1: ! 538: case UOP2: ! 539: case UOP3: ! 540: case UOP4: ! 541: case UOP5: ! 542: case UOP6: ! 543: case UOP7: ! 544: case UOP8: ! 545: case UOP9: ! 546: #if defined(COMBINED) ! 547: case GENLAB: ! 548: #endif ! 549: goal = NRGS; ! 550: } ! 551: } ! 552: ! 553: /* The rhs of && and || ops are executed only if the ! 554: result is not clear from the lhs. If our goal is ! 555: CEFF, we don't need a result, but we need to ! 556: preserve that dependancy. So special case it. */ ! 557: if (goal==CEFF) { ! 558: if (o == ANDAND) return andeff(p); ! 559: if (o == OROR) return oreff(p); ! 560: } ! 561: /* This next batch of code wanders over the tree getting ! 562: rid of code which is for effect only and has no ! 563: effect */ ! 564: switch( optype(o) ) ! 565: { ! 566: case LTYPE: ! 567: if( goal == CEFF ) ! 568: { ! 569: p->tn.op = FREE; ! 570: return( NIL ); ! 571: } ! 572: break; ! 573: ! 574: case BITYPE: ! 575: p->in.right = condit( p->in.right, goal, -1, -1 ); ! 576: case UTYPE: ! 577: p->in.left = condit( p->in.left, o==COMOP?CEFF:goal, ! 578: -1, -1 ); ! 579: } ! 580: /* If we are only interested in effects, we quit here */ ! 581: if( goal == CEFF || o==COMOP ) ! 582: { ! 583: /* lhs or rhs may have disappeared */ ! 584: /* op need not get done */ ! 585: ! 586: switch( optype(o) ) ! 587: { ! 588: ! 589: case BITYPE: ! 590: p->tn.op = COMOP; ! 591: p = rcomma(p); ! 592: return ( p ); ! 593: ! 594: case UTYPE: ! 595: /* don't throw out prepass's labels */ ! 596: if(p->in.op == GENLAB) ! 597: return(p); ! 598: p->tn.op = FREE; ! 599: return( p->in.left ); ! 600: ! 601: case LTYPE: ! 602: p->tn.op = FREE; ! 603: return( NIL ); ! 604: } ! 605: } ! 606: return( p ); ! 607: } ! 608: ! 609: /* goal must = CCC from here on */ ! 610: ! 611: switch( o ) ! 612: { ! 613: ! 614: case ULE: ! 615: case ULT: ! 616: case UGE: ! 617: case UGT: ! 618: case EQ: ! 619: case NE: ! 620: case LE: ! 621: case LT: ! 622: case GE: ! 623: case GT: ! 624: if(t<0 ) ! 625: { ! 626: o = p->tn.op = negrel[o-EQ]; ! 627: t = f; ! 628: f = -1; ! 629: } ! 630: ! 631: #ifndef NOOPT ! 632: if( p->in.right->in.op == ICON && ! 633: p->in.right->tn.lval == 0 && ! 634: p->in.right->in.name == (char *) 0 ) ! 635: { ! 636: /* if chars are unsigned, do these optimizations ! 637: as if this is an unsigned compare*/ ! 638: #ifndef CHSIGN ! 639: if ( ! 640: ( p->in.left->tn.type == TCHAR || ! 641: ( p->in.left->in.op == CONV && ! 642: p->in.left->in.left->tn.type == TCHAR ) ) ! 643: && o >= LE && o <= GT) ! 644: o += UGT - GT; ! 645: #endif ! 646: ! 647: /* the question here is whether we can assume that */ ! 648: /* unconditional branches preserve condition codes */ ! 649: /* if this turned out to be no, we would have to */ ! 650: /* explicitly handle this case here */ ! 651: ! 652: switch( o ) ! 653: { ! 654: ! 655: case UGT: ! 656: case ULE: ! 657: o = p->in.op = (o==UGT)?NE:EQ; ! 658: case EQ: ! 659: case NE: ! 660: case LE: ! 661: case LT: ! 662: case GE: ! 663: case GT: ! 664: if( logop( p->in.left->tn.op ) ) ! 665: { ! 666: /* situation like (a==0)==0 */ ! 667: /* ignore optimization */ ! 668: goto noopt; ! 669: } ! 670: break; ! 671: ! 672: case ULT: /* never succeeds */ ! 673: return( gtb( p, f ) ); ! 674: ! 675: case UGE: ! 676: /* always succeeds */ ! 677: return( gtb( p, t ) ); ! 678: } ! 679: p->tn.op = p->in.right->tn.op = FREE; ! 680: p = condit( p->in.left, NRGS, -1, -1 ); ! 681: p = genbr( o, t, p ); ! 682: if( f<0 ) return( p ); ! 683: else return( genbr( 0, f, p ) ); ! 684: } ! 685: noopt: ! 686: # endif ! 687: ! 688: p->in.left = condit( p->in.left, NRGS, -1, -1 ); ! 689: p->in.right = condit( p->in.right, NRGS, -1, -1 ); ! 690: p = genbr( o, t, p ); ! 691: if( f>=0 ) p = genbr( 0, f, p ); ! 692: return( p ); ! 693: ! 694: case COMOP: ! 695: p->in.left = condit( p->in.left, CEFF, -1, -1 ); ! 696: p->in.right = condit( p->in.right, CCC, t, f ); ! 697: return( rcomma( p ) ); ! 698: ! 699: case NOT: ! 700: p->tn.op = FREE; ! 701: return( condit( p->in.left, CCC, f, t ) ); ! 702: ! 703: case ANDAND: ! 704: lf = f<0 ? getlab() : f; ! 705: lt = t<0 ? getlab() : t; ! 706: p->tn.op = COMOP; ! 707: if( tcond( p->in.left ) ) ! 708: { ! 709: /* left is always true */ ! 710: p->in.left = condit( p->in.left, CEFF, -1, -1 ); ! 711: p->in.right = condit( p->in.right, CCC, t, f ); ! 712: } ! 713: else { ! 714: /* lhs not always true */ ! 715: if( tcond( p->in.right ) ) ! 716: { ! 717: /* rhs is always true */ ! 718: p->in.right = ! 719: condit( p->in.right, CEFF, -1, -1 ); ! 720: if (p->in.right) { ! 721: /* const with sideeffect */ ! 722: p->in.left = ! 723: condit( p->in.left, CCC, -1,lf); ! 724: p->in.right = condit( p->in.right, ! 725: CCC, t, t ); ! 726: } else ! 727: p->in.left = ! 728: condit( p->in.left, CCC, t, f ); ! 729: } else { ! 730: p->in.left = ! 731: condit( p->in.left, CCC, -1, lf ); ! 732: p->in.right = ! 733: condit( p->in.right, CCC, t, f ); ! 734: } ! 735: } ! 736: q = rcomma( p ); ! 737: if( f<0 ) q = dlabel( q, lf ); ! 738: if( t<0 ) q = dlabel( q, lt ); ! 739: return( q ); ! 740: ! 741: case OROR: ! 742: lf = f<0 ? getlab() : f; ! 743: lt = t<0 ? getlab() : t; ! 744: p->tn.op = COMOP; ! 745: if( fcond( p->in.left ) ) ! 746: { ! 747: /* left is always false */ ! 748: p->in.left = condit( p->in.left, CEFF, -1, -1 ); ! 749: p->in.right = condit( p->in.right, CCC, t, f ); ! 750: } ! 751: else { ! 752: /* left is not always false */ ! 753: if( fcond( p->in.right ) ) ! 754: { ! 755: /* right always false */ ! 756: p->in.right = ! 757: condit( p->in.right, CEFF, -1, -1 ); ! 758: if (p->in.right) { ! 759: /* const with sideeffect */ ! 760: p->in.left = ! 761: condit( p->in.left, CCC, lt,-1); ! 762: /* This may generate a superfluous ! 763: test. Tough. */ ! 764: p->in.right = condit( p->in.right, ! 765: CCC, f, f ); ! 766: } else ! 767: p->in.left = ! 768: condit( p->in.left, CCC, t, f ); ! 769: } else { ! 770: p->in.left = ! 771: condit( p->in.left, CCC, lt, -1 ); ! 772: p->in.right = ! 773: condit( p->in.right, CCC, t, f ); ! 774: } ! 775: } ! 776: p = rcomma( p ); ! 777: if( f<0 ) p = dlabel( p, lf ); ! 778: if( t<0 ) p = dlabel( p, lt ); ! 779: return( p ); ! 780: ! 781: case QUEST: ! 782: lf = f<0 ? getlab() : f; ! 783: lt = t<0 ? getlab() : t; ! 784: p->in.left = condit( p->in.left, CCC, -1, l=getlab() ); ! 785: q = p->in.right; ! 786: q1 = condit( q->in.left, goal, lt, lf ); ! 787: q->in.left = dlabel( q1, l ); ! 788: q->in.right = condit( q->in.right, goal, t, f ); ! 789: p->tn.op = COMOP; ! 790: q->tn.op = COMOP; ! 791: if( t<0 ) p = dlabel( p, lt ); ! 792: if( f<0 ) p = dlabel( p, lf ); ! 793: return( p ); ! 794: ! 795: default: ! 796: /* get the condition codes, generate the branch */ ! 797: switch( optype(o) ) ! 798: { ! 799: case BITYPE: ! 800: p->in.right = condit( p->in.right, NRGS, -1, -1 ); ! 801: case UTYPE: ! 802: p->in.left = condit( p->in.left, NRGS, -1, -1 ); ! 803: } ! 804: if( t>=0 ) p = genbr( NE, t, p ); ! 805: if( f>=0 ) p = genbr( (t>=0)?0:EQ, f, p ); ! 806: return( p ); ! 807: } ! 808: } ! 809: ! 810: # ifndef TWOPASS ! 811: ! 812: p2compile( p ) ! 813: register NODE *p; ! 814: { ! 815: if( lflag ) lineid(p->ln.lineno ? p->ln.lineno : lineno, ftitle ); ! 816: tmpoff = 0; /* expression at top level reuses temps */ ! 817: /* generate code for the tree p */ ! 818: ! 819: # ifdef MYREADER ! 820: MYREADER(p); /* do your own laundering of the input */ ! 821: # endif ! 822: /* eliminate the conditionals */ ! 823: # ifndef NODBG ! 824: if( p && odebug>2 ) e2print(p); ! 825: # endif ! 826: /*p = prepass(p);*/ ! 827: if(p) ! 828: p = condit( p, CEFF, -1, -1 ); ! 829: if( p ) ! 830: { ! 831: /* expression does something */ ! 832: /* generate the code */ ! 833: # ifndef NODBG ! 834: if( odebug>2 ) e2print(p); ! 835: # endif ! 836: pjwreader(p); ! 837: pjwend(p); ! 838: } ! 839: # ifndef NODBG ! 840: else if( odebug>1 ) printf( "null effect\n" ); ! 841: # endif ! 842: allchk(); ! 843: /* tcheck will be done by the first pass at the end of a ftn. */ ! 844: /* first pass will do it... */ ! 845: } ! 846: ! 847: p2bbeg( aoff, myreg ) ! 848: register aoff,myreg; ! 849: { ! 850: static int myftn = -1; ! 851: SETOFF( aoff, ALSTACK ); ! 852: if( myftn != ftnno ) ! 853: { ! 854: /* beginning of function */ ! 855: maxboff = aoff; ! 856: myftn = ftnno; ! 857: maxtemp = 0; ! 858: maxarg = 0; ! 859: } ! 860: else ! 861: { ! 862: if( aoff > maxboff ) maxboff = aoff; ! 863: } ! 864: # ifdef SETREGS ! 865: SETREGS(myreg); ! 866: # endif ! 867: } ! 868: ! 869: p2bend() ! 870: { ! 871: SETOFF( maxboff, ALSTACK ); ! 872: SETOFF( maxarg, ALSTACK ); ! 873: SETOFF( maxtemp, ALSTACK ); ! 874: eobl2(); ! 875: maxboff = maxarg = maxtemp = 0; ! 876: } ! 877: ! 878: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.