![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fold.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 / n0|
Return to fold.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / n0 |
1.1 root 1: /*
2: * n0/fold.c
3: * Constant expression folder for the C compiler parser.
4: * More of this is done in the code generator.
5: * This one exists only to allow constant expressions in case labels,
6: * in array bounds, and in initializers.
7: */
8:
9: #ifdef vax
10: #include "INC$LIB:cc0.h"
11: #else
12: #include "cc0.h"
13: #endif
14:
15: extern lval_t grablval();
16:
17: #if FOLD_DOUBLES
18: /*
19: * The double folding code below assumes that the compiler host and target fp
20: * representations are identical,
21: * an assumption the compiler source carefully avoids making everywhere else.
22: * If host fp == target fp,
23: * ordinary C fp operations (+, -, *, / etc.) can be used in folding.
24: * If host fp != target fp, folding requires format translation or emulation.
25: * A compiler produced with this option uses fp,
26: * so in particular the verison of fp it uses must run on all target systems;
27: * e.g., if you compile the compiler -VNDP then the target will need
28: * either an NDP or NDP emulation.
29: */
30: extern TREE *foldd();
31: extern double grabdval();
32: #endif
33:
34: /*
35: * Try to fold constants.
36: * The given op must be appropriate for folding,
37: * the left subtree must be a constant (ICON/LCON/ZCON/DCON), and
38: * the right subtree (if any) must be a constant (ICON/LCON/ZCON/DCON)
39: * for folding to work.
40: * Return pointer to a constant tree node,
41: * or NULL if folding is impossible.
42: * This code is very casual about lval_t/ulval_t bit equivalence.
43: * Folds double constants if FOLD_DOUBLES.
44: */
45: TREE *
46: fold0(op, lp, rp) int op; TREE *lp, *rp;
47: {
48: register TREE *tp;
49: register lval_t lv, rv;
50: int bool;
51: register int lt, rt, gt, uflag, zflag, lflag;
52:
53: /* Check op dope table to make sure op has a chance of folding. */
54: if ((opdope[op - MIOBASE] & FOLD) == 0)
55: return NULL;
56:
57: /* Check for constant left subtree. */
58: if (!isconst(lp))
59: return NULL;
60: lt = lp->t_type;
61:
62: /* Handle ?: without further ado. */
63: if (op == QUEST) {
64: if (rp->t_op != COLON)
65: return NULL; /* parsing must be fubar */
66: return (grablval(lp, 0)) ? rp->t_lp : rp->t_rp;
67: }
68:
69: /* Handle ',' with constant on lhs without further ado. */
70: if (op == COMMA)
71: return rp;
72:
73: if (rp != NULL) {
74: /* Check for constant right subtree. */
75: if (!isconst(rp))
76: return NULL;
77: rt = rp->t_type;
78: } else
79: rt = lt; /* Unary ops: no right subtree */
80:
81: /*
82: * Find the goal type in the conversion dope table.
83: * Watch out for shifts, right type implicitly T_INT.
84: */
85: if (op == SHL || op == SHR)
86: rt = T_INT;
87: gt = cvdope[13 * (lt - T_CHAR) + (rt - T_CHAR)] & GOAL;
88:
89: /* Set unsigned, long, ZCON flags based on goal type. */
90: uflag = (gt == T_UINT || gt == T_ULONG);
91: lflag = (gt == T_LONG || gt == T_ULONG);
92: zflag = (lp->t_op == ZCON || (rp != NULL && rp->t_op == ZCON));
93:
94: #if FOLD_DOUBLES
95: /* Fold as doubles if goal type is double. */
96: if (gt == T_DOUBLE) {
97: if (opdope[op - MIOBASE] & NFLT)
98: return NULL; /* op is illegal in any case */
99: return foldd(op, lp, rp);
100: }
101: #endif
102:
103: /* Grab the left and right values as [u]lval_t. */
104: lv = grablval(lp, uflag);
105: if (rp != NULL)
106: rv = grablval(rp, uflag);
107:
108: /* Perform the folding, computing result in lv or in bool (0 or 1). */
109: bool = -1;
110: switch (op) {
111:
112: case COM: lv = ~lv; break;
113: case NEG: lv = -lv; break;
114: case ADD: lv += rv; break;
115: case SUB: lv -= rv; break;
116: case MUL: lv *= rv; break;
117: case AND: lv &= rv; break;
118: case OR: lv |= rv; break;
119: case XOR: lv ^= rv; break;
120: case SHL: lv <<= rv; break;
121:
122: /* Ops /, % and >> are different for signed and unsigned cases. */
123: case DIV:
124: if (rv == 0) {
125: cwarn("divide by zero");
126: return NULL;
127: }
128: if (uflag)
129: lv = ((ulval_t)lv / (ulval_t)rv);
130: else
131: lv /= rv;
132: break;
133:
134: case REM:
135: if (rv == 0) {
136: cwarn("zero modulus");
137: return NULL;
138: }
139: if (uflag)
140: lv = ((ulval_t)lv % (ulval_t)rv);
141: else
142: lv %= rv;
143: break;
144:
145: case SHR:
146: if (uflag)
147: lv = ((ulval_t)lv >> (ulval_t)rv);
148: else
149: lv >>= rv;
150: break;
151:
152: /* Relations and conditionals return T_INT result in bool. */
153: case NOT: bool = !lv; break;
154: case EQ: bool = lv == rv; break;
155: case NE: bool = lv != rv; break;
156: case ANDAND: bool = (lv && rv); break;
157: case OROR: bool = (lv || rv); break;
158: /* Nonequality relations are different for signed and unsigned cases. */
159: case LT:
160: bool = (uflag) ? ((ulval_t)lv < (ulval_t)rv) : (lv < rv);
161: break;
162: case LE:
163: bool = (uflag) ? ((ulval_t)lv <= (ulval_t)rv) : (lv <= rv);
164: break;
165: case GT:
166: bool = (uflag) ? ((ulval_t)lv > (ulval_t)rv) : (lv > rv);
167: break;
168: case GE:
169: bool = (uflag) ? ((ulval_t)lv >= (ulval_t)rv) : (lv >= rv);
170: break;
171:
172: default: /* shouldn't happen if opdope is right */
173: return NULL;
174: }
175:
176: /* Allocate a TREE for the result, store result, return it. */
177: tp = talloc();
178: if (bool != -1) { /* boolean result */
179: tp->t_op = ICON;
180: tp->t_type = T_INT;
181: tp->t_ival = bool;
182: } else if (lflag) { /* [u]long result */
183: tp->t_op = LCON;
184: tp->t_type = (uflag) ? T_ULONG : T_LONG;
185: tp->t_lval = lv;
186: } else if (zflag) { /* size_t result */
187: tp->t_op = ZCON;
188: tp->t_type = T_UINT;
189: tp->t_zval = lv;
190: } else { /* [u]int result */
191: tp->t_op = ICON;
192: tp->t_type = (uflag) ? T_UINT : T_INT;
193: tp->t_ival = lv;
194: }
195: return tp;
196: }
197:
198: /*
199: * Return true if tp represents a constant (ICON, LCON, ZCON, DCON).
200: */
201: int
202: isconst(tp) register TREE *tp;
203: {
204: register int op;
205:
206: return (tp->t_dp == NULL
207: && ((op = tp->t_op) == ICON
208: || op == LCON
209: || op == ZCON
210: #if FOLD_DOUBLES
211: || op == DCON
212: #endif
213: ));
214: }
215:
216: /*
217: * Grab the value of a constant as an lval_t (or ulval_t, really).
218: * Zero extend if the goal type is unsigned.
219: */
220: lval_t
221: grablval(tp, uflag) register TREE *tp; int uflag;
222: {
223: switch (tp->t_op) {
224: case ICON:
225: return (uflag) ? (ulval_t)(uival_t)tp->t_ival : tp->t_ival;
226: case ZCON:
227: return (ulval_t)tp->t_zval;
228: case LCON:
229: return tp->t_lval;
230: #if FOLD_DOUBLES
231: case DCON:
232: return dval_to_d(tp);
233: #endif
234: }
235: cbotch("grablval");
236: }
237:
238: #if FOLD_DOUBLES
239:
240: /*
241: * Fold double constants.
242: */
243: TREE *
244: foldd(op, lp, rp) int op; TREE *lp, *rp;
245: {
246: register TREE *tp;
247: int bool;
248: double lv, rv;
249:
250: lv = grabdval(lp);
251: if (rp != NULL)
252: rv = grabdval(rp);
253:
254:
255: /* Perform the folding, leaving result in lv or in bool (0 or 1). */
256: bool = -1;
257: switch(op) {
258:
259: case NEG: lv = -lv; break;
260: case ADD: lv += rv; break;
261: case SUB: lv -= rv; break;
262: case MUL: lv *= rv; break;
263: case DIV: lv /= rv; break;
264:
265: /* Relations and conditionals return T_INT result in bool. */
266: case NOT: bool = !lv; break;
267: case EQ: bool = lv == rv; break;
268: case NE: bool = lv != rv; break;
269: case LT: bool = lv < rv; break;
270: case LE: bool = lv <= rv; break;
271: case GT: bool = lv > rv; break;
272: case GE: bool = lv >= rv; break;
273: case ANDAND: bool = (lv && rv); break;
274: case OROR: bool = (lv || rv); break;
275:
276: default: /* shouldn't happen if opdope is right */
277: return NULL;
278: }
279:
280: /* Allocate a TREE for the result and store the result. */
281: tp = talloc();
282: if (bool != -1) { /* boolean result */
283: tp->t_op = ICON;
284: tp->t_type = T_INT;
285: tp->t_ival = bool;
286: } else { /* double result */
287: tp->t_op = DCON;
288: tp->t_type = T_DOUBLE;
289: d_to_dval(tp, lv);
290: }
291: return tp;
292: }
293:
294: /*
295: * Grab the value of a constant as a double.
296: */
297: double
298: grabdval(tp) register TREE *tp;
299: {
300: register int t;
301:
302: switch (tp->t_op) {
303: case ICON:
304: return ((t = tp->t_type) == T_UINT || t == T_ULONG)
305: ? (uival_t)tp->t_ival : tp->t_ival;
306: case ZCON:
307: return (uival_t)tp->t_zval;
308: case LCON:
309: return ((t = tp->t_type) == T_UINT || t == T_ULONG)
310: ? (ulval_t)tp->t_lval : tp->t_lval;
311: case DCON:
312: return dval_to_d(tp);
313: }
314: cbotch("grabdval");
315: }
316:
317: #endif
318:
319: /* end of n0/fold.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.