![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtree0.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 mtree0.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 |
1.1 root 1: /*
2: * Modify an expression.
3: * All machines.
4: *
5: * modify() calls modtree() which generally does left before right
6: * deepest first traversal, including constant folding and machine
7: * dependent modifications. modify() then walk()'s the tree with
8: * modswap() and modrneg() and finally calls modleaf() to insert
9: * leaf nodes where required.
10: *
11: * mflag -
12: * 0 < mflag - prints trees before and after modification
13: * unless in MINIT context, where you get after only.
14: * 1 < mflag - prints trees at end of modtree()
15: * 2 < mflag - prints trees at beginning of modtree()
16: * 8 < mflag - gets multiple intermediate trees.
17: */
18: #ifdef vax
19: #include "INC$LIB:cc1.h"
20: #else
21: #include "cc1.h"
22: #endif
23:
24: int modswap();
25: int modrneg();
26:
27: /*
28: * Tree modify.
29: */
30: TREE *
31: modify(tp, c)
32: register TREE *tp;
33: {
34: #if !TINY
35: if (mflag > 0 && c != MINIT)
36: snapf("%W%E", "Before modify", tp);
37: #endif
38: tp = modtree(tp, c, NULL);
39: walk(tp, modswap);
40: walk(tp, modrneg);
41: #if !TINY
42: if (mflag > 8 && c != MINIT)
43: snapf("%W%E", "Before modleaf", tp);
44: #endif
45: tp = modleaf(tp, c, NULL);
46: #if !TINY
47: if (mflag > 0)
48: snapf("%W%E%W", "After modify", tp, NULL);
49: #endif
50: return (tp);
51: }
52:
53: /*
54: * Tree modifier.
55: * This routine performs a number of machine independent things.
56: * Folding of constant expressions is done by the routine 'modfold()'.
57: * After all the machine independent things have been done,
58: * a call to 'modoper()' does machine-specific modifications.
59: */
60: TREE *
61: modtree(tp, ac, ptp)
62: register TREE *tp;
63: TREE *ptp;
64: {
65: register TREE *lp;
66: register TREE *rp;
67: register TREE *tp1;
68: register int c;
69: register int left;
70: register int n;
71: register int op;
72: register int tt, ts;
73:
74: c = ac;
75: if (c==MINIT || c==MRETURN || c==MSWITCH)
76: c = MRVALUE;
77: #if !TINY
78: if (mflag > 2 && ac != MINIT)
79: snapf("%W%E", "modtree before modfold", tp);
80: #endif
81: again:
82: tp = modfold(tp);
83: #if !TINY
84: if (mflag > 8 && ac != MINIT)
85: snapf("%W%E", "modtree after modfold", tp);
86: #endif
87: op = tp->t_op;
88: if (isleaf(op))
89: goto done;
90: lp = tp->t_lp;
91: rp = NULL;
92: if (op != FIELD)
93: rp = tp->t_rp;
94: tt = tp->t_type;
95: ts = tp->t_size;
96: /*
97: * Change '(reg = a) + b' into 'reg = a, reg + b'.
98: */
99: if (isokasgn(op, lp)) {
100: lp = leftnode(COMMA, lp, lp->t_type, lp->t_size);
101: lp->t_rp = tp;
102: tp->t_lp = copynode(lp->t_lp->t_lp);
103: tp = lp;
104: goto again;
105: }
106: /*
107: * Now change 'b + (reg = a)' into 'reg = a, b + reg'.
108: */
109: if (isokasgn(op, rp)) {
110: rp = leftnode(COMMA, rp, rp->t_type, rp->t_size);
111: rp->t_rp = tp;
112: tp->t_rp = copynode(rp->t_lp->t_lp);
113: tp = rp;
114: goto again;
115: }
116: switch (op) {
117:
118: case BLKMOVE:
119: tp->t_lp = modtree(lp, MRVALUE, tp);
120: tp->t_rp = modtree(rp, MRVALUE, tp);
121: break;
122:
123: case CALL:
124: tp = modcall(tp, c);
125: break;
126:
127: case FIELD:
128: tp->t_lp = modtree(lp, c, tp);
129: break;
130:
131: case QUEST:
132: tp->t_lp = modtree(lp, MFLOW, tp);
133: if (rp->t_op != COLON)
134: cbotch("no ':'");
135: rp->t_lp = modtree(rp->t_lp, c, rp);
136: rp->t_rp = modtree(rp->t_rp, c, rp);
137: break;
138:
139: case COLON:
140: cbotch("misplaced ':'");
141: tp->t_op = COMMA;
142:
143: case COMMA:
144: if (isfxcon(lp) || lp->t_op == DCON) {
145: tp = rp;
146: goto again;
147: }
148: tp->t_lp = modtree(lp, MEFFECT, tp);
149: tp->t_rp = modtree(rp, c, tp);
150: break;
151:
152: case NOT:
153: if (c != MFLOW) {
154: tp = modtruth(tp);
155: goto again;
156: }
157: lp = modtree(lp, MFLOW, tp);
158: goto unary;
159:
160: case COM:
161: case NEG:
162: lp = modtree(lp, (ac==MINIT?MINIT:MRVALUE), tp);
163: unary:
164: if (lp->t_op == op) {
165: lp = lp->t_lp;
166: lp->t_type = tt;
167: lp->t_size = ts;
168: tp = lp;
169: goto again;
170: }
171: tp->t_lp = lp;
172: break;
173:
174: case CONVERT:
175: case CAST:
176: /* Distribute conversion to last comma node. */
177: if (lp->t_op==COMMA) {
178: rp = lp;
179: rp->t_type = tt;
180: while (rp->t_rp->t_op==COMMA) {
181: rp->t_type = tt;
182: rp = rp->t_rp;
183: }
184: tp->t_lp = rp->t_rp;
185: rp->t_rp = tp;
186: tp = lp;
187: goto again;
188: }
189: /* Distribute conversion to subtrees of COLON. */
190: if (lp->t_op==QUEST) {
191: rp = lp;
192: rp->t_type = tt;
193: rp = rp->t_rp;
194: rp->t_type = tt;
195: tp->t_lp = rp->t_lp;
196: rp->t_lp = tp;
197: rp->t_rp = leftnode(tp->t_op, rp->t_rp, tt);
198: tp = lp;
199: goto again;
200: }
201: lp = modtree(lp, MRVALUE, tp);
202: if (tt==lp->t_type && ts==lp->t_size) {
203: tp = lp;
204: goto again;
205: }
206: tp->t_lp = lp;
207: break;
208:
209: case OROR:
210: case ANDAND:
211: if (c != MFLOW) {
212: tp = modtruth(tp);
213: goto again;
214: }
215: tp->t_lp = modtree(lp, MFLOW, tp);
216: tp->t_rp = modtree(rp, MFLOW, tp);
217: break;
218:
219: case INCAFT:
220: case DECAFT:
221: if (c == MEFFECT)
222: tp->t_op += INCBEF-INCAFT;
223:
224: case INCBEF:
225: case DECBEF:
226: tp->t_lp = modtree(lp, MLADDR, tp);
227: if (isflt(tt)) {
228: tp->t_op = (op==INCBEF || op==INCAFT) ? AADD : ASUB;
229: if (op==INCAFT || op==DECAFT) {
230: tp->t_lp = copynode(tp);
231: tp->t_rp = leftnode(CONVERT, ivalnode(1), F64);
232: tp->t_op = (op==INCAFT)?SUB:ADD;
233: }
234: goto again;
235: }
236: tp->t_rp = modtree(basenode(rp), MRADDR, tp);
237: break;
238:
239: case ADDR:
240: lp = modtree(lp, (ac==MINIT?MINIT:MLADDR), tp);
241: if (lp->t_op == STAR) {
242: lp = lp->t_lp;
243: if ( ! isblkp(lp->t_type)) {
244: lp->t_type = tt;
245: lp->t_size = ts;
246: }
247: tp = lp;
248: goto again;
249: } else if (lp->t_op == QUEST) {
250: /* Change '&(a?b:c)' to 'a?&b:&c'. */
251: rp = lp->t_rp; /* COLON node */
252: rp->t_lp = leftnode(ADDR, rp->t_lp, tt, ts);
253: rp->t_rp = leftnode(ADDR, rp->t_rp, tt, ts);
254: rp->t_type = lp->t_type = tt;
255: rp->t_size = lp->t_size = ts;
256: tp = lp;
257: goto again;
258: }
259: tp->t_lp = lp;
260: break;
261:
262: case STAR:
263: lp = modtree(lp, (ac==MINIT?MINIT:MRADDR), tp);
264: if (lp->t_op == ADDR) {
265: lp = lp->t_lp;
266: if ( ! isblkp(lp->t_type)) {
267: lp->t_type = tt;
268: lp->t_size = ts;
269: }
270: tp = lp;
271: goto again;
272: }
273: tp->t_lp = lp;
274: break;
275:
276: case ASSIGN:
277: tp->t_lp = modtree(lp, MLADDR, tp);
278: tp->t_rp = modtree(rp, MRVALUE, tp);
279: break;
280:
281: case DIV:
282: case REM:
283: case ADIV:
284: case AREM:
285: lp = modtree(lp, lgoal(op), tp);
286: rp = modtree(rp, MRADDR, tp);
287: if (((n = ispow2(rp)) >= 0) && ((n==0) || isuns(tt))) {
288: if (op==DIV || op==ADIV) {
289: tp->t_op += SHR-DIV;
290: tp->t_lp = lp;
291: tp->t_rp = ivalnode(n);
292: goto again;
293: }
294: else {
295: tp->t_op += AND-REM;
296: tp->t_lp = lp;
297: tp->t_rp = gvalnode(tt, ((long)01<<n)-1);
298: goto again;
299: }
300: }
301: tp->t_lp = lp;
302: tp->t_rp = rp;
303: break;
304:
305: case MUL:
306: case AMUL:
307: lp = modtree(lp, lgoal(op), tp);
308: rp = modtree(rp, MRADDR, tp);
309: if ((tp1=modmul(tp, lp, rp)) != NULL
310: || (op==MUL && (tp1=modmul(tp, rp, lp))!=NULL)) {
311: tp = tp1;
312: goto again;
313: }
314: tp->t_lp = lp;
315: tp->t_rp = rp;
316: break;
317:
318: case ADD:
319: case SUB:
320: case AND:
321: case OR:
322: case XOR:
323: case SHR:
324: case SHL:
325: lp = modtree(lp, (ac==MINIT?MINIT:MRVALUE), tp);
326: rp = modtree(rp, (ac==MINIT?MINIT:MRADDR), tp);
327: if (isnval(rp, 0)) {
328: if (op == AND) {
329: rp->t_type = tt;
330: rp->t_size = ts;
331: tp = rp;
332: goto again;
333: }
334: lp->t_type = tt;
335: lp->t_size = ts;
336: tp = lp;
337: goto again;
338: }
339: if (op == SUB
340: && rp->t_op == ICON
341: && (isuns(rp->t_type)==0 || rp->t_ival>=0)) {
342: tp->t_op += ADD-SUB;
343: tp->t_type = IVAL_T; /* Signed */
344: rp->t_ival = -rp->t_ival;
345: amd(rp);
346: tp->t_lp = lp;
347: tp->t_rp = rp;
348: goto again;
349: }
350: tp->t_lp = lp;
351: tp->t_rp = rp;
352: break;
353:
354: case AADD:
355: case ASUB:
356: case AAND:
357: case AOR:
358: case AXOR:
359: case ASHL:
360: case ASHR:
361: lp = modtree(lp, MLADDR, tp);
362: rp = modtree(rp, MRADDR, tp);
363: if (isnval(rp, 0)) {
364: if (op == AAND) {
365: tp->t_op = ASSIGN;
366: tp->t_lp = lp;
367: tp->t_rp = rp;
368: goto again;
369: }
370: lp->t_type = tt;
371: lp->t_size = ts;
372: tp = lp;
373: goto again;
374: }
375: tp->t_lp = lp;
376: tp->t_rp = rp;
377: break;
378:
379: case EQ:
380: case NE:
381: case GT:
382: case LT:
383: case GE:
384: case LE:
385: case UGT:
386: case UGE:
387: case ULT:
388: case ULE:
389: if (c != MFLOW) {
390: tp = modtruth(tp);
391: goto again;
392: }
393: lp = modfold(lp);
394: rp = modfold(rp);
395: if ((left=isnval(lp, 0)) || isnval(rp, 0)) {
396: if (left) {
397: tp->t_op = op = fliprel[op-EQ];
398: tp1 = lp;
399: lp = rp;
400: rp = tp1;
401: }
402: if ((op==EQ || op==NE) && lp->t_op != QUEST)
403: lp = modtree(lp, MFLOW, tp);
404: else
405: lp = modtree(lp, MRVALUE, tp);
406: } else
407: lp = modtree(lp, MRVALUE, tp);
408: tp->t_lp = lp;
409: tp->t_rp = modtree(rp, MRADDR, tp);
410: break;
411: }
412: tp = modfold(tp);
413: done:
414: walk(tp, amd);
415: if ((tp1 = modoper(tp, ac, ptp)) != NULL) {
416: tp = tp1;
417: goto again;
418: }
419: #if !TINY
420: if (mflag > 1 && ac != MINIT)
421: snapf("%W%E", "modtree done", tp);
422: #endif
423: return (tp);
424: }
425:
426: /*
427: * Modify multiply.
428: * Called from the modify case for MUL and AMUL.
429: * If MUL, called twice in both arrangements.
430: */
431: TREE *
432: modmul(tp, lp, rp)
433: register TREE *tp, *lp, *rp;
434: {
435: register n;
436:
437: if (isnval(rp, 0)) {
438: if (tp->t_op == AMUL) {
439: tp->t_op = ASSIGN;
440: return(tp);
441: }
442: rp->t_type = tp->t_type;
443: rp->t_size = tp->t_size;
444: return (rp);
445: }
446: if ((n=ispow2(rp)) >= 0) {
447: tp->t_op += SHL-MUL;
448: tp->t_lp = lp;
449: tp->t_rp = ivalnode(n);
450: return (tp);
451: }
452: return (NULL);
453: }
454:
455: /*
456: * This routine fabricates a fake question colon pair
457: * to get the correct return value for !, &&, || and relational ops
458: * in non flow contexts.
459: */
460: TREE *
461: modtruth(tp)
462: register TREE *tp;
463: {
464: register TREE *tp1;
465:
466: tp1 = ivalnode(1);
467: tp1 = leftnode(COLON, tp1, TRUTH);
468: tp1->t_rp = ivalnode(0);
469: tp = leftnode(QUEST, tp, TRUTH);
470: tp->t_rp = tp1;
471: return (tp);
472: }
473:
474: /*
475: * Find left subgoal.
476: * This permits '+' and '+=' to share a lot of code.
477: */
478: lgoal(op)
479: register op;
480: {
481: if (op>=AADD && op<=ASHR)
482: return (MLADDR);
483: return (MRVALUE);
484: }
485:
486: /*
487: * Look for '+' of a negative constant and make it into a subtract.
488: * Machines tend to have 'dec' instructions for small numbers.
489: */
490: modrneg(tp, ptp)
491: register TREE *tp;
492: TREE *ptp;
493: {
494: register TREE *rp;
495:
496: if (tp->t_op==ADD || tp->t_op==AADD) {
497: rp = tp->t_rp;
498: if (rp->t_op==ICON && !isuns(rp->t_type) && rp->t_ival<0) {
499: tp->t_op += SUB-ADD;
500: rp->t_ival = -rp->t_ival;
501: amd(rp);
502: }
503: }
504: }
505:
506: /*
507: * Check assignment transformation for legality.
508: */
509: isokasgn(op, tp)
510: register op;
511: register TREE *tp;
512: {
513: register top;
514:
515: if (op!=ASSIGN && (op<ADD || op>SHR))
516: return (0);
517: if (tp == NULL)
518: return (0);
519: top = tp->t_op;
520: if (top!=ASSIGN && (top<AADD || top>ASHR))
521: return (0);
522: return (isokareg(tp, op));
523: }
524:
525: /*
526: * If the tree is a constant power of two, return the log
527: * base two of the number.
528: * If not, return -1.
529: */
530: ispow2(tp)
531: register TREE *tp;
532: {
533: register i;
534: register long n;
535:
536: if (!isfxcon(tp))
537: return (-1);
538: n = grabnval(tp);
539: if (n<1 || (n&(n-1))!=0)
540: return (-1);
541: i = 0;
542: while ((n&01) == 0) {
543: ++i;
544: n >>= 1;
545: }
546: return (i);
547: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.