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