![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optim2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / pcc|
Return to optim2.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / pcc |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)optim2.c 1.1 86/02/03 Copyr 1985 Sun Micro"; ! 3: #endif ! 4: ! 5: /* ! 6: * Copyright (c) 1985 by Sun Microsystems, Inc. ! 7: */ ! 8: ! 9: #include "cpass2.h" ! 10: ! 11: /* ! 12: * routines to detect and to deal with doubly-indexed OREGs. ! 13: * Initially, these were all stolen from the vax code. ! 14: */ ! 15: ! 16: base( p ) ! 17: register NODE *p; ! 18: { ! 19: register int o = p->in.op; ! 20: register v,maxoff; ! 21: register NODE *lp,*rp; ! 22: ! 23: if ( BTYPE(p->in.type) == DOUBLE ) ! 24: maxoff = 123; ! 25: else ! 26: maxoff = 127; ! 27: if ( o==REG && isbreg( p->tn.rval )) ! 28: return( p->tn.rval ); ! 29: lp = p->in.left; ! 30: rp = p->in.right; ! 31: if ((o==PLUS || o==MINUS) ! 32: && lp->in.op==REG && isbreg( lp->tn.rval ) ! 33: && rp->in.op==ICON && rp->in.name[0] == '\0' ! 34: && (use68020 || (v=rp->tn.lval) <= maxoff && v >= -128) ! 35: ) ! 36: return( lp->tn.rval ); ! 37: return( -1 ); ! 38: } ! 39: ! 40: offset( p, notused ) ! 41: register NODE *p; ! 42: int notused; ! 43: { ! 44: if ( p->in.op==REG ) { ! 45: if ( p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type) ) { ! 46: return( p->tn.rval ); ! 47: } ! 48: if ( p->in.type==SHORT ) { ! 49: /* ! 50: * result is: short index flag + xreg ! 51: */ ! 52: return( (1<<8) + p->tn.rval ); ! 53: } ! 54: } ! 55: if (use68020) { ! 56: /* ! 57: * test for scaled indexing ! 58: */ ! 59: int count; ! 60: NODE *lp = p->in.left; ! 61: NODE *rp = p->in.right; ! 62: if ( p->in.op==LS && lp->in.op==REG ! 63: && (lp->in.type==INT || lp->in.type==UNSIGNED || lp->in.type == SHORT ) ! 64: && (rp->in.op==ICON && rp->in.name[0]=='\0') ! 65: && (count = rp->tn.lval) >= 0 && count <= 3 ) { ! 66: int scale = (1 << count); ! 67: if ( p->in.type == SHORT ) { ! 68: /* ! 69: * result is: short index flag + scale factor + xreg ! 70: */ ! 71: return( (1<<8) + (scale<<4) + lp->tn.rval ); ! 72: } ! 73: /* ! 74: * result is: scale factor + xreg ! 75: */ ! 76: return( (scale<<4) + lp->tn.rval ); ! 77: } ! 78: } ! 79: return( -1 ); ! 80: } ! 81: ! 82: makeor2( p, basenode, breg, scale_plus_xreg ) ! 83: register NODE *p; /* node to be rewritten */ ! 84: register NODE *basenode; /* base node (usually a ptr) */ ! 85: int breg; /* base register */ ! 86: int scale_plus_xreg; /* scale factor + index register */ ! 87: { ! 88: register NODE *t; /* from which tn.lval, tn.name are obtained */ ! 89: register int i; ! 90: NODE *f; ! 91: ! 92: register flags; ! 93: int scale, xreg, shortx, ibit; ! 94: ! 95: ibit = 0; ! 96: shortx= (scale_plus_xreg >> 8) & 1; ! 97: scale = (scale_plus_xreg >> 4) & 017; ! 98: xreg = scale_plus_xreg & 017; ! 99: ! 100: p->in.op = OREG; ! 101: f = p->in.left; /* have to free this subtree later */ ! 102: ! 103: /* init base */ ! 104: switch (basenode->in.op) { ! 105: case ICON: ! 106: case REG: ! 107: case OREG: ! 108: t = basenode; ! 109: break; ! 110: ! 111: case MINUS: ! 112: basenode->in.right->tn.lval = -basenode->in.right->tn.lval; ! 113: case PLUS: ! 114: t = basenode->in.right; ! 115: break; ! 116: ! 117: case INCR: ! 118: case ASG MINUS: ! 119: t = basenode->in.left; ! 120: break; ! 121: ! 122: case UNARY MUL: ! 123: t = basenode->in.left->in.left; ! 124: break; ! 125: ! 126: default: ! 127: cerror("illegal makeor2"); ! 128: } ! 129: ! 130: p->tn.lval = t->tn.lval; ! 131: #ifndef FLEXNAMES ! 132: for(i=0; i<NCHNAM; ++i) ! 133: p->in.name[i] = t->in.name[i]; ! 134: #else ! 135: p->in.name = t->in.name; ! 136: #endif ! 137: ! 138: /* ! 139: * For 68020, R2UPK3 encodes the following data: ! 140: * int shortx:1; short index ! 141: * int ibit:1; memory indirect mode (unused) ! 142: * int scale:4; scale factor (1,2,4,8) ! 143: * For 68010, only the short index flag is encoded. ! 144: */ ! 145: R2PACKFLGS(flags,shortx,ibit,scale); ! 146: p->tn.rval = R2PACK( breg, xreg, flags ); ! 147: ! 148: tfree(f); ! 149: return; ! 150: } ! 151: ! 152: ! 153: /* ! 154: * Multiply a value by a constant. ! 155: * Multiplies are slow on the 68010, so do some shifting and ! 156: * adding here. ! 157: * For each 1-bit in the constant the value is shifted ! 158: * by n where 2**n equals the bit. ! 159: * The shifted value is then added into an accumulated value. ! 160: * One tricky part is for runs of three or more consecutive ! 161: * bits. For a number like 7, it is cheaper to calculate ! 162: * (8 - 1), than it is (3 + 2 + 1) ! 163: */ ! 164: conmul(p, cookie) ! 165: register NODE *p; ! 166: { ! 167: register const; /* The constant value */ ! 168: register int curpos; /* Position of last one bit */ ! 169: register int power; /* The bit being tested */ ! 170: int run; /* Num of consecutive one bits */ ! 171: int nbits; /* Num of bits since the last one bit */ ! 172: int negconst; /* Is the constant <0 ? */ ! 173: char * destreg; /* name of "AL" register */ ! 174: char * helper; /* name of "A1" register */ ! 175: int helperreg; ! 176: TWORD ltype; ! 177: char typechar; ! 178: int t; ! 179: ! 180: /* ! 181: * first determine how many instructions we will need to do ! 182: * it in line. Cost estimator is: # single bits + 2* # of multi bit ! 183: * runs. If this exceeds 5, then it is more compact to use a ! 184: * multiply instruction or routine. ! 185: */ ! 186: const = p->in.right->tn.lval; ! 187: if (const<0){ ! 188: negconst = 1; ! 189: const = - const; ! 190: } else ! 191: negconst = 0; ! 192: run = const & (const>>1); /* each run shortened by one bit */ ! 193: run = cntbits( run ^ (run>>1) ) + (run&1); /* 2*# multibit runs */ ! 194: nbits = cntbits( const ^ (const>>1)) +(const&1); /* 2* #total runs*/ ! 195: run += nbits; /* 2* estimator */ ! 196: ltype = p->in.left->in.type; ! 197: if ((ttype(ltype,TUCHAR|TCHAR|TUSHORT|TSHORT) && run>6) || (run > 10)){ ! 198: /* old-fashioned way */ ! 199: if (tshape( p->in.right, SSCON ) ){ ! 200: if (negconst){ ! 201: expand( p->in.left, INAREG|INTAREG, " negZB AL\nZv"); ! 202: p->in.right->tn.lval = const; ! 203: } ! 204: if (ttype(ltype, TSHORT|TCHAR)){ ! 205: expand( p, cookie, " muls #CR,AL\nZv"); ! 206: } else if (ttype(ltype, TUSHORT|TUCHAR)){ ! 207: expand( p, cookie, " mulu #CR,AL\n"); ! 208: } else if (use68020) { ! 209: if (ISUNSIGNED(p->in.type)) { ! 210: expand( p, cookie, " mulul #CR,AL\n"); ! 211: } else { ! 212: expand( p, cookie, " mulsl #CR,AL\nZv"); ! 213: } ! 214: } else { ! 215: ! 216: expand( p, cookie, ! 217: "\tmovl\tAL,A1\n\tswap\tA1\n\tmulu\t#CR,AL\n"); ! 218: fputs( ttype(ltype, TULONG|TUNSIGNED|TUCHAR|TPOINT) ! 219: ? "\tmulu" : "\tmuls", stdout); ! 220: expand( p, cookie, ! 221: "\t#CR,A1\n\tswap\tA1\n\tclrw\tA1\n\taddl\tA1,AL\nZv"); ! 222: } ! 223: } else if (use68020) { ! 224: if (ISUNSIGNED(p->in.type)) { ! 225: expand( p, cookie, " mulul #CR,AL\n"); ! 226: } else { ! 227: expand( p, cookie, " mulsl #CR,AL\nZv"); ! 228: } ! 229: } else { ! 230: order( p->in.right, INTAREG ); ! 231: order( p, INAREG|INTAREG ); ! 232: } ! 233: return; ! 234: } ! 235: typechar = (((t=p->in.type)==CHAR)||t==UCHAR) ? 'b' ! 236: : (t==SHORT||t==USHORT) ? 'w' ! 237: : 'l'; ! 238: /* ! 239: * if the result type is larger than the operand type, we must expand ! 240: * the operand before doing the operation. ! 241: */ ! 242: switch( p->in.left->tn.type){ ! 243: case UCHAR: ! 244: case USHORT: ! 245: if (typechar=='b' || typechar=='w') break; ! 246: expand( p->in.left, INAREG|INTAREG, " andl #0xffff,AL\n"); ! 247: break; ! 248: case CHAR: ! 249: case SHORT: ! 250: if (typechar=='b' || typechar=='w') break; ! 251: expand( p->in.left, INAREG|INTAREG, " extl AL\n"); ! 252: break; ! 253: } ! 254: p->in.left->tn.type = t; ! 255: nbits = ffs( const )-1; ! 256: power = 0; ! 257: helperreg = resc[0].tn.rval ; ! 258: helper = rnames[ helperreg ]; ! 259: destreg = rnames[ p->in.left->tn.rval]; ! 260: if (negconst){ ! 261: expand( p->in.left, INAREG|INTAREG, " negZB AL\nZv"); ! 262: } ! 263: if (nbits>0){ ! 264: shiftreg( nbits, destreg, helperreg , 1, typechar, t); ! 265: const >>= nbits; ! 266: } ! 267: if (const==1) return; ! 268: /* ! 269: * the first time is special (ask Ann Landers). If it is a run, ! 270: * then we move, negate, shift add. Otherwise, we don't negate. ! 271: */ ! 272: run = ffs( ~const) -1; ! 273: expand(p, cookie, " movZB AL,A1\n"); ! 274: switch (run){ ! 275: case 2: ! 276: shiftreg( 1, helper, -1, 1, typechar, t); ! 277: expand( p, cookie, "\taddZB\tA1,AL\nZv"); ! 278: /* fall through */ ! 279: case 1: ! 280: curpos = 0; ! 281: break; ! 282: default: ! 283: shiftreg( run, helper, -1, 1, typechar, t); ! 284: expand( p->in.left, INAREG|INTAREG, " negZB AL\nZv"); ! 285: expand( p, cookie, "\taddZB\tA1,AL\nZv"); ! 286: curpos = 1; ! 287: break; ! 288: } ! 289: for ( const >>= run; const >>= (power=ffs(const))-1; const >>= run){ ! 290: run = ffs(~const)-1; ! 291: switch(run) { ! 292: case 1: ! 293: shiftreg( power-curpos, helper, -1, 1, typechar, t); ! 294: expand( p, cookie, "\taddZB\tA1,AL\nZv"); ! 295: curpos = 0; ! 296: break; ! 297: case 2: ! 298: shiftreg( power-curpos, helper, -1, 1, typechar, t); ! 299: expand( p, cookie, "\taddZB\tA1,AL\nZv"); ! 300: shiftreg( 1, helper, -1, 1, typechar, t); ! 301: expand( p, cookie, "\taddZB\tA1,AL\nZv"); ! 302: curpos = 0; ! 303: break; ! 304: default: ! 305: shiftreg( power-curpos, helper, -1, 1, typechar, t); ! 306: expand( p, cookie, "\tsubZB\tA1,AL\nZv"); ! 307: shiftreg( run, helper, -1, 1, typechar, t); ! 308: expand( p, cookie, "\taddZB\tA1,AL\nZv"); ! 309: curpos = 1; ! 310: break; ! 311: } ! 312: } ! 313: } ! 314: ! 315: /* ! 316: * divide a signed number by a constant. ! 317: * divides are really slow on this machine, so we really want to avoid them. ! 318: * the only interesting case is divide by power-of-two. Others, we really ! 319: * have to do the division. ! 320: */ ! 321: void ! 322: condiv( p, cookie ) register NODE *p; ! 323: { ! 324: char sizechar; ! 325: register const; ! 326: register TWORD ltype; ! 327: int lab1f; ! 328: char * lname = rnames[p->in.left->tn.rval]; ! 329: const = p->in.right->tn.lval; ! 330: ltype = p->in.left->tn.type; ! 331: if (const & (const-1)){ ! 332: /* too bad -- not a positive power of two */ ! 333: switch (ltype){ ! 334: case CHAR: ! 335: print_str_str_nl( " extw ", lname ); ! 336: /* fall through */ ! 337: case SHORT: ! 338: print_str_str_nl( " extl ", lname ); ! 339: printf( " divs #%d,%s\n", const, lname); ! 340: break; ! 341: default: ! 342: if (use68020) { ! 343: printf( " divsl #%d,%s\n", ! 344: const, lname); ! 345: } else { ! 346: order( p->in.right, INTAREG ); ! 347: order( p, INTAREG ); ! 348: } ! 349: break; ! 350: } ! 351: return; ! 352: } ! 353: switch (ltype){ ! 354: case CHAR: sizechar = 'b'; break; ! 355: case SHORT: sizechar = 'w'; break; ! 356: default: sizechar = 'l'; ! 357: } ! 358: lab1f = getlab(); ! 359: printf(" tst%c %s\n jge L%d\n", sizechar, lname, lab1f); ! 360: print_str((const >= 1 && const <= 8) ? " addq" : " add"); ! 361: printf("%c #%d,%s\n", sizechar, const-1, lname ); ! 362: deflab(lab1f); ! 363: const = ffs(const)-1; ! 364: /* like shiftreg(), but for right, arithmetic shifts */ ! 365: while (const > 0){ ! 366: if (const> 8){ ! 367: printf(" asr%c #8,%s\n", sizechar, lname ); ! 368: const -= 8; ! 369: } else { ! 370: printf(" asr%c #%d,%s\n", sizechar, const, lname ); ! 371: const = 0; ! 372: } ! 373: } ! 374: return; ! 375: } ! 376: ! 377: ! 378: /* ! 379: * remainder a signed number by a constant. ! 380: * remainders are really slow on this machine, so we really want to avoid them. ! 381: * the only interesting case is powers-of-two. Others, we really ! 382: * have to do the division. ! 383: */ ! 384: void ! 385: conrem( p, cookie ) register NODE *p; ! 386: { ! 387: char sizechar, opchar; ! 388: register const; ! 389: register TWORD ltype; ! 390: char * lname = rnames[p->in.left->tn.rval]; ! 391: char * helper, u; ! 392: int lab1f, lab2f; ! 393: const = p->in.right->tn.lval; ! 394: ltype = p->in.left->tn.type; ! 395: if (const & (const-1)){ ! 396: /* too bad -- not a positive power of two */ ! 397: switch (ltype){ ! 398: case CHAR: ! 399: print_str_str_nl( " extw ", lname ); ! 400: /* fall through */ ! 401: case SHORT: ! 402: print_str_str_nl( " extl ", lname ); ! 403: printf( " divs #%d,%s\n", const, lname); ! 404: print_str_str_nl( " swap ", lname ); ! 405: break; ! 406: case UCHAR: ! 407: print_str_str_nl(" andl #0xff,", lname ); ! 408: goto divu; ! 409: case USHORT: ! 410: print_str_str_nl(" andl #0xffff,", lname ); ! 411: divu: printf(" divu #%d,%s\n", const, lname); ! 412: print_str_str_nl(" swap ", lname); ! 413: break; ! 414: default: ! 415: if (use68020) { ! 416: helper = rnames[resc[0].tn.rval]; ! 417: printf(" %s #%d,%s:%s\n", ! 418: (ISUNSIGNED(ltype)? "divull" : "divsll"), ! 419: const, helper, lname); ! 420: printf(" movl %s,%s\n", helper, lname); ! 421: } else { ! 422: order( p->in.right, INTAREG ); ! 423: order( p, INTAREG ); ! 424: } ! 425: break; ! 426: } ! 427: return; ! 428: } ! 429: helper = rnames[resc[0].tn.rval]; ! 430: u = 0; ! 431: switch (ltype){ ! 432: case UCHAR: u = 1; /* fall through */ ! 433: case CHAR: sizechar = 'b'; opchar = 'w'; break; ! 434: case USHORT: u = 1; /* fall through */ ! 435: case SHORT: sizechar = 'w'; opchar = 'w'; break; ! 436: case UNSIGNED: u = 1; /* fall through */ ! 437: default: sizechar = 'l'; opchar = 'l'; ! 438: } ! 439: if (!u){ ! 440: lab1f = getlab(); ! 441: lab2f = getlab(); ! 442: } ! 443: if (const<=128 && const >=-128){ ! 444: printf(" moveq #%d,%s\n", const-1, helper); ! 445: if (!u){ ! 446: printf(" tst%c %s\n jge L%d\n neg%c %s\n", ! 447: sizechar, lname, lab1f, sizechar, lname); ! 448: printf(" and%c %s,%s\n neg%c %s\n jra L%d\n", ! 449: opchar, helper, lname, opchar, lname, lab2f ); ! 450: deflab( lab1f ); ! 451: } ! 452: printf(" and%c %s,%s\n", opchar, helper, lname); ! 453: if (!u){ deflab(lab2f);} ! 454: } else { ! 455: if (!u){ ! 456: printf(" mov%c %s,%s\n jge L%d\n neg%c %s\n", ! 457: sizechar, lname, helper, lab1f, sizechar, lname); ! 458: deflab(lab1f); ! 459: } ! 460: printf(" and%c #%d,%s\n", opchar, const-1, lname ); ! 461: if (!u){ ! 462: printf(" tst%c %s\n jge L%d\n neg%c %s\n", ! 463: sizechar, helper, lab2f, opchar, lname ); ! 464: deflab(lab2f); ! 465: } ! 466: } ! 467: return; ! 468: } ! 469: ! 470: optim2( p ) ! 471: register NODE *p; ! 472: { ! 473: register NODE *q; ! 474: register NODE *r; ! 475: register long v; ! 476: register op; ! 477: int w; ! 478: int lsize, rsize; ! 479: NODE *rl, *rr, *qq; ! 480: TWORD t; ! 481: ! 482: /* ! 483: * reduction of strength on integer constant operands ! 484: * this is a practical, fruitful area of peephole code optimization, ! 485: * since there are so many easy things that can be done. ! 486: * we also check for possible single-o OREGs in a place where ! 487: * the oreg2() should but does not. ! 488: */ ! 489: op = p->in.op; ! 490: switch (optype(op)) { ! 491: case LTYPE: ! 492: break; ! 493: case UTYPE: ! 494: optim2(p->in.left); ! 495: break; ! 496: case BITYPE: ! 497: optim2(p->in.left); ! 498: optim2(p->in.right); ! 499: break; ! 500: } ! 501: switch (op){ ! 502: case LS: ! 503: case ASG LS: ! 504: case RS: ! 505: case ASG RS: ! 506: /* if rhs is an extending SCONV, don't bother converting */ ! 507: r = p->in.right; ! 508: if (isconv(r, SHORT, USHORT) || isconv(r, CHAR, UCHAR)) { ! 509: q = r->in.left; ! 510: *r = *q; ! 511: q->in.op = FREE; ! 512: } ! 513: /* one interesting case: <lhs> <op> 0 */ ! 514: if (r->tn.op != ICON ) break; ! 515: if (r->tn.lval == 0 && r->tn.name[0] == '\0' ){ ! 516: promoteleft: ! 517: t = p->in.type; ! 518: q = p->in.left; ! 519: *p = *q; /* paint over */ ! 520: p->in.type = t; ! 521: q->in.op = r->in.op = FREE; ! 522: } ! 523: /* could test for count of 1, too, but this is easier to do later on */ ! 524: break; ! 525: ! 526: case UNARY MUL: ! 527: /* in case this wasn't done earlier... */ ! 528: if (p->in.left->in.op == ICON) { ! 529: q = p->in.left; ! 530: t = p->in.type; ! 531: *p = *q; ! 532: p->in.op = NAME; ! 533: p->in.type = t; ! 534: q->in.op = FREE; ! 535: break; ! 536: } ! 537: /* ! 538: * put potential double index OREG trees into a canonical ! 539: * form: ( <base> + <offset> ) + <index> ! 540: */ ! 541: p = p->in.left; ! 542: if (p->in.op != PLUS) ! 543: break; ! 544: q = p->in.left; ! 545: r = p->in.right; ! 546: if ( ISPTR(r->in.type) ) { ! 547: /* ! 548: * put the pointer on the left ! 549: */ ! 550: p->in.left = r; ! 551: p->in.right = q; ! 552: q = p->in.left; ! 553: r = p->in.right; ! 554: } ! 555: if ( ISPTR(q->in.type) ! 556: && (r->in.op == PLUS || r->in.op == MINUS) ! 557: && !ISPTR(r->in.left->in.type) ! 558: && r->in.right->in.op == ICON ) { ! 559: /* ! 560: * <ptr exp> + ( <int exp> [+-] ICON ) ! 561: * rewrite as ! 562: * (<ptr exp> [+-] ICON) + <int exp> ! 563: */ ! 564: p->in.right = r->in.left; ! 565: r->in.left = q; ! 566: p->in.left = r; ! 567: r->in.type = q->in.type; ! 568: break; ! 569: } ! 570: if (r->in.op == LS ! 571: && ( (rr = r->in.right)->in.op == ICON ) ! 572: && ( (rl = r->in.left)->in.op == PLUS ! 573: || rl->in.op == MINUS ) ! 574: && !ISPTR(rl->in.left->in.type) ! 575: && rl->in.right->in.op == ICON ) { ! 576: /* ! 577: * <ptr exp> + ((<int exp> [+-] ICON) << ICON) ! 578: * rewrite as ! 579: * (<ptr exp> [+-] ICON*) + (<int exp> << ICON) ! 580: */ ! 581: r->in.left = rl->in.left; ! 582: rl->in.left = q; ! 583: p->in.left = rl; ! 584: rl->in.type = q->in.type; ! 585: rl->in.right->tn.lval <<= rr->tn.lval; ! 586: break; ! 587: } ! 588: break; ! 589: ! 590: case PLUS: ! 591: case ASG PLUS: ! 592: case MINUS: ! 593: case ASG MINUS: ! 594: /* ! 595: * one interesting cases: <lhs> <op> 0. ! 596: * <address reg> + SCONV( <short> ) is a good one, too, ! 597: * but is best done later on. ! 598: */ ! 599: if (((r=p->in.right)->tn.op == ICON ! 600: && r->tn.lval == 0 && r->tn.name[0] == '\0' ) ! 601: || (r->tn.op == FCON && r->fpn.dval == 0.0 )) { ! 602: goto promoteleft; ! 603: } ! 604: break; ! 605: ! 606: case MUL: ! 607: /* ! 608: * put constants on the right ! 609: */ ! 610: if (p->in.left->in.op == ICON && p->in.right->in.op != ICON) { ! 611: r = p->in.right; ! 612: p->in.right = p->in.left; ! 613: p->in.left = r; ! 614: } ! 615: /* fall through */ ! 616: ! 617: case ASG MUL: ! 618: case DIV: ! 619: case ASG DIV: ! 620: case MOD: ! 621: case ASG MOD: ! 622: /* ! 623: * two interesting case: <lhs> <op> 1 ! 624: * and: small multiplies that can be handled by ! 625: * the feeble instructions. ! 626: */ ! 627: if (((r=p->in.right)->tn.op == ICON ! 628: && r->tn.lval == 1 && r->tn.name[0] == '\0') ! 629: || (r->tn.op == FCON && r->fpn.dval == 1.0 )) { ! 630: switch (op){ ! 631: case MOD: ! 632: case ASG MOD: ! 633: /* ! 634: * x%1 == 0 ! 635: * BUT x might have side effects, so... ! 636: * x%1 ==> (x,0) ! 637: */ ! 638: p->in.op = COMOP; ! 639: if (r->tn.op==FCON) ! 640: r->fpn.dval = 0.0; ! 641: else ! 642: r->tn.lval = 0; ! 643: break; ! 644: default: ! 645: goto promoteleft; ! 646: } ! 647: break; ! 648: } ! 649: if (op == DIV || op == ASG DIV){ ! 650: /* ! 651: * a very particular case: a difference of two ! 652: * pointers, divided by a power of two should ! 653: * always give an integral result (this is ! 654: * pointer subtraction, with the implied divide ! 655: * by sizeof( *p ) ). So, we can change this ! 656: * into a shift, if we ever see it. ! 657: * AND... ! 658: * a less peculiar case: unsigned divide by a power of 2. ! 659: */ ! 660: if ( ! 661: (p->in.type == UNSIGNED && r->in.op ==ICON ) ! 662: || ((p->in.type == INT || p->in.type == UNSIGNED) ! 663: && r->in.op == ICON && (q = p->in.left)->in.op == MINUS ! 664: && ISPTR(q->in.left->in.type) ! 665: && ISPTR(q->in.right->in.type)) ! 666: ){ ! 667: if (cntbits( v=r->tn.lval )==1 && r->in.name[0]=='\0' ){ ! 668: /* well, looks like we found one */ ! 669: w = ffs( v ) - 1; ! 670: p->in.op = op += RS - DIV; /* keep ASG if present */ ! 671: r->tn.lval = w; ! 672: break; ! 673: } ! 674: } ! 675: } ! 676: /* the other good case is multiply by a power of two, ! 677: and thats already being handled in the front end */ ! 678: /* ! 679: * many multiplies ! 680: * can be done directly in the hardware: ! 681: * {SHORT, USHORT, CHAR, UCHAR} x ! 682: * {SHORT, USHORT, CHAR, UCHAR, ICON} ! 683: * ! 684: * so can the corresponding divides. ! 685: */ ! 686: if (p->in.type != INT && p->in.type != UNSIGNED && ! 687: !ISPTR(p->in.type)) ! 688: break; ! 689: q = p->in.left; ! 690: if ( isconv(q, SHORT, USHORT ) ) lsize = 2; ! 691: else if (isconv(q, CHAR, UCHAR )) lsize = 1; ! 692: else if (q->in.type == SHORT) lsize = 0; ! 693: else break; ! 694: if ( isconv(r, SHORT, USHORT ) || ! 695: special(r, SSCON) ) rsize = 2; ! 696: else if (isconv(r, CHAR, UCHAR )) rsize = 1; ! 697: else break; ! 698: /* we've looked at both sides and it looks plausable */ ! 699: /* rearrange lhs */ ! 700: if (lsize == 1){ ! 701: /* diddle SCONV, but leave it in place */ ! 702: q->in.type = (q->in.left->tn.type==UCHAR)?USHORT:SHORT; ! 703: } else if(lsize == 2){ ! 704: p->in.left = q->in.left; ! 705: q->in.op = FREE; ! 706: } ! 707: /* now rearrange rhs */ ! 708: if (rsize == 1){ ! 709: r->in.type = (r->in.left->tn.type==UCHAR)?USHORT:SHORT; ! 710: } else if (r->tn.op == ICON){ ! 711: r->tn.type = SHORT; ! 712: } else { ! 713: p->in.right = r->in.left; ! 714: r->in.op = FREE; ! 715: } ! 716: /* ! 717: * The result of the mul[us] instructions are ints ! 718: * anyway, so leave the type of the MUL node alone. ! 719: * But DIV must be acknowleged as short. ! 720: */ ! 721: if ( (op==DIV || op== ASG DIV || op==MOD || op==ASG MOD) ! 722: && p->in.type != SHORT && p->in.type != USHORT){ ! 723: w = (p->in.right->tn.type==SHORT && p->in.left->tn.type==SHORT) ? SHORT : USHORT; ! 724: q = talloc(); ! 725: *q = *p; ! 726: p->in.op = SCONV; ! 727: q->in.type = w; ! 728: p->in.left = q; ! 729: p->in.right = 0; ! 730: } ! 731: break; ! 732: case SCONV: ! 733: /* ! 734: * conversions from float to double ! 735: * in a coprocessor register are vacuous ! 736: */ ! 737: q = p->in.left; ! 738: if (p->in.type == DOUBLE && q->in.type == FLOAT ! 739: && q->in.op == REG && iscreg(q->tn.rval)) { ! 740: TWORD t = p->in.type; ! 741: *p = *q; ! 742: p->in.type = t; ! 743: q->in.op = FREE; ! 744: return; ! 745: } ! 746: /* ! 747: * John Gilmore memorial hack ! 748: * ! 749: * garbage-can case: ! 750: * if this is a shorten of a simple calculation ! 751: * whose (2) operands are no larger than the ! 752: * result type, then we can do the operation more ! 753: * cheaply, no? ! 754: * The architypical case looks like: ! 755: * (SCONV<short> (+<int> (SCONV<int> NAME<short> ) ICON )) ! 756: * p^ q^ r^ ! 757: */ ! 758: if ( q->in.type!=INT && q->in.type!=UNSIGNED ) return; ! 759: switch (q->in.op){ ! 760: case PLUS: ! 761: case MINUS: ! 762: case MUL: ! 763: case DIV: ! 764: case MOD: ! 765: case LS: ! 766: case RS: ! 767: case AND: ! 768: case OR: ! 769: case ER: ! 770: break; ! 771: default: ! 772: return; ! 773: } ! 774: if ( p->in.type==SHORT || p->in.type==USHORT ){ ! 775: w = 2; ! 776: v = 0x7fff; ! 777: }else if ( p->in.type==CHAR || p->in.type==UCHAR ){ ! 778: w = 1; ! 779: v = 0x7f; ! 780: }else break; ! 781: qq = q; ! 782: r = q->in.right; ! 783: q = q->in.left; ! 784: if ( isconv(q, SHORT, USHORT ) ) lsize = 2; ! 785: else if (isconv(q, CHAR, UCHAR )) lsize = 1; ! 786: else if (q->in.op == ICON) ! 787: if (q->tn.name[0] == '\0' ! 788: && ((q->tn.lval | v)==v || (q->tn.lval|v)==-1)) ! 789: lsize = 0; ! 790: else break; ! 791: else if (tlen(q) < sizeof(long)) lsize = -1; ! 792: else break; ! 793: if ( isconv(r, SHORT, USHORT ) ) rsize = 2; ! 794: else if (isconv(r, CHAR, UCHAR )) rsize = 1; ! 795: else if (r->in.op == ICON) ! 796: if (r->tn.name[0] == '\0' ! 797: && ((r->tn.lval | v)==v || (r->tn.lval|v)==-1)) ! 798: rsize = 0; ! 799: else break; ! 800: else if (tlen(r) < sizeof(long)) rsize = -1; ! 801: else break; ! 802: if (lsize == -1) { ! 803: NODE *t = talloc(); ! 804: t->in.op = SCONV; ! 805: t->in.type = qq->in.type; ! 806: t->in.left = q; ! 807: lsize = tlen(q); ! 808: q = t; ! 809: qq->in.left = q; ! 810: } ! 811: if (rsize == -1) { ! 812: NODE *t = talloc(); ! 813: t->in.op = SCONV; ! 814: t->in.type = qq->in.type; ! 815: t->in.left = r; ! 816: rsize = tlen(r); ! 817: r = t; ! 818: qq->in.right = r; ! 819: } ! 820: if (rsize > w || lsize > w) { ! 821: /* must preserve top SCONV, but weaken operation */ ! 822: p = p->in.left; ! 823: if (rsize >lsize){ ! 824: p->in.type = r->in.left->in.type ; ! 825: w = rsize; ! 826: } else { ! 827: p->in.type = q->in.left->in.type; ! 828: w = lsize; ! 829: } ! 830: } else { ! 831: /* clobber SCONV */ ! 832: NODE * t = p->in.left; ! 833: TWORD tt = p->in.type; ! 834: *p = *t; /* paint over */ ! 835: p->in.type = tt; /* except type */ ! 836: t->in.op = FREE; /* give a node back */ ! 837: } ! 838: /* now weaken or elide child convs */ ! 839: switch (lsize){ ! 840: case 0: /* ICON -- diddle type */ ! 841: q->in.type = p->in.type; break; ! 842: case 1: /* char */ ! 843: if (lsize <w){ ! 844: /* retain SCONV but weaken */ ! 845: q->in.type = p->in.type; break; ! 846: } ! 847: /* else fall through */ ! 848: case 2: /* same size -- elide SCONV */ ! 849: { NODE * t = q->in.left; ! 850: *q = *t; ! 851: t->in.op = FREE; ! 852: } ! 853: } ! 854: switch (rsize){ ! 855: case 0: /* ICON -- diddle type */ ! 856: r->in.type = p->in.type; break; ! 857: case 1: /* char */ ! 858: if (rsize <w){ ! 859: /* retain SCONV but weaken */ ! 860: r->in.type = p->in.type; break; ! 861: } ! 862: /* else fall through */ ! 863: case 2: /* same size -- elide SCONV */ ! 864: { NODE * t = r->in.left; ! 865: *r = *t; ! 866: t->in.op = FREE; ! 867: } ! 868: } ! 869: break; ! 870: case CHK: ! 871: /* ! 872: * A CHK with constant bounds, of which the left-hand-side ! 873: * is an SCONV that widens a shorter type can be converted ! 874: * to an SCONV over a CHK. This lets us use weaker CHK ! 875: * instructions. ! 876: */ ! 877: if (p->in.type != INT && p->in.type != UNSIGNED) break; ! 878: q = p->in.left; ! 879: if (!isconv(q, CHAR, UCHAR) && !isconv(q, SHORT, USHORT) )break; ! 880: r = p->in.right; ! 881: rr = r->in.right; ! 882: rl = r->in.left; ! 883: if (rr->in.op != ICON || rl->in.op != ICON) break; ! 884: /* ! 885: * make bounds smaller using the type of the ! 886: * converted operand ! 887: */ ! 888: t = q->in.left->in.type; ! 889: switch(t) { ! 890: case CHAR: ! 891: if (reduce_bounds(-128, 127, rl, rr)) ! 892: goto delete_check; ! 893: break; ! 894: case UCHAR: ! 895: if (reduce_bounds(0, 255, rl, rr)) ! 896: goto delete_check; ! 897: break; ! 898: case SHORT: ! 899: if (reduce_bounds(-32768, 32767, rl, rr)) ! 900: goto delete_check; ! 901: break; ! 902: case USHORT: ! 903: if (reduce_bounds(0, 65535, rl, rr)) ! 904: goto delete_check; ! 905: break; ! 906: delete_check: ! 907: *p = *q; ! 908: q->in.op = FREE; ! 909: tfree(r); ! 910: return; ! 911: } ! 912: /* ! 913: * weaken the conversion by ! 914: * exchanging CHK and SCONV nodes ! 915: */ ! 916: *p = *q; /* p becomes SCONV node */ ! 917: p->in.left = q; ! 918: q->in.op = CHK; ! 919: q->in.right = r; ! 920: q->in.type = r->in.type = rl->tn.type = rr->tn.type = t; ! 921: break; ! 922: ! 923: case INIT: ! 924: /* ! 925: * not an optimization, but prevents an ! 926: * infinite loop later on in code generation... ! 927: */ ! 928: q = p->in.left; ! 929: if (q->in.op != ICON && q->in.op != FCON) { ! 930: uerror("Illegal initialization"); ! 931: tfree(q); ! 932: q = talloc(); ! 933: q->in.type = p->in.type; ! 934: if (ISFLOATING(p->in.type)) { ! 935: q->in.op = FCON; ! 936: q->fpn.dval = 0.0; ! 937: } else { ! 938: q->in.op = ICON; ! 939: q->tn.name = ""; ! 940: q->tn.lval = 0; ! 941: } ! 942: p->in.left = q; ! 943: } ! 944: break; ! 945: ! 946: case FORCE: ! 947: /* ! 948: * if the type of a FORCE op is {u}char or {u}short, ! 949: * extend it into an INT. ! 950: */ ! 951: switch(p->in.type){ ! 952: case CHAR: ! 953: case UCHAR: ! 954: case SHORT: ! 955: case USHORT: ! 956: q = talloc(); ! 957: q->in.op = SCONV; ! 958: q->in.type = INT; ! 959: q->in.left = p->in.left; ! 960: q->in.right = NULL; ! 961: p->in.left = q; ! 962: p->in.type = INT; ! 963: break; ! 964: } ! 965: break; ! 966: ! 967: } /* switch */ ! 968: } ! 969: ! 970: /* ! 971: * reduce bounds of a range check using ! 972: * the known bounds of the domain type ! 973: */ ! 974: int ! 975: reduce_bounds(domain_min, domain_max, range_min, range_max) ! 976: register CONSZ domain_min, domain_max; ! 977: register NODE *range_min, *range_max; ! 978: { ! 979: /* do the domain and range intersect? */ ! 980: if (domain_min > range_max->tn.lval || domain_max < range_min->tn.lval) { ! 981: /* expression value is known to lie outside required range */ ! 982: werror("expression value is out of range"); ! 983: } ! 984: /* range := intersection(range, domain) */ ! 985: if (domain_min > range_min->tn.lval) ! 986: range_min->tn.lval = domain_min; ! 987: if (domain_max < range_max->tn.lval) ! 988: range_max->tn.lval = domain_max; ! 989: /* if domain is a subset of range, range check is unnecessary */ ! 990: if (domain_min >= range_min->tn.lval && domain_max <= range_max->tn.lval) { ! 991: return(1); ! 992: } ! 993: return(0); ! 994: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.