![[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 / b / bin / c / n1|
Return to mtree1.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / n1 |
1.1 ! root 1: /* ! 2: * n1/mtree1.c ! 3: * A portable associative tree reorderer and constant expression folder. ! 4: * This may not be general enough for all machines. ! 5: */ ! 6: ! 7: #ifdef vax ! 8: #include "INC$LIB:cc1.h" ! 9: #else ! 10: #include "cc1.h" ! 11: #endif ! 12: ! 13: #if _I386 ! 14: #define NLNODE 128 ! 15: #define NONODE 128 ! 16: #else ! 17: #define NLNODE 20 ! 18: #define NONODE 20 ! 19: #endif ! 20: ! 21: static char cltc[] = "associative expression too complex"; ! 22: TREE *fold1(); ! 23: TREE *foldaddr(); ! 24: ! 25: /* ! 26: * Fancy folder. ! 27: * This gathers up all the constants that it can ! 28: * by digging through the subtrees of commutative/associative operations. ! 29: * Simpler things are done for operations that are not quite so friendly. ! 30: * Returns a pointer to the new 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 = constcvt(tp->t_type, grabnval(lp)); ! 62: if (islong(tp->t_type)) ! 63: lp = lvalnode(c1); else ! 64: lp = ivalnode((ival_t) 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 operator cluster. ! 118: * Pack it into the supplied buffers. ! 119: */ ! 120: cluster(tp, op, type, ann, anl, onodes, leaves) ! 121: register TREE *tp; ! 122: int *ann, *anl; ! 123: register TREE *onodes[], *leaves[]; ! 124: { ! 125: register i, nl; ! 126: int nn; ! 127: TREE *xp; ! 128: ! 129: if (tp->t_op==op && tp->t_type==type) { ! 130: nn = *ann; ! 131: if ((*ann)++ >= NONODE) ! 132: cfatal(cltc); ! 133: onodes[nn] = tp; ! 134: cluster(tp->t_lp, op, type, ann, anl, onodes, leaves); ! 135: cluster(tp->t_rp, op, type, ann, anl, onodes, leaves); ! 136: return; ! 137: } ! 138: nl = *anl; ! 139: if ((*anl)++ >= NLNODE) ! 140: cfatal(cltc); ! 141: if (isncon(tp->t_op)) { ! 142: leaves[nl] = tp; ! 143: return; ! 144: } ! 145: for (i = nl; i > 0; ) { ! 146: xp = leaves[i-1]; ! 147: if (tp->t_op==ADDR && !isncon(xp->t_op)) ! 148: break; ! 149: if (tp->t_op==STAR && xp->t_op==STAR) ! 150: break; ! 151: leaves[i] = xp; ! 152: --i; ! 153: } ! 154: leaves[i] = tp; ! 155: } ! 156: ! 157: /* ! 158: * Fold an operation. ! 159: * Return a pointer to the folded tree, ! 160: * or NULL if no fold is possible. ! 161: * FIX_ME This should pay attention to unsigned types like n0/fold.c/fold0(). ! 162: */ ! 163: TREE * ! 164: fold1(op, lp, rp) int op; TREE *lp, *rp; ! 165: { ! 166: register TREE *fp; ! 167: register int sop, lflag, tt, bool; ! 168: lval_t lv, rv; ! 169: ! 170: if ((fp = foldaddr(op, lp, rp)) != NULL) ! 171: return fp; ! 172: if ((sop = lp->t_op)!=ICON && sop!=LCON) ! 173: return NULL; ! 174: lv = grabnval(lp); ! 175: tt = lp->t_type; ! 176: lflag = (sop == LCON); ! 177: if (op == QUEST) ! 178: return (lv) ? rp->t_lp : rp->t_rp; ! 179: if (rp != NULL) { ! 180: if ((sop = rp->t_op)!=ICON && sop!=LCON) ! 181: return NULL; ! 182: rv = grabnval(rp); ! 183: if (rp->t_type > tt) ! 184: tt = rp->t_type; ! 185: if (sop == LCON) ! 186: ++lflag; ! 187: } ! 188: bool = -1; ! 189: ! 190: /* Perform the folding, result to lv or bool. */ ! 191: switch (op) { ! 192: ! 193: case COM: lv = ~lv; break; ! 194: case NEG: lv = -lv; break; ! 195: case ADD: lv += rv; break; ! 196: case SUB: lv -= rv; break; ! 197: case MUL: lv *= rv; break; ! 198: case AND: lv &= rv; break; ! 199: case OR: lv |= rv; break; ! 200: case XOR: lv ^= rv; break; ! 201: case SHL: lv <<= rv; break; ! 202: case SHR: lv >>= rv; break; ! 203: ! 204: case DIV: ! 205: if (rv == 0) ! 206: return NULL; ! 207: lv /= rv; ! 208: break; ! 209: ! 210: case REM: ! 211: if (rv == 0) ! 212: return NULL; ! 213: lv %= rv; ! 214: break; ! 215: ! 216: case NOT: bool = !lv; break; ! 217: case EQ: bool = lv == rv; break; ! 218: case NE: bool = lv != rv; break; ! 219: case LT: bool = lv < rv; break; ! 220: case LE: bool = lv <= rv; break; ! 221: case GT: bool = lv > rv; break; ! 222: case GE: bool = lv >= rv; break; ! 223: case ANDAND: bool = (lv && rv); break; ! 224: case OROR: bool = (lv || rv); break; ! 225: ! 226: default: ! 227: return NULL; ! 228: } ! 229: ! 230: if (bool != -1) ! 231: fp = ivalnode((ival_t)bool); ! 232: else if (lflag) ! 233: fp = lvalnode(lv); ! 234: else ! 235: fp = ivalnode((ival_t) lv); ! 236: fp->t_type = tt; ! 237: return fp; ! 238: } ! 239: ! 240: /* ! 241: * Fold things that look like '&array[constant]' ! 242: * where the array is an external or a static. ! 243: */ ! 244: TREE * ! 245: foldaddr(op, lp, rp) ! 246: register TREE *lp, *rp; ! 247: { ! 248: register TREE *xp; ! 249: long val; ! 250: ! 251: if (op==ADD || op==SUB) { ! 252: if (lp->t_op==ADDR ! 253: && (rp->t_op==LCON || rp->t_op==ICON)) { ! 254: xp = lp->t_lp; ! 255: if (xp->t_op==LID || xp->t_op==GID) { ! 256: val = grabnval(rp); ! 257: if (op == ADD) ! 258: xp->t_offs += val; ! 259: else ! 260: xp->t_offs -= val; ! 261: return lp; ! 262: } ! 263: } ! 264: if (op==ADD && rp->t_op==ADDR ! 265: && (lp->t_op==LCON || lp->t_op==ICON)) { ! 266: xp = rp->t_lp; ! 267: if (xp->t_op==LID || xp->t_op==GID) { ! 268: xp->t_offs += grabnval(lp); ! 269: return rp; ! 270: } ! 271: } ! 272: } ! 273: return NULL; ! 274: } ! 275: ! 276: /* end of n1/mtree1.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.