![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtree1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1|
Return to mtree1.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 |
1.1 ! root 1: /* ! 2: * The routines in this file ! 3: * are a portable associative tree ! 4: * reorderer and constant expression ! 5: * folder. They may not be general ! 6: * enough for all machines. ! 7: */ ! 8: #ifdef vax ! 9: #include "INC$LIB:cc1.h" ! 10: #else ! 11: #include "cc1.h" ! 12: #endif ! 13: ! 14: #define NLNODE 20 ! 15: #define NONODE 20 ! 16: ! 17: static char cltc[] = "associative expression too complex"; ! 18: TREE *fold1(); ! 19: TREE *foldaddr(); ! 20: ! 21: /* ! 22: * Fancy folder. ! 23: * Gathers up all the constants that ! 24: * in can, by digging through the ! 25: * subtrees of commutative/associative ! 26: * operations. Simpler things are ! 27: * done for operations that are not quite ! 28: * so friendly. ! 29: * Returns a pointer to the new ! 30: * tree. ! 31: */ ! 32: TREE * ! 33: modfold(tp) ! 34: register TREE *tp; ! 35: { ! 36: register TREE *lp, **rp; ! 37: int i, nl, nn, op, cop; ! 38: lval_t c1; ! 39: TREE *leaves[NLNODE], *onodes[NONODE]; ! 40: ! 41: op = tp->t_op; ! 42: if (op==NEG && tp->t_lp->t_op==DCON) { ! 43: tp = tp->t_lp; ! 44: #if IEEE|DECVAX ! 45: tp->t_dval[DVALIS] ^= DVALMS; ! 46: #else ! 47: #if MCFFP ! 48: if ((((int)tp->t_dval[3])&0377) != 0) ! 49: tp->t_dval[3] ^= 0200; ! 50: #else ! 51: dvalneg((char *)tp->t_dval); ! 52: #endif ! 53: #endif ! 54: return (tp); ! 55: } ! 56: if (isleaf(op) || isflt(tp->t_type)) ! 57: return (tp); ! 58: if (op==CONVERT || op==CAST) { ! 59: lp = tp->t_lp; ! 60: if ((cop=lp->t_op)==ICON || cop==LCON) { ! 61: c1 = grabnval(lp); ! 62: if (islong(tp->t_type)) ! 63: lp = lvalnode(c1); else ! 64: lp = ivalnode((int) c1); ! 65: lp->t_type = tp->t_type; ! 66: lp->t_size = tp->t_size; ! 67: return (lp); ! 68: } ! 69: } ! 70: if (op!=ADD && op!=MUL && op!=AND && op!=OR && op!=XOR) { ! 71: lp = fold1(op, tp->t_lp, tp->t_rp); ! 72: if (lp != NULL) ! 73: return (lp); ! 74: return (tp); ! 75: } ! 76: nn = nl = 0; ! 77: cluster(tp, op, tp->t_type, &nn, &nl, onodes, leaves); ! 78: rp = &leaves[--nl]; ! 79: for (i = nl; i > 0; ) { ! 80: lp = fold1(op, rp[0], rp[-1]); ! 81: if (lp == NULL) ! 82: break; ! 83: --nl; ! 84: --rp; ! 85: rp[0] = lp; ! 86: --i; ! 87: } ! 88: tp = rp[0]; ! 89: if (op==ADD || op==OR || op==XOR) { ! 90: if (nl>0 && isnval(tp, 0)) ! 91: --nl; ! 92: if (nl <= 0) ! 93: return (leaves[0]); ! 94: } ! 95: if (op==MUL || op==AND) { ! 96: if (isnval(tp, 0)) ! 97: return (tp); ! 98: if (op==MUL && nl>0 && isnval(tp, 1)) ! 99: --nl; ! 100: } ! 101: if (nl <= 0) ! 102: return (leaves[0]); ! 103: rp = &leaves[0]; ! 104: tp = leaves[0]; ! 105: for (i=0; i<nl; ++i) { ! 106: lp = onodes[i]; ! 107: lp->t_rp = *++rp; ! 108: lp->t_lp = tp; ! 109: tp = lp; ! 110: if (op==ADD && isblkp(tp->t_type)==0) ! 111: fixaddtype(tp); ! 112: } ! 113: return (tp); ! 114: } ! 115: ! 116: /* ! 117: * Collect up an associative ! 118: * operator cluster. Pack it into the ! 119: * supplied buffers. ! 120: */ ! 121: cluster(tp, op, type, ann, anl, onodes, leaves) ! 122: register TREE *tp; ! 123: int *ann, *anl; ! 124: register TREE *onodes[], *leaves[]; ! 125: { ! 126: register i, nl; ! 127: int nn; ! 128: TREE *xp; ! 129: ! 130: if (tp->t_op==op && tp->t_type==type) { ! 131: nn = *ann; ! 132: if ((*ann)++ >= NONODE) ! 133: cfatal(cltc); ! 134: onodes[nn] = tp; ! 135: cluster(tp->t_lp, op, type, ann, anl, onodes, leaves); ! 136: cluster(tp->t_rp, op, type, ann, anl, onodes, leaves); ! 137: return; ! 138: } ! 139: nl = *anl; ! 140: if ((*anl)++ >= NLNODE) ! 141: cfatal(cltc); ! 142: if (isncon(tp->t_op)) { ! 143: leaves[nl] = tp; ! 144: return; ! 145: } ! 146: for (i = nl; i > 0; ) { ! 147: xp = leaves[i-1]; ! 148: if (tp->t_op==ADDR && !isncon(xp->t_op)) ! 149: break; ! 150: if (tp->t_op==STAR && xp->t_op==STAR) ! 151: break; ! 152: leaves[i] = xp; ! 153: --i; ! 154: } ! 155: leaves[i] = tp; ! 156: } ! 157: ! 158: /* ! 159: * Fold an operation. ! 160: * Return a pointer to the folded ! 161: * tree, or NULL if no fold is ! 162: * possible. ! 163: */ ! 164: TREE * ! 165: fold1(op, lp, rp) ! 166: TREE *lp, *rp; ! 167: { ! 168: register TREE *fp; ! 169: register sop, lrf; ! 170: register tt; ! 171: lval_t c1, c2; ! 172: ! 173: if ((fp = foldaddr(op, lp, rp)) != NULL) ! 174: return (fp); ! 175: lrf = 0; ! 176: if ((sop=lp->t_op)!=ICON && sop!=LCON) ! 177: return (NULL); ! 178: c1 = grabnval(lp); ! 179: tt = lp->t_type; ! 180: if (sop == LCON) ! 181: ++lrf; ! 182: if (op == QUEST) { ! 183: return (c1 ? rp->t_lp : rp->t_rp); ! 184: } ! 185: if (rp != NULL) { ! 186: if ((sop=rp->t_op)!=ICON && sop!=LCON) ! 187: return (NULL); ! 188: c2 = grabnval(rp); ! 189: if (rp->t_type > tt) ! 190: tt = rp->t_type; ! 191: if (sop == LCON) ! 192: ++lrf; ! 193: } ! 194: switch (op) { ! 195: ! 196: case COM: ! 197: c1 = ~c1; ! 198: break; ! 199: ! 200: case NOT: ! 201: c1 = !c1; ! 202: break; ! 203: ! 204: case NEG: ! 205: c1 = -c1; ! 206: break; ! 207: ! 208: case ADD: ! 209: c1 += c2; ! 210: break; ! 211: ! 212: case SUB: ! 213: c1 -= c2; ! 214: break; ! 215: ! 216: case MUL: ! 217: c1 *= c2; ! 218: break; ! 219: ! 220: case DIV: ! 221: if (c2 == 0) ! 222: return (NULL); ! 223: c1 /= c2; ! 224: break; ! 225: ! 226: case REM: ! 227: if (c2 == 0) ! 228: return (NULL); ! 229: c1 %= c2; ! 230: break; ! 231: ! 232: case AND: ! 233: c1 &= c2; ! 234: break; ! 235: ! 236: case OR: ! 237: c1 |= c2; ! 238: break; ! 239: ! 240: case XOR: ! 241: c1 ^= c2; ! 242: break; ! 243: ! 244: case SHL: ! 245: c1 <<= c2; ! 246: break; ! 247: ! 248: case SHR: ! 249: c1 >>= c2; ! 250: break; ! 251: ! 252: case EQ: ! 253: c1 = c1==c2; ! 254: break; ! 255: ! 256: case NE: ! 257: c1 = c1!=c2; ! 258: break; ! 259: ! 260: case LT: ! 261: c1 = c1<c2; ! 262: break; ! 263: ! 264: case LE: ! 265: c1 = c1<=c2; ! 266: break; ! 267: ! 268: case GT: ! 269: c1 = c1>c2; ! 270: break; ! 271: ! 272: case GE: ! 273: c1 = c1>=c2; ! 274: break; ! 275: ! 276: case ANDAND: ! 277: c1 = (c1 && c2); ! 278: break; ! 279: ! 280: case OROR: ! 281: c1 = (c1 || c2); ! 282: break; ! 283: ! 284: default: ! 285: return (NULL); ! 286: } ! 287: if (lrf && op!=ANDAND && op!=OROR && !isrelop(op)) ! 288: fp = lvalnode(c1); ! 289: else ! 290: fp = ivalnode((int) c1); ! 291: fp->t_type = tt; ! 292: return (fp); ! 293: } ! 294: ! 295: /* ! 296: * Fold things that look like ! 297: * `&array[constant]' where the array ! 298: * is an external or a static. ! 299: */ ! 300: TREE * ! 301: foldaddr(op, lp, rp) ! 302: register TREE *lp, *rp; ! 303: { ! 304: register TREE *xp; ! 305: long val; ! 306: ! 307: if (op==ADD || op==SUB) { ! 308: if (lp->t_op==ADDR ! 309: && (rp->t_op==LCON || rp->t_op==ICON)) { ! 310: xp = lp->t_lp; ! 311: if (xp->t_op==LID || xp->t_op==GID) { ! 312: val = grabnval(rp); ! 313: if (op == ADD) ! 314: xp->t_offs += val; ! 315: else ! 316: xp->t_offs -= val; ! 317: return (lp); ! 318: } ! 319: } ! 320: if (op==ADD && rp->t_op==ADDR ! 321: && (lp->t_op==LCON || lp->t_op==ICON)) { ! 322: xp = rp->t_lp; ! 323: if (xp->t_op==LID || xp->t_op==GID) { ! 324: xp->t_offs += grabnval(lp); ! 325: return (rp); ! 326: } ! 327: } ! 328: } ! 329: return (NULL); ! 330: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.