![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optim.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / comp|
Return to optim.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / comp |
1.1 ! root 1: /* @(#) optim.c: 1.3 1/12/84 */ ! 2: ! 3: # include "mfile1.h" ! 4: ! 5: # define ISCON(p) (p->in.op==ICON) ! 6: ! 7: int opdebug = 0; ! 8: NODE *doptim(); ! 9: ! 10: NODE * ! 11: aadjust( p, adj ) ! 12: register NODE *p; ! 13: register adj; ! 14: { ! 15: /* try to adjust p by adj bits */ ! 16: register NODE *q; ! 17: adj = BITOOR(adj); ! 18: switch( p->tn.op ) ! 19: { ! 20: case ICON: ! 21: p->tn.lval += adj; ! 22: return( p ); ! 23: default: ! 24: /* construct a + node */ ! 25: mkplus: ! 26: return( block( PLUS, p, bcon(adj), p->fn.type, ! 27: p->fn.cdim, p->fn.csiz ) ); ! 28: case PLUS: ! 29: q = p->in.right; ! 30: if( q->tn.op != ICON ) goto mkplus; ! 31: q->tn.lval += adj; ! 32: return( p ); ! 33: case MINUS: ! 34: q = p->in.right; ! 35: if( q->tn.op != ICON ) goto mkplus; ! 36: q->tn.lval -= adj; ! 37: return( p ); ! 38: } ! 39: } ! 40: ! 41: adjust( p, adj ) ! 42: register NODE *p; ! 43: register adj; ! 44: { ! 45: /* handle adjustment of scalars by adj bits */ ! 46: ! 47: switch( p->tn.op ) ! 48: { ! 49: case NAME: ! 50: case VAUTO: ! 51: case VPARAM: ! 52: p->tn.lval += BITOOR(adj); ! 53: return( 1 ); ! 54: case STAR: ! 55: p->in.left = aadjust( p->in.left, adj ); ! 56: return( 1 ); ! 57: default: ! 58: return( 0 ); ! 59: } ! 60: } ! 61: ! 62: # ifdef NOSIMPSTR ! 63: # ifndef MYSIMPSTR ! 64: simpstr( d, s ) ! 65: { ! 66: return( STRTY ); ! 67: } ! 68: # endif ! 69: # else ! 70: TWORD ! 71: simpstr( d, s ) ! 72: { ! 73: /* return STRTY if not, and CHAR, INT, SHORT, or LONG if simple */ ! 74: register sz, al; ! 75: ! 76: sz = tsize( STRTY, d, s ); ! 77: al = talign( STRTY, s ); ! 78: if( sz == SZINT && !( al % ALINT) ) return( INT ); ! 79: else if( sz == SZCHAR && !( al % ALCHAR) ) return( CHAR ); ! 80: else if( sz == SZLONG && !( al % ALLONG) ) return( LONG ); ! 81: else if( sz == SZSHORT && !( al % ALSHORT) ) return( SHORT ); ! 82: return( STRTY ); ! 83: } ! 84: # endif ! 85: ! 86: tydown( p ) ! 87: NODE *p; ! 88: { ! 89: /* reflect the type of p downwards, as appropriate */ ! 90: /* the type is typically getting smaller */ ! 91: /* returns 1 if it makes a real change */ ! 92: ! 93: TWORD t; ! 94: NODE *l, *r; ! 95: int flag; ! 96: ! 97: #ifndef NODBG ! 98: if( opdebug ) ! 99: { ! 100: printf( "tydown(%d) called with:\n", p-node ); ! 101: eprint( p ); ! 102: } ! 103: #endif ! 104: t = p->tn.type; ! 105: if( ISPTR(t) || ISARY(t) ) return(0); ! 106: ! 107: /* work these types down into the tree */ ! 108: ! 109: flag = 0; ! 110: ! 111: switch( p->tn.op ) ! 112: { ! 113: ! 114: case AND: ! 115: case OR: ! 116: case PLUS: ! 117: case MINUS: ! 118: case ER: ! 119: case COMOP: ! 120: #ifndef NODBG ! 121: if( opdebug ) ! 122: { ! 123: printf( "tydown:\n" ); ! 124: eprint( p ); ! 125: } ! 126: #endif ! 127: r = p->in.right; ! 128: if( bigsize(r->tn.type) > bigsize(p->tn.type ) ) ! 129: { ! 130: r = makety( r, t, 0, (int) t ); ! 131: tydown( r ); ! 132: p->in.right = doptim( r ); ! 133: #ifndef NODBG ! 134: if( opdebug ) ! 135: { ! 136: printf( "tydown(%d), after doptim(R):\n", ! 137: p-node ); ! 138: eprint(p); ! 139: } ! 140: #endif ! 141: flag = 1; ! 142: } ! 143: if( p->tn.op == COMOP ) return( flag ); ! 144: /* FALLTHRU */ ! 145: ! 146: case UNARY MINUS: ! 147: case COMPL: ! 148: l = p->in.left; ! 149: if( bigsize(l->tn.type) > bigsize(p->tn.type ) ) ! 150: { ! 151: l = makety( l, t, 0, (int) t ); ! 152: tydown( l ); ! 153: p->in.left = doptim( l ); ! 154: #ifndef NODBG ! 155: if( opdebug ) ! 156: { ! 157: printf( "tydown(%d), after doptim(L):\n", ! 158: p-node ); ! 159: eprint(p); ! 160: } ! 161: #endif ! 162: flag = 1; ! 163: } ! 164: return(flag); ! 165: } ! 166: return( 0 ); /* no change */ ! 167: } ! 168: ! 169: # ifndef MYCONVERT ! 170: NODE * ! 171: sconvert( p ) ! 172: register NODE *p; ! 173: { ! 174: register TWORD t, lt; ! 175: register NODE *l; ! 176: register o; ! 177: ! 178: /* optimize CONV nodes */ ! 179: /* the unsigned-ness is ignored */ ! 180: /* if the CONV involves floats or doubles, retain unless null */ ! 181: /* if the CONV makes things bigger, retain */ ! 182: /* if the CONV keeps things the same size, just paint the type */ ! 183: /* if the CONV makes things smaller, adjust the addressing with ! 184: ** memory references, and paint the new type ! 185: */ ! 186: /* if a pointer is being converted, convert as if it were PTRTYPE */ ! 187: /* finally, if CONV converts a constant, do it in place */ ! 188: again: ! 189: #ifndef NODBG ! 190: if( opdebug ) ! 191: { ! 192: printf( "sconvert(%d) called:\n", p-node ); ! 193: eprint( p ); ! 194: } ! 195: #endif ! 196: if( p->tn.op != CONV ) cerror( "sconvert" ); ! 197: l = p->in.left; ! 198: t = p->tn.type; ! 199: lt = l->tn.type; ! 200: o = l->tn.op; ! 201: ! 202: if( o == FCON ) ! 203: { ! 204: /* for a floating point const, paint type, ! 205: ** round when it is output */ ! 206: if( t == FLOAT || t == DOUBLE ) goto paint; ! 207: /* otherwise, convert it to long and treat as long conversion */ ! 208: l->tn.op = ICON; ! 209: l->tn.lval = l->fpn.dval; /* MACHINE-DEPENDENT CONVERSION */ ! 210: l->tn.rval = NONAME; ! 211: goto icon; ! 212: } ! 213: ! 214: if( o==CONV && cbigger( l ) ) ! 215: { ! 216: merge: ! 217: p->in.left = l->in.left; ! 218: l->tn.op = FREE; ! 219: tydown( p ); ! 220: goto again; ! 221: } ! 222: if( t == lt && (t == DOUBLE || t == FLOAT) ) ! 223: goto paint; /* float over float, double over double */ ! 224: if( t==FLOAT || t==DOUBLE || t == VOID ! 225: || lt==FLOAT || lt==DOUBLE ) return( p ); ! 226: ! 227: if( ISUNSIGNED(t) ) t = DEUNSIGN(t); ! 228: if( ISUNSIGNED(lt) ) lt = DEUNSIGN(lt); ! 229: if( ISPTR(lt) ) ! 230: # ifdef MEMONLY ! 231: if( o==STAR || o==NAME || o==VAUTO || o==VPARAM ) ! 232: # endif ! 233: lt = PTRTYPE; ! 234: if( t == lt ) goto paint; ! 235: if( ISPTR(lt) || ISARY(lt) ) return(p); ! 236: ! 237: if( o == ICON ) ! 238: { ! 239: icon: ! 240: l->tn.lval = ccast( l->tn.lval, p->tn.type ); ! 241: paint: ! 242: l->tn.type = p->tn.type; ! 243: l->fn.csiz = p->fn.csiz; ! 244: l->fn.cdim = p->fn.cdim; ! 245: p->tn.op = FREE; ! 246: if( tydown(l) ) ! 247: { ! 248: l = doptim(l); ! 249: } ! 250: return( l ); ! 251: } ! 252: if( cbigger(p) ) return( p ); ! 253: /* p makes things smaller */ ! 254: if( o==CONV ) ! 255: { ! 256: /* two conversions in a row: the second makes things smaller */ ! 257: /* make them into one */ ! 258: goto merge; ! 259: } ! 260: if( o==STAR || o==NAME || o==VAUTO || o==VPARAM ) ! 261: { ! 262: /* memory reference: determine the adjustment */ ! 263: # ifdef RTOLBYTES ! 264: # ifdef LOWINT ! 265: if( lt == LONG ) if( !adjust( l, LOWINT )) cerror( "adj" ); ! 266: # endif ! 267: # else ! 268: register adj = 0; ! 269: if( lt == LONG ) adj = SZLONG; ! 270: else if( lt == INT ) adj = SZINT; ! 271: else if( lt == SHORT ) adj = SZSHORT; ! 272: else cerror( "sconv:lt 0%o", lt ); ! 273: if( t == INT ) adj -= SZINT; ! 274: else if( t == SHORT ) adj -= SZSHORT; ! 275: else if( t == CHAR ) adj -= SZCHAR; ! 276: else cerror( "sconv:t 0%o", t ); ! 277: # ifdef LOWINT ! 278: if( lt == LONG ) adj += LOWINT; ! 279: # endif ! 280: if( adj ) if( !adjust( l, adj ) ) cerror( "adj1" ); ! 281: # endif ! 282: } ! 283: ! 284: /* other cases are where it is computed into a reg; */ ! 285: /* simply paint the type */ ! 286: /* must avoid clobbering the type for assignment nodes */ ! 287: /* however, we must copy (e.g., apply the CONV) for register vars */ ! 288: /* also, can't paint type over fields */ ! 289: if( o == REG || asgop(o) || o == FLD ) return( p ); ! 290: goto paint; ! 291: } ! 292: # endif ! 293: ! 294: NODE * ! 295: pvconvert( p ) ! 296: register NODE *p; ! 297: { ! 298: /* p is a CONV node; convert */ ! 299: /* this does something only when the descendent is not a ptr */ ! 300: register NODE *l; ! 301: register int o; ! 302: l = p->in.left; ! 303: if( ISPTR( l->tn.type ) ) return( clocal(p) ); ! 304: # ifdef MEMONLY ! 305: o = l->tn.op; ! 306: if( o==STAR || o==NAME || o==VAUTO || o==VPARAM || o==ICON ) ! 307: # endif ! 308: { ! 309: /* optimize this reference */ ! 310: /* sconvert and optimize to PTRTYPE */ ! 311: l = makety( l, PTRTYPE, 0, PTRTYPE ); ! 312: if( l->tn.op == CONV ) l = sconvert( l ); ! 313: l->tn.type = p->tn.type; ! 314: l->fn.cdim = p->fn.cdim; ! 315: l->fn.csiz = p->fn.csiz; ! 316: p->tn.op = FREE; ! 317: p = l; ! 318: } ! 319: return( clocal(p) ); ! 320: } ! 321: ! 322: NODE * ! 323: fortarg( p ) ! 324: register NODE *p; ! 325: { ! 326: /* fortran function arguments */ ! 327: ! 328: if( p->in.op == CM ) ! 329: { ! 330: p->in.left = fortarg( p->in.left ); ! 331: p->in.right = fortarg( p->in.right ); ! 332: return(p); ! 333: } ! 334: while( ISPTR(p->in.type) ) ! 335: { ! 336: p = buildtree( STAR, p, NIL ); ! 337: } ! 338: return( optim(p) ); ! 339: } ! 340: ! 341: /* mapping relationals when the sides are reversed */ ! 342: short revrel[] = ! 343: { ! 344: EQ, NE, GE, GT, LE, LT, UGE, UGT, ULE, ULT ! 345: }; ! 346: ! 347: #ifndef NODBG ! 348: # define REPORT(x) if(opdebug)printf( "optim turns %d into %d\n",p-node,x-node); ! 349: #else ! 350: # define REPORT(x) ! 351: #endif ! 352: NODE * ! 353: doptim(p) ! 354: register NODE *p; ! 355: { ! 356: /* local optimizations, most of which are machine independent */ ! 357: /* doptim is called for each node by optim; it assumes that ! 358: ** the children of p are already optimized ! 359: */ ! 360: /* p is not a leaf */ ! 361: register NODE *l, *r, *sp; ! 362: register o, i; ! 363: register TWORD t; ! 364: ! 365: #ifndef NODBG ! 366: if( opdebug ) ! 367: { ! 368: printf( "doptim called on:\n" ); ! 369: eprint(p); ! 370: } ! 371: #endif ! 372: ! 373: if( (t=BTYPE(p->in.type))==ENUMTY || t==MOETY ) econvert(p); ! 374: switch( optype( o = p->tn.op ) ) ! 375: { ! 376: case BITYPE: ! 377: r = p->in.right; ! 378: /* FALLTHRU */ ! 379: case UTYPE: ! 380: l = p->in.left; ! 381: break; ! 382: case LTYPE: ! 383: /* nothing more to do (after doing the enum stuff) */ ! 384: return( p ); ! 385: } ! 386: sp = conval( p ); ! 387: /* return only if conval did something */ ! 388: if( sp != p ) return( doptim(sp) ); ! 389: #ifndef NODBG ! 390: if( opdebug ) ! 391: { ! 392: printf( "doptim works on:\n" ); ! 393: eprint(p); ! 394: } ! 395: #endif ! 396: switch(o) ! 397: { ! 398: case CONV: ! 399: /* someday, make pvconvert and sconvert the same */ ! 400: return( ISPTR(p->tn.type)?pvconvert(p):sconvert(p) ); ! 401: case ASG PLUS: ! 402: case ASG MINUS: ! 403: case ASG AND: ! 404: case ASG OR: ! 405: case ASG ER: ! 406: case ASG LS: ! 407: case ASG RS: ! 408: case ASG MUL: ! 409: case ASG DIV: ! 410: case ASG MOD: ! 411: /* if conversion ops on the lhs, transfer them to the rhs */ ! 412: t = l->in.type; ! 413: ! 414: /* (CONV A) op= B into A op= (CONV B) ! 415: ** this only holds if the result depends only on the ! 416: ** low order part of B (e.g., that part of B that ! 417: ** is the width of A ! 418: ** this is not true for /=, %=, or floats */ ! 419: ! 420: if( l->tn.op == CONV && t!=FLOAT && t!=DOUBLE ! 421: && o!=ASG DIV && o != ASG MOD ) ! 422: { ! 423: p->in.left = l->in.left; ! 424: l->tn.op = FREE; ! 425: l = l->in.left; ! 426: r = makety( r, p->in.type, p->fn.cdim, p->fn.csiz ); ! 427: p->in.right = doptim( r ); ! 428: } ! 429: if( !nncon(r) ) break; /* no more optimization */ ! 430: /* get rid of 0 ops that don't change anything... */ ! 431: if( !r->tn.lval && (o==ASG PLUS || o==ASG MINUS || o==ASG OR || ! 432: o==ASG ER || o==ASG LS || o==ASG RS) ) ! 433: { ! 434: /* the answer is the lhs */ ! 435: goto bless; ! 436: } ! 437: if( r->tn.lval == 1 && (o==ASG MUL || o==ASG DIV) ) ! 438: { ! 439: /* the answer is the lhs */ ! 440: goto bless; ! 441: } ! 442: if( (i = ispow2( r->tn.lval ))>=0 && o==ASG MUL ) ! 443: { ! 444: o = p->in.op = ASG LS; ! 445: r->tn.lval = i; ! 446: } ! 447: break; ! 448: case LS: ! 449: case RS: ! 450: if( !nncon(r) || r->tn.lval ) ! 451: break; /* do nothing */ ! 452: goto bless; /* shifts by 0 */ ! 453: case FORTCALL: ! 454: p->in.right = fortarg( r ); ! 455: break; ! 456: case UNARY AND: ! 457: switch( l->tn.op ) ! 458: { ! 459: case STAR: ! 460: /* fake up to use setuleft */ ! 461: l->tn.op = FREE; ! 462: l=l->in.left; ! 463: goto setuleft; ! 464: case VAUTO: ! 465: case VPARAM: ! 466: case TEMP: ! 467: /* the next two lines come from short structs */ ! 468: case CALL: ! 469: case UNARY CALL: ! 470: break; ! 471: ! 472: case RNODE: ! 473: # ifdef ARGSRET ! 474: /* RNODE disappears if structure simple */ ! 475: if( simpstr( p->fn.cdim, p->fn.csiz ) == STRTY ) ! 476: { ! 477: /* complicated: make it look like first arg */ ! 478: l->tn.op = VPARAM; ! 479: l->tn.lval = BITOOR(ARGINIT); ! 480: l->tn.rval = NONAME; ! 481: } ! 482: break; ! 483: #else ! 484: # ifdef STATSRET ! 485: /* simple structures will disappear */ ! 486: if( simpstr( p->fn.cdim, p->fn.csiz ) != STRTY ) break; ! 487: /* otherwise, make & RNODE into ICON for static area */ ! 488: l->tn.rval = -strftn; ! 489: # else ! 490: break; /* & of RNODE is just fine */ ! 491: #endif ! 492: #endif ! 493: case NAME: ! 494: # ifdef ANDABLE ! 495: if( !ANDABLE(l) ) return(p); ! 496: # endif ! 497: l->tn.op = ICON; ! 498: setuleft: ! 499: /* set the type of lhs with the type of the top */ ! 500: l->in.type = p->in.type; ! 501: l->fn.cdim = p->fn.cdim; ! 502: l->fn.csiz = p->fn.csiz; ! 503: p->in.op = FREE; ! 504: REPORT(l); ! 505: return( l ); ! 506: default: ! 507: cerror( "& error" ); ! 508: } ! 509: break; ! 510: case STCALL: ! 511: case UNARY STCALL: ! 512: /* use l in case return type overwritten */ ! 513: t = simpstr( l->fn.cdim, l->fn.csiz ); ! 514: if( t != STRTY ) ! 515: { ! 516: /* take some care to keep the types OK */ ! 517: /* the type of the return might well have been ! 518: ** overwritten by (say) a structure reference ! 519: */ ! 520: /* MAY NOT BE QUITE RIGHT IF TWO FLAVORS OF PTR */ ! 521: l = p; ! 522: p->tn.type = DECREF( p->tn.type ); ! 523: p = buildtree( UNARY AND, l, NIL ); ! 524: if( o == STCALL ) l->tn.op = CALL; ! 525: else l->tn.op = UNARY CALL; ! 526: l->fn.type = l->fn.csiz = t; ! 527: l->fn.cdim = 0; ! 528: } ! 529: break; ! 530: case STAR: ! 531: if( p->tn.type == STRTY || p->tn.type == UNIONTY ) ! 532: { ! 533: p->tn.op = FREE; ! 534: REPORT(l); ! 535: return( l ); ! 536: } ! 537: if( l->tn.op == UNARY AND && !callop(l->in.left->tn.op) ) ! 538: { ! 539: /* & of call used in structure optimization */ ! 540: /* fake up to use setuleft */ ! 541: l->tn.op = FREE; ! 542: l = l->in.left; ! 543: goto setuleft; ! 544: } ! 545: if( l->tn.op != ICON ) break; ! 546: l->tn.op = NAME; ! 547: goto setuleft; ! 548: case MINUS: ! 549: if( !nncon(r) ) break; ! 550: r->tn.lval = - r->tn.lval; ! 551: o = p->in.op = PLUS; ! 552: case MUL: ! 553: case PLUS: ! 554: case AND: ! 555: case OR: ! 556: case ER: ! 557: /* commutative ops; for now, just collect constants */ ! 558: /* someday, do it right */ ! 559: if( o==r->tn.op || nncon(l) || ( ISCON(l) && !ISCON(r) ) ) ! 560: { ! 561: /* make ops tower to the left, not the right */ ! 562: /* also, put constants on the right */ ! 563: sp = l; ! 564: l = p->in.left = r; ! 565: r = p->in.right = sp; ! 566: } ! 567: /* do (A + C1) + C2, etc. */ ! 568: /* the number of special cases is horrifying */ ! 569: /* many bugs have been found here; this code is very cautious */ ! 570: /* (A + C1) + C2, where C2 can be a ptr, C1 not */ ! 571: if( o==PLUS && l->tn.op==PLUS && ISCON(r) && ! 572: nncon(l->in.right) ) ! 573: { ! 574: p->in.left = l->in.left; ! 575: l->tn.op = FREE; ! 576: l = l->in.right; ! 577: r->tn.lval += l->tn.lval; ! 578: l->tn.op = FREE; ! 579: return( doptim( p ) ); ! 580: } ! 581: /* (A + C1) + C2, where C1 can be a ptr, C2 not */ ! 582: if( o==PLUS && l->tn.op==PLUS && nncon(r) && ! 583: ISCON(l->in.right) ) ! 584: { ! 585: l->in.right->tn.lval += r->tn.lval; ! 586: goto bless; /* return l as the result */ ! 587: } ! 588: /* (A - C1) + C2, where C2 can be a ptr, C1 not */ ! 589: if( o==PLUS && l->tn.op==MINUS && ISCON(r) && ! 590: nncon(l->in.right) ) ! 591: { ! 592: p->in.left = l->in.left; ! 593: l->tn.op = FREE; ! 594: l = l->in.right; ! 595: r->tn.lval -= l->tn.lval; ! 596: l->tn.op = FREE; ! 597: return( doptim( p ) ); ! 598: } ! 599: /* (&A)+C */ ! 600: if( o==PLUS && l->tn.op == UNARY AND && ISCON(r) ) ! 601: { ! 602: switch( l->in.left->tn.op ) ! 603: { ! 604: case NAME: ! 605: case VPARAM: ! 606: case VAUTO: ! 607: l->in.left->tn.lval += r->tn.lval; ! 608: goto bless; ! 609: } ! 610: } ! 611: /* change muls to shifts */ ! 612: if( o==MUL && nncon(r) && (i=ispow2(r->tn.lval))>=0) ! 613: { ! 614: if( i == 0 ) ! 615: { ! 616: /* multiplication by 1 */ ! 617: bless: ! 618: /* return l, with the type of p */ ! 619: l = makety( l, p->tn.type, p->fn.cdim, ! 620: p->fn.csiz ); ! 621: r->tn.op = FREE; ! 622: p->tn.op = FREE; ! 623: /* if a conversion op was added, optimize */ ! 624: l = doptim( l ); ! 625: #ifndef NODBG ! 626: if( opdebug ) ! 627: { ! 628: printf( "optim replaces op1 (%d) by:\n", ! 629: p-node ); ! 630: eprint(l); ! 631: } ! 632: #endif ! 633: return( l ); ! 634: } ! 635: o = p->in.op = LS; ! 636: r->tn.lval = i; ! 637: } ! 638: /* change +'s of negative consts back to - */ ! 639: if( o==PLUS && nncon(r) && r->tn.lval<0 ) ! 640: { ! 641: r->tn.lval = -r->tn.lval; ! 642: o = p->in.op = MINUS; ! 643: } ! 644: if( nncon(r) && !r->tn.lval && (o==PLUS||o==MINUS) ) ! 645: { ! 646: /* get rid of add or subtract of 0 */ ! 647: goto bless; ! 648: } ! 649: # ifdef PTRLEFT ! 650: if( o==PLUS && ISPTR(p->tn.type) && ISPTR(r->tn.type) ! 651: # ifdef CONSRIGHT ! 652: && r->tn.op != ICON ! 653: # endif ! 654: ) ! 655: { ! 656: sp = l; ! 657: p->in.left = r; ! 658: p->in.right = sp; ! 659: } ! 660: # endif ! 661: # ifdef PTRRIGHT ! 662: if( o==PLUS && ISPTR(p->tn.type) && ISPTR(l->tn.type) ! 663: # ifdef CONSRIGHT ! 664: && r->tn.op != ICON ! 665: # endif ! 666: ) ! 667: { ! 668: sp = l; ! 669: p->in.left = r; ! 670: p->in.right = sp; ! 671: } ! 672: # endif ! 673: break; ! 674: case DIV: ! 675: if( nncon( r ) && r->tn.lval == 1 ) goto bless; ! 676: break; ! 677: case EQ: ! 678: case NE: ! 679: case LT: ! 680: case LE: ! 681: case GT: ! 682: case GE: ! 683: case ULT: ! 684: case ULE: ! 685: case UGT: ! 686: case UGE: ! 687: if( ISCON(l) && !ISCON(r) ) ! 688: { ! 689: /* exchange operands */ ! 690: p->in.op = revrel[p->in.op - EQ ]; ! 691: sp = l; ! 692: l = p->in.left = r; ! 693: r = p->in.right = sp; ! 694: } ! 695: break; ! 696: case STASG: ! 697: if( (t=simpstr( p->fn.cdim, p->fn.csiz ) ) != STRTY ) ! 698: { ! 699: /* rewrite = as simpler */ ! 700: if( ISPTR(r->tn.type) ) ! 701: { ! 702: r = buildtree( STAR, r, NIL ); ! 703: r->fn.type = r->fn.csiz = t; ! 704: r->fn.cdim = 0; ! 705: p->in.right = r = doptim( r ); ! 706: } ! 707: l = buildtree( STAR, l, NIL ); ! 708: l->fn.type = l->fn.csiz = t; ! 709: l->fn.cdim = 0; ! 710: p->in.left = l = doptim( l ); ! 711: p->fn.type = p->fn.csiz = t; ! 712: p->fn.cdim = 0; ! 713: p->fn.op = ASSIGN; ! 714: return( p ); ! 715: } ! 716: case STARG: ! 717: if( (t=simpstr( p->fn.cdim, p->fn.csiz ) ) != STRTY ) ! 718: { ! 719: /* rewrite as simpler */ ! 720: if( ISPTR(l->fn.type) ) ! 721: { ! 722: l = buildtree( STAR, l, NIL ); ! 723: l->fn.type = l->fn.csiz = t; ! 724: l->fn.cdim = 0; ! 725: p->in.left = l = doptim( l ); ! 726: } ! 727: p->fn.type = p->fn.csiz = (t==LONG ? LONG : INT); ! 728: p->fn.cdim = 0; ! 729: p->fn.op = FUNARG; ! 730: return( p ); ! 731: } ! 732: # ifdef ENDSTRUCT ! 733: p->in.left = aadjust( l, p->stn.stsize ); ! 734: # endif ! 735: break; ! 736: } ! 737: return(p); ! 738: } ! 739: ! 740: NODE * ! 741: optim( p ) ! 742: register NODE *p; ! 743: { ! 744: switch( optype( p->tn.op ) ) ! 745: { ! 746: case BITYPE: ! 747: p->in.right = optim( p->in.right ); ! 748: /* FALLTHRU */ ! 749: case UTYPE: ! 750: p->in.left = optim( p->in.left ); ! 751: } ! 752: return( doptim( p ) ); ! 753: } ! 754: ! 755: ispow2( c ) ! 756: register CONSZ c; ! 757: { ! 758: register i; ! 759: if( c <= 0 || (c&(c-1)) ) return(-1); ! 760: for( i=0; c>1; ++i) c >>= 1; ! 761: return(i); ! 762: } ! 763: ! 764: nncon( p ) ! 765: register NODE *p; ! 766: { ! 767: /* is p a constant without a name */ ! 768: return( p->tn.op == ICON && p->tn.rval == NONAME && !ISPTR(p->tn.type)); ! 769: } ! 770: ! 771: /* some routines for debugging and tree transformation */ ! 772: #ifndef MYOFFCON ! 773: NODE * ! 774: offcon( off, t, d, s ) ! 775: OFFSZ off; ! 776: TWORD t; ! 777: { ! 778: /* return a node, for structure references, which is suitable for ! 779: ** being added to a pointer of type t, in order to be off bits offset ! 780: ** into a structure ! 781: */ ! 782: register NODE *p; ! 783: ! 784: /* t, d, and s are the type, dimension offset, and size offset */ ! 785: /* in general they may be necessary for offcon */ ! 786: p = bcon(0); ! 787: p->tn.lval = BITOOR(off); ! 788: p->fn.type = p->fn.csiz = PTRTYPE; ! 789: return(p); ! 790: } ! 791: # endif ! 792: ! 793: bccode() ! 794: { ! 795: /* called just before executing code */ ! 796: /* beware: called several times if there is auto. initialization */ ! 797: /*# ifdef SDB ! 798: /* static bcclev; ! 799: /* if( blevel != bcclev ) ! 800: /* { ! 801: /* bcclev = blevel; ! 802: /* pstab( S_LBRAC, blevel-1 ); ! 803: /* } ! 804: /*# endif ! 805: /**/ ! 806: # ifdef MYBCCODE ! 807: MYBCCODE; ! 808: # endif ! 809: p2bbeg( autooff, regvar ); ! 810: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.