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