![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c12.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c|
Return to c12.c CVS log | Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c |
1.1 root 1: /*
2: * C compiler part 2 -- expression optimizer
3: */
4:
5: #include "c1.h"
6:
7: union tree *
8: optim(tree)
9: register union tree *tree;
10: {
11: register op, dope;
12: int d1, d2;
13: union tree *t;
14: union { double dv; int iv[4];} fp11;
15:
16: if (tree==NULL)
17: return(NULL);
18: if ((op = tree->t.op)==0)
19: return(tree);
20: if (op==NAME && tree->n.class==AUTO) {
21: tree->n.class = OFFS;
22: tree->n.regno = 5;
23: tree->n.offset = tree->n.nloc;
24: }
25: dope = opdope[op];
26: if ((dope&LEAF) != 0) {
27: if (op==FCON) {
28: fp11.dv = tree->f.fvalue;
29: if (fp11.iv[1]==0
30: && fp11.iv[2]==0
31: && fp11.iv[3]==0) {
32: tree->t.op = SFCON;
33: tree->f.value = fp11.iv[0];
34: }
35: }
36: return(tree);
37: }
38: if ((dope&BINARY) == 0)
39: return(unoptim(tree));
40: /* is known to be binary */
41: if (tree->t.type==CHAR)
42: tree->t.type = INT;
43: switch(op) {
44: /*
45: * PDP-11 special:
46: * generate new &=~ operator out of &=
47: * by complementing the RHS.
48: */
49: case ASAND:
50: tree->t.op = ASANDN;
51: tree->t.tr2 = tnode(COMPL, tree->t.tr2->t.type, tree->t.tr2, TNULL);
52: break;
53:
54: /*
55: * On the PDP-11, int->ptr via multiplication
56: * Longs are just truncated.
57: */
58: case LTOP:
59: tree->t.op = ITOP;
60: tree->t.tr1 = unoptim(tnode(LTOI,INT,tree->t.tr1, TNULL));
61: case ITOP:
62: tree->t.op = TIMES;
63: break;
64:
65: case MINUS:
66: if ((t = isconstant(tree->t.tr2)) && (!uns(t) || tree->t.type!=LONG)
67: && (t->t.type!=INT || t->c.value!=0100000)) {
68: tree->t.op = PLUS;
69: if (t->t.type==DOUBLE)
70: /* PDP-11 FP representation */
71: t->c.value ^= 0100000;
72: else
73: t->c.value = -t->c.value;
74: }
75: break;
76: }
77: op = tree->t.op;
78: dope = opdope[op];
79: if (dope&LVALUE && tree->t.tr1->t.op==FSEL)
80: return(lvfield(tree));
81: if ((dope&COMMUTE)!=0) {
82: d1 = tree->t.type;
83: tree = acommute(tree);
84: if (tree->t.op == op)
85: tree->t.type = d1;
86: /*
87: * PDP-11 special:
88: * replace a&b by a ANDN ~ b.
89: * This will be undone when in
90: * truth-value context.
91: */
92: if (tree->t.op!=AND)
93: return(tree);
94: /*
95: * long & pos-int is simpler
96: */
97: if (tree->t.type==LONG && tree->t.tr2->t.op==ITOL
98: && (tree->t.tr2->t.tr1->t.op==CON && tree->t.tr2->t.tr1->c.value>=0
99: || uns(tree->t.tr2->t.tr1))) {
100: tree->t.type = UNSIGN;
101: t = tree->t.tr2;
102: tree->t.tr2 = tree->t.tr2->t.tr1;
103: t->t.tr1 = tree;
104: tree->t.tr1 = tnode(LTOI, UNSIGN, tree->t.tr1, TNULL);
105: return(optim(t));
106: }
107: /*
108: * Keep constants to the right
109: */
110: if ((tree->t.tr1->t.op==ITOL && tree->t.tr1->t.tr1->t.op==CON)
111: || tree->t.tr1->t.op==LCON) {
112: t = tree->t.tr1;
113: tree->t.tr1 = tree->t.tr2;
114: tree->t.tr2 = t;
115: }
116: tree->t.op = ANDN;
117: op = ANDN;
118: tree->t.tr2 = tnode(COMPL, tree->t.tr2->t.type, tree->t.tr2, TNULL);
119: }
120: again:
121: tree->t.tr1 = optim(tree->t.tr1);
122: tree->t.tr2 = optim(tree->t.tr2);
123: if (tree->t.type == LONG) {
124: t = lconst(tree->t.op, tree->t.tr1, tree->t.tr2);
125: if (t)
126: return(t);
127: }
128: if ((dope&RELAT) != 0) {
129: if ((d1=degree(tree->t.tr1)) < (d2=degree(tree->t.tr2))
130: || d1==d2 && tree->t.tr1->t.op==NAME && tree->t.tr2->t.op!=NAME) {
131: t = tree->t.tr1;
132: tree->t.tr1 = tree->t.tr2;
133: tree->t.tr2 = t;
134: tree->t.op = maprel[op-EQUAL];
135: }
136: if (tree->t.tr1->t.type==CHAR && tree->t.tr2->t.op==CON
137: && (dcalc(tree->t.tr1, 0) <= 12 || tree->t.tr1->t.op==STAR)
138: && tree->t.tr2->c.value <= 127 && tree->t.tr2->c.value >= 0)
139: tree->t.tr2->t.type = CHAR;
140: }
141: d1 = max(degree(tree->t.tr1), islong(tree->t.type));
142: d2 = max(degree(tree->t.tr2), 0);
143: switch (op) {
144:
145: /*
146: * In assignment to fields, treat all-zero and all-1 specially.
147: */
148: case FSELA:
149: if (tree->t.tr2->t.op==CON && tree->t.tr2->c.value==0) {
150: tree->t.op = ASAND;
151: tree->t.tr2->c.value = ~tree->F.mask;
152: return(optim(tree));
153: }
154: if (tree->t.tr2->t.op==CON && tree->F.mask==tree->t.tr2->c.value) {
155: tree->t.op = ASOR;
156: return(optim(tree));
157: }
158:
159: case LTIMES:
160: case LDIV:
161: case LMOD:
162: case LASTIMES:
163: case LASDIV:
164: case LASMOD:
165: case UDIV:
166: case UMOD:
167: case ASUDIV:
168: case ASUMOD:
169: tree->t.degree = 10;
170: break;
171:
172: case ANDN:
173: if (isconstant(tree->t.tr2) && tree->t.tr2->c.value==0) {
174: return(tree->t.tr1);
175: }
176: goto def;
177:
178: case CALL:
179: tree->t.degree = 10;
180: break;
181:
182: case QUEST:
183: case COLON:
184: tree->t.degree = max(d1, d2);
185: break;
186:
187: case PTOI:
188: case DIVIDE:
189: case ASDIV:
190: case ASTIMES:
191: if (tree->t.tr2->t.op==CON && tree->t.tr2->c.value==1) {
192: if (op==PTOI)
193: return(optim(tnode(LTOI,INT,paint(tree->t.tr1,LONG), TNULL)));
194: return(paint(tree->t.tr1, tree->t.type));
195: }
196: case MOD:
197: case ASMOD:
198: if ((uns(tree->t.tr1) || tree->t.op==PTOI) && ispow2(tree))
199: return(pow2(tree));
200: if ((op==MOD||op==ASMOD) && tree->t.type==DOUBLE) {
201: error("Floating %% not defined");
202: tree->t.type = INT;
203: }
204: case ULSH:
205: case ASULSH:
206: d1 += 2 + regpanic;
207: d2 += 2 + regpanic;
208: panicposs++;
209: if (tree->t.type==LONG)
210: return(hardlongs(tree));
211: if ((op==MOD || op==DIVIDE || op==ASMOD || op==ASDIV)
212: && (uns(tree->t.tr1) || uns(tree->t.tr2))
213: && (tree->t.tr2->t.op!=CON || tree->t.tr2->c.value<=1)) {
214: if (op>=ASDIV) {
215: tree->t.op += ASUDIV - ASDIV;
216: } else
217: tree->t.op += UDIV - DIVIDE;
218: d1 = d2 = 10;
219: }
220: goto constant;
221:
222: case ASPLUS:
223: case ASMINUS:
224: if (tree->t.tr2->t.op==CON && tree->t.tr2->c.value==0)
225: return(tree->t.tr1);
226: goto def;
227:
228: case LSHIFT:
229: case RSHIFT:
230: case ASRSH:
231: case ASLSH:
232: if (tree->t.tr2->t.op==CON && tree->t.tr2->c.value==0)
233: return(paint(tree->t.tr1, tree->t.type));
234: /*
235: * PDP-11 special: turn right shifts into negative
236: * left shifts
237: */
238: if (tree->t.type == LONG) {
239: d1++;
240: d2++;
241: }
242: if (op==LSHIFT||op==ASLSH)
243: goto constant;
244: if (tree->t.tr2->t.op==CON && tree->t.tr2->c.value==1
245: && !uns(tree->t.tr1) && !uns(tree->t.tr2))
246: goto constant;
247: op += (LSHIFT-RSHIFT);
248: tree->t.op = op;
249: tree->t.tr2 = tnode(NEG, tree->t.tr2->t.type, tree->t.tr2, TNULL);
250: if (uns(tree->t.tr1) || uns(tree->t.tr2)) {
251: if (tree->t.op==LSHIFT)
252: tree->t.op = ULSH;
253: else if (tree->t.op==ASLSH)
254: tree->t.op = ASULSH;
255: }
256: goto again;
257:
258: constant:
259: if (tree->t.tr1->t.op==CON && tree->t.tr2->t.op==CON) {
260: const(op, &tree->t.tr1->c.value, tree->t.tr2->c.value, tree->t.type);
261: return(tree->t.tr1);
262: }
263:
264:
265: def:
266: default:
267: if (dope&RELAT) {
268: if (tree->t.tr1->t.type==LONG) /* long relations are a mess */
269: d1 = 10;
270: if (opdope[tree->t.tr1->t.op]&RELAT && tree->t.tr2->t.op==CON
271: && tree->t.tr2->c.value==0) {
272: tree = tree->t.tr1;
273: switch(op) {
274: case GREATEQ:
275: return((union tree *)&cone);
276: case LESS:
277: return((union tree *)&czero);
278: case LESSEQ:
279: case EQUAL:
280: tree->t.op = notrel[tree->t.op-EQUAL];
281: }
282: return(tree);
283: }
284: }
285: tree->t.degree = d1==d2? d1+islong(tree->t.type): max(d1, d2);
286: break;
287: }
288: return(tree);
289: }
290:
291: union tree *
292: unoptim(tree)
293: register union tree *tree;
294: {
295: register union tree *subtre, *p;
296:
297: if (tree==NULL)
298: return(NULL);
299: again:
300: if (tree->t.op==AMPER && tree->t.tr1->t.op==STAR) {
301: subtre = tree->t.tr1->t.tr1;
302: subtre->t.type = tree->t.type;
303: return(optim(subtre));
304: }
305: subtre = tree->t.tr1 = optim(tree->t.tr1);
306: switch (tree->t.op) {
307:
308: case INCAFT:
309: case DECAFT:
310: if (tree->t.type!=subtre->t.type)
311: paint(subtre, tree->t.type);
312: break;
313:
314: case ITOL:
315: if (subtre->t.op==CON && subtre->t.type==INT && subtre->c.value<0) {
316: subtre = getblk(sizeof(struct lconst));
317: subtre->t.op = LCON;
318: subtre->t.type = LONG;
319: subtre->l.lvalue = tree->t.tr1->c.value;
320: return(subtre);
321: }
322: break;
323:
324: case FTOI:
325: if (uns(tree)) {
326: tree->t.op = FTOL;
327: tree->t.type = LONG;
328: tree = tnode(LTOI, UNSIGN, tree, TNULL);
329: }
330: break;
331:
332: case LTOF:
333: if (subtre->t.op==LCON) {
334: tree = getblk(sizeof(struct ftconst));
335: tree->t.op = FCON;
336: tree->t.type = DOUBLE;
337: tree->c.value = isn++;
338: tree->f.fvalue = subtre->l.lvalue;
339: return(optim(tree));
340: }
341: break;
342:
343: case ITOF:
344: if (subtre->t.op==CON) {
345: tree = getblk(sizeof(struct ftconst));
346: tree->t.op = FCON;
347: tree->t.type = DOUBLE;
348: tree->f.value = isn++;
349: if (uns(subtre))
350: tree->f.fvalue = (unsigned)subtre->c.value;
351: else
352: tree->f.fvalue = subtre->c.value;
353: return(optim(tree));
354: }
355: if (uns(subtre)) {
356: tree->t.tr1 = tnode(ITOL, LONG, subtre, TNULL);
357: tree->t.op = LTOF;
358: return(optim(tree));
359: }
360: break;
361:
362: case ITOC:
363: /*
364: * Sign-extend PDP-11 characters
365: */
366: if (subtre->t.op==CON) {
367: char c;
368: c = subtre->c.value;
369: subtre->c.value = c;
370: subtre->t.type = tree->t.type;
371: return(subtre);
372: } else if (subtre->t.op==NAME && tree->t.type==INT) {
373: subtre->t.type = CHAR;
374: return(subtre);
375: }
376: break;
377:
378: case LTOI:
379: switch (subtre->t.op) {
380:
381: case LCON:
382: subtre->t.op = CON;
383: subtre->t.type = tree->t.type;
384: subtre->c.value = subtre->l.lvalue;
385: return(subtre);
386:
387: case NAME:
388: subtre->n.offset += 2;
389: subtre->t.type = tree->t.type;
390: return(subtre);
391:
392: case STAR:
393: subtre->t.type = tree->t.type;
394: subtre->t.tr1->t.type = tree->t.type+PTR;
395: subtre->t.tr1 = tnode(PLUS, tree->t.type, subtre->t.tr1, tconst(2, INT));
396: return(optim(subtre));
397:
398: case ITOL:
399: return(paint(subtre->t.tr1, tree->t.type));
400:
401: case PLUS:
402: case MINUS:
403: case AND:
404: case ANDN:
405: case OR:
406: case EXOR:
407: subtre->t.tr2 = tnode(LTOI, tree->t.type, subtre->t.tr2, TNULL);
408: case NEG:
409: case COMPL:
410: subtre->t.tr1 = tnode(LTOI, tree->t.type, subtre->t.tr1, TNULL);
411: subtre->t.type = tree->t.type;
412: return(optim(subtre));
413: }
414: break;
415:
416: case FSEL:
417: tree->t.op = AND;
418: tree->t.tr1 = tree->t.tr2->t.tr1;
419: tree->t.tr2->t.tr1 = subtre;
420: tree->t.tr2->t.op = RSHIFT;
421: tree->t.tr1->c.value = (1 << tree->t.tr1->c.value) - 1;
422: return(optim(tree));
423:
424: case FSELR:
425: tree->t.op = LSHIFT;
426: tree->t.type = UNSIGN;
427: tree->t.tr1 = tree->t.tr2;
428: tree->t.tr1->t.op = AND;
429: tree->t.tr2 = tree->t.tr2->t.tr2;
430: tree->t.tr1->t.tr2 = subtre;
431: tree->t.tr1->t.tr1->c.value = (1 << tree->t.tr1->t.tr1->c.value) -1;
432: return(optim(tree));
433:
434: case AMPER:
435: if (subtre->t.op==STAR)
436: return(subtre->t.tr1);
437: if (subtre->t.op==NAME && subtre->n.class == OFFS) {
438: p = tnode(PLUS, tree->t.type, subtre, tree);
439: subtre->t.type = tree->t.type;
440: tree->t.op = CON;
441: tree->t.type = INT;
442: tree->t.degree = 0;
443: tree->c.value = subtre->n.offset;
444: subtre->n.class = REG;
445: subtre->n.nloc = subtre->n.regno;
446: subtre->n.offset = 0;
447: return(optim(p));
448: }
449: if (subtre->t.op==LOAD) {
450: tree->t.tr1 = subtre->t.tr1;
451: goto again;
452: }
453: break;
454:
455: case STAR:
456: if (subtre->t.op==AMPER) {
457: subtre->t.tr1->t.type = tree->t.type;
458: return(subtre->t.tr1);
459: }
460: if (tree->t.type==STRUCT)
461: break;
462: if (subtre->t.op==NAME && subtre->n.class==REG) {
463: subtre->t.type = tree->t.type;
464: subtre->n.class = OFFS;
465: subtre->n.regno = subtre->n.nloc;
466: return(subtre);
467: }
468: p = subtre->t.tr1;
469: if ((subtre->t.op==INCAFT||subtre->t.op==DECBEF)&&tree->t.type!=LONG
470: && p->t.op==NAME && p->n.class==REG && p->t.type==subtre->t.type) {
471: p->t.type = tree->t.type;
472: p->t.op = subtre->t.op==INCAFT? AUTOI: AUTOD;
473: return(p);
474: }
475: if (subtre->t.op==PLUS && p->t.op==NAME && p->n.class==REG) {
476: if (subtre->t.tr2->t.op==CON) {
477: p->n.offset += subtre->t.tr2->c.value;
478: p->n.class = OFFS;
479: p->t.type = tree->t.type;
480: p->n.regno = p->n.nloc;
481: return(p);
482: }
483: if (subtre->t.tr2->t.op==AMPER) {
484: subtre = subtre->t.tr2->t.tr1;
485: subtre->n.class += XOFFS-EXTERN;
486: subtre->n.regno = p->n.nloc;
487: subtre->t.type = tree->t.type;
488: return(subtre);
489: }
490: }
491: break;
492: case EXCLA:
493: if ((opdope[subtre->t.op]&RELAT)==0)
494: break;
495: tree = subtre;
496: tree->t.op = notrel[tree->t.op-EQUAL];
497: break;
498:
499: case COMPL:
500: if (tree->t.type==CHAR)
501: tree->t.type = INT;
502: if (tree->t.op == subtre->t.op)
503: return(paint(subtre->t.tr1, tree->t.type));
504: if (subtre->t.op==CON) {
505: subtre->c.value = ~subtre->c.value;
506: return(paint(subtre, tree->t.type));
507: }
508: if (subtre->t.op==LCON) {
509: subtre->l.lvalue = ~subtre->l.lvalue;
510: return(subtre);
511: }
512: if (subtre->t.op==ITOL) {
513: if (subtre->t.tr1->t.op==CON) {
514: tree = getblk(sizeof(struct lconst));
515: tree->t.op = LCON;
516: tree->t.type = LONG;
517: if (uns(subtre->t.tr1))
518: tree->l.lvalue = ~(long)(unsigned)subtre->t.tr1->c.value;
519: else
520: tree->l.lvalue = ~subtre->t.tr1->c.value;
521: return(tree);
522: }
523: if (uns(subtre->t.tr1))
524: break;
525: subtre->t.op = tree->t.op;
526: subtre->t.type = subtre->t.tr1->t.type;
527: tree->t.op = ITOL;
528: tree->t.type = LONG;
529: goto again;
530: }
531:
532: case NEG:
533: if (tree->t.type==CHAR)
534: tree->t.type = INT;
535: if (tree->t.op==subtre->t.op)
536: return(paint(subtre->t.tr1, tree->t.type));
537: if (subtre->t.op==CON) {
538: subtre->c.value = -subtre->c.value;
539: return(paint(subtre, tree->t.type));
540: }
541: if (subtre->t.op==LCON) {
542: subtre->l.lvalue = -subtre->l.lvalue;
543: return(subtre);
544: }
545: if (subtre->t.op==ITOL && subtre->t.tr1->t.op==CON) {
546: tree = getblk(sizeof(struct lconst));
547: tree->t.op = LCON;
548: tree->t.type = LONG;
549: if (uns(subtre->t.tr1))
550: tree->l.lvalue = -(long)(unsigned)subtre->t.tr1->c.value;
551: else
552: tree->l.lvalue = -subtre->t.tr1->c.value;
553: return(tree);
554: }
555: /*
556: * PDP-11 FP negation
557: */
558: if (subtre->t.op==SFCON) {
559: subtre->c.value ^= 0100000;
560: subtre->f.fvalue = -subtre->f.fvalue;
561: return(subtre);
562: }
563: if (subtre->t.op==FCON) {
564: subtre->f.fvalue = -subtre->f.fvalue;
565: return(subtre);
566: }
567: }
568: if ((opdope[tree->t.op]&LEAF)==0)
569: tree->t.degree = max(islong(tree->t.type), degree(subtre));
570: return(tree);
571: }
572:
573: /*
574: * Deal with assignments to partial-word fields.
575: * The game is that select(x) += y turns into
576: * select(x += select(y)) where the shifts and masks
577: * are chosen properly. The outer select
578: * is discarded where the value doesn't matter.
579: * Sadly, overflow is undetected on += and the like.
580: * Pure assignment is handled specially.
581: */
582:
583: union tree *
584: lvfield(t)
585: register union tree *t;
586: {
587: register union tree *t1, *t2;
588:
589: switch (t->t.op) {
590:
591: case ASSIGN:
592: t2 = getblk(sizeof(struct fasgn));
593: t2->t.op = FSELA;
594: t2->t.type = UNSIGN;
595: t1 = t->t.tr1->t.tr2;
596: t2->F.mask = ((1<<t1->t.tr1->c.value)-1)<<t1->t.tr2->c.value;
597: t2->t.tr1 = t->t.tr1;
598: t2->t.tr2 = t->t.tr2;
599: t = t2;
600:
601: case ASANDN:
602: case ASPLUS:
603: case ASMINUS:
604: case ASOR:
605: case ASXOR:
606: case INCBEF:
607: case INCAFT:
608: case DECBEF:
609: case DECAFT:
610: t1 = t->t.tr1;
611: t1->t.op = FSELR;
612: t->t.tr1 = t1->t.tr1;
613: t1->t.tr1 = t->t.tr2;
614: t->t.tr2 = t1;
615: t1 = t1->t.tr2;
616: t1 = tnode(COMMA, INT, tconst(t1->t.tr1->c.value, INT),
617: tconst(t1->t.tr2->c.value, INT));
618: return(optim(tnode(FSELT, UNSIGN, t, t1)));
619:
620: }
621: error("Unimplemented field operator");
622: return(t);
623: }
624:
625: #define LSTSIZ 20
626: struct acl {
627: int nextl;
628: int nextn;
629: union tree *nlist[LSTSIZ];
630: union tree *llist[LSTSIZ+1];
631: };
632:
633: union tree *
634: acommute(tree)
635: register union tree *tree;
636: {
637: struct acl acl;
638: int d, i, op, flt, d1, type;
639: register union tree *t1, **t2;
640: union tree *t;
641:
642: acl.nextl = 0;
643: acl.nextn = 0;
644: op = tree->t.op;
645: type = tree->t.type;
646: flt = isfloat(tree);
647: insert(op, tree, &acl);
648: acl.nextl--;
649: t2 = &acl.llist[acl.nextl];
650: if (!flt) {
651: /* put constants together */
652: for (i=acl.nextl; i>0; i--) {
653: d = t2[-1]->t.type==UNSIGN||t2[0]->t.type==UNSIGN?UNSIGN:INT;
654: if (t2[0]->t.op==CON && t2[-1]->t.op==CON) {
655: acl.nextl--;
656: t2--;
657: const(op, &t2[0]->c.value, t2[1]->c.value, d);
658: t2[0]->t.type = d;
659: } else if (t = lconst(op, t2[-1], t2[0])) {
660: acl.nextl--;
661: t2--;
662: t2[0] = t;
663: }
664: }
665: }
666: if (op==PLUS || op==OR) {
667: /* toss out "+0" */
668: if (acl.nextl>0 && ((t1 = isconstant(*t2)) && t1->c.value==0
669: || (*t2)->t.op==LCON && (*t2)->l.lvalue==0)) {
670: acl.nextl--;
671: t2--;
672: }
673: if (acl.nextl <= 0) {
674: if ((*t2)->t.type==CHAR || (*t2)->t.type==UNCHAR)
675: *t2 = tnode(LOAD, tree->t.type, *t2, TNULL);
676: (*t2)->t.type = tree->t.type;
677: return(*t2);
678: }
679: /* subsume constant in "&x+c" */
680: if (op==PLUS && t2[0]->t.op==CON && t2[-1]->t.op==AMPER) {
681: t2--;
682: t2[0]->t.tr1->n.offset += t2[1]->c.value;
683: acl.nextl--;
684: }
685: } else if (op==TIMES || op==AND) {
686: t1 = acl.llist[acl.nextl];
687: if (t1->t.op==CON) {
688: if (t1->c.value==0) {
689: for (i=0; i<acl.nextl; i++)
690: if (sideeffects(acl.llist[i]))
691: break;
692: if (i==acl.nextl)
693: return(t1);
694: }
695: if (op==TIMES && t1->c.value==1 && acl.nextl>0)
696: if (--acl.nextl <= 0) {
697: t1 = acl.llist[0];
698: if (uns(tree))
699: paint(t1, tree->t.type);
700: return(t1);
701: }
702: }
703: }
704: if (op==PLUS && !flt)
705: distrib(&acl);
706: tree = *(t2 = &acl.llist[0]);
707: d = max(degree(tree), islong(tree->t.type));
708: if (op==TIMES && !flt) {
709: d += regpanic+1;
710: panicposs++;
711: }
712: for (i=0; i<acl.nextl; i++) {
713: t1 = acl.nlist[i];
714: t1->t.tr2 = t = *++t2;
715: d1 = degree(t);
716: /*
717: * PDP-11 strangeness:
718: * rt. op of ^ must be in a register.
719: */
720: if (op==EXOR && dcalc(t, 0)<=12) {
721: t1->t.tr2 = t = optim(tnode(LOAD, t->t.type, t, TNULL));
722: d1 = t->t.degree;
723: }
724: t1->t.degree = d = d==d1? d+islong(t1->t.type): max(d, d1);
725: t1->t.tr1 = tree;
726: tree = t1;
727: if (tree->t.type==LONG) {
728: if (tree->t.op==TIMES)
729: tree = hardlongs(tree);
730: else if (tree->t.op==PLUS && (t = isconstant(tree->t.tr1))
731: && t->c.value < 0 && !uns(t)) {
732: tree->t.op = MINUS;
733: t->c.value = - t->c.value;
734: t = tree->t.tr1;
735: tree->t.tr1 = tree->t.tr2;
736: tree->t.tr2 = t;
737: }
738: }
739: }
740: if (tree->t.op==TIMES && ispow2(tree))
741: tree->t.degree = max(degree(tree->t.tr1), islong(tree->t.type));
742: paint(tree, type);
743: return(tree);
744: }
745:
746: sideeffects(tp)
747: register union tree *tp;
748: {
749: register dope;
750:
751: if (tp==NULL)
752: return(0);
753: dope = opdope[tp->t.op];
754: if (dope&LEAF) {
755: if (tp->t.op==AUTOI || tp->t.op==AUTOD)
756: return(1);
757: return(0);
758: }
759: if (dope&ASSGOP)
760: return(1);
761: switch(tp->t.op) {
762: case CALL:
763: case FSELA:
764: case STRASG:
765: return(1);
766: }
767: if (sideeffects(tp->t.tr1))
768: return(1);
769: if (dope&BINARY)
770: return(sideeffects(tp->t.tr2));
771: return(0);
772: }
773:
774: distrib(list)
775: struct acl *list;
776: {
777: /*
778: * Find a list member of the form c1c2*x such
779: * that c1c2 divides no other such constant, is divided by
780: * at least one other (say in the form c1*y), and which has
781: * fewest divisors. Reduce this pair to c1*(y+c2*x)
782: * and iterate until no reductions occur.
783: */
784: register union tree **p1, **p2;
785: union tree *t;
786: int ndmaj, ndmin;
787: union tree **dividend, **divisor;
788: union tree **maxnod, **mindiv;
789:
790: loop:
791: maxnod = &list->llist[list->nextl];
792: ndmaj = 1000;
793: dividend = 0;
794: for (p1 = list->llist; p1 <= maxnod; p1++) {
795: if ((*p1)->t.op!=TIMES || (*p1)->t.tr2->t.op!=CON)
796: continue;
797: ndmin = 0;
798: for (p2 = list->llist; p2 <= maxnod; p2++) {
799: if (p1==p2 || (*p2)->t.op!=TIMES || (*p2)->t.tr2->t.op!=CON)
800: continue;
801: if ((*p1)->t.tr2->c.value == (*p2)->t.tr2->c.value) {
802: (*p2)->t.tr2 = (*p1)->t.tr1;
803: (*p2)->t.op = PLUS;
804: (*p1)->t.tr1 = (*p2);
805: *p1 = optim(*p1);
806: squash(p2, maxnod);
807: list->nextl--;
808: goto loop;
809: }
810: if (((*p2)->t.tr2->c.value % (*p1)->t.tr2->c.value) == 0)
811: goto contmaj;
812: if (((*p1)->t.tr2->c.value % (*p2)->t.tr2->c.value) == 0) {
813: ndmin++;
814: mindiv = p2;
815: }
816: }
817: if (ndmin > 0 && ndmin < ndmaj) {
818: ndmaj = ndmin;
819: dividend = p1;
820: divisor = mindiv;
821: }
822: contmaj:;
823: }
824: if (dividend==0)
825: return;
826: t = list->nlist[--list->nextn];
827: p1 = dividend;
828: p2 = divisor;
829: t->t.op = PLUS;
830: t->t.type = (*p1)->t.type;
831: t->t.tr1 = (*p1);
832: t->t.tr2 = (*p2)->t.tr1;
833: (*p1)->t.tr2->c.value /= (*p2)->t.tr2->c.value;
834: (*p2)->t.tr1 = t;
835: t = optim(*p2);
836: if (p1 < p2) {
837: *p1 = t;
838: squash(p2, maxnod);
839: } else {
840: *p2 = t;
841: squash(p1, maxnod);
842: }
843: list->nextl--;
844: goto loop;
845: }
846:
847: squash(p, maxp)
848: union tree **p, **maxp;
849: {
850: register union tree **np;
851:
852: for (np = p; np < maxp; np++)
853: *np = *(np+1);
854: }
855:
856: const(op, vp, v, type)
857: register int *vp, v;
858: {
859: switch (op) {
860:
861: case PTOI:
862: (*vp) /= (unsigned)v;
863: return;
864:
865: case PLUS:
866: *vp += v;
867: return;
868:
869: case TIMES:
870: *vp *= v;
871: return;
872:
873: case AND:
874: *vp &= v;
875: return;
876:
877: case OR:
878: *vp |= v;
879: return;
880:
881: case EXOR:
882: *vp ^= v;
883: return;
884:
885: case UDIV:
886: case UMOD:
887: type = UNSIGN;
888: case DIVIDE:
889: case MOD:
890: if (type==UNSIGN && v!=0 && v<=1) {
891: if (op==UDIV || op==DIVIDE) {
892: if (v==1)
893: return;
894: *vp = *(unsigned *)vp >= (unsigned)v;
895: return;
896: } else {
897: if (v==1) {
898: *vp = 0;
899: return;
900: }
901: if (*(unsigned *)vp >= (unsigned)v)
902: *vp -= v;
903: return;
904: }
905: }
906: if (v==0) {
907: error("Warning: divide check");
908: nerror--;
909: } else
910: if (type==INT)
911: if (op==DIVIDE || op==UDIV)
912: *vp /= v;
913: else
914: *vp %= v;
915: else
916: if (op==DIVIDE || op==UDIV)
917: *(unsigned *)vp /= (unsigned)v;
918: else
919: *(unsigned *)vp %= (unsigned)v;
920: return;
921:
922: case RSHIFT:
923: rshift:
924: if (v<0) {
925: v = -v;
926: goto lshift;
927: }
928: if (type==INT)
929: *vp >>= v;
930: else
931: *(unsigned *)vp >>= (unsigned)v;
932: return;
933:
934: case ULSH:
935: type = UNSIGN;
936:
937: case LSHIFT:
938: lshift:
939: if (v<0) {
940: v = -v;
941: goto rshift;
942: }
943: if (type==INT)
944: *vp <<= v;
945: else
946: *(unsigned *)vp <<= (unsigned)v;
947: return;
948:
949: case ANDN:
950: *vp &= ~ v;
951: return;
952: }
953: error("C error: const");
954: }
955:
956: union tree *
957: lconst(op, lp, rp)
958: register union tree *lp, *rp;
959: {
960: long l, r;
961:
962: if (lp->t.op==LCON)
963: l = lp->l.lvalue;
964: else if (lp->t.op==ITOL && lp->t.tr1->t.op==CON) {
965: if (lp->t.tr1->t.type==INT)
966: l = lp->t.tr1->c.value;
967: else
968: l = (unsigned)lp->t.tr1->c.value;
969: } else
970: return(0);
971: if (rp->t.op==LCON)
972: r = rp->l.lvalue;
973: else if (rp->t.op==ITOL && rp->t.tr1->t.op==CON) {
974: if (rp->t.tr1->t.type==INT)
975: r = rp->t.tr1->c.value;
976: else
977: r = (unsigned)rp->t.tr1->c.value;
978: } else
979: return(0);
980: switch (op) {
981:
982: case PLUS:
983: l += r;
984: break;
985:
986: case MINUS:
987: l -= r;
988: break;
989:
990: case TIMES:
991: case LTIMES:
992: l *= r;
993: break;
994:
995: case DIVIDE:
996: case LDIV:
997: if (r==0)
998: error("Divide check");
999: else
1000: l /= r;
1001: break;
1002:
1003: case MOD:
1004: case LMOD:
1005: if (r==0)
1006: error("Divide check");
1007: else
1008: l %= r;
1009: break;
1010:
1011: case AND:
1012: l &= r;
1013: break;
1014:
1015: case ANDN:
1016: l &= ~r;
1017: break;
1018:
1019: case OR:
1020: l |= r;
1021: break;
1022:
1023: case EXOR:
1024: l ^= r;
1025: break;
1026:
1027: case LSHIFT:
1028: l <<= r;
1029: break;
1030:
1031: case RSHIFT:
1032: l >>= r;
1033: break;
1034:
1035: default:
1036: return(0);
1037: }
1038: if (lp->t.op==LCON) {
1039: lp->l.lvalue = l;
1040: return(lp);
1041: }
1042: lp = getblk(sizeof(struct lconst));
1043: lp->t.op = LCON;
1044: lp->t.type = LONG;
1045: lp->l.lvalue = l;
1046: return(lp);
1047: }
1048:
1049: insert(op, tree, list)
1050: register union tree *tree;
1051: register struct acl *list;
1052: {
1053: register d;
1054: int d1, i;
1055: union tree *t;
1056:
1057: ins:
1058: if (tree->t.op != op)
1059: tree = optim(tree);
1060: if (tree->t.op == op && list->nextn < LSTSIZ-2) {
1061: list->nlist[list->nextn++] = tree;
1062: insert(op, tree->t.tr1, list);
1063: insert(op, tree->t.tr2, list);
1064: return;
1065: }
1066: if (!isfloat(tree)) {
1067: /* c1*(x+c2) -> c1*x+c1*c2 */
1068: if ((tree->t.op==TIMES||tree->t.op==LSHIFT)
1069: && tree->t.tr2->t.op==CON && tree->t.tr2->c.value>0
1070: && tree->t.tr1->t.op==PLUS && tree->t.tr1->t.tr2->t.op==CON) {
1071: d = tree->t.tr2->c.value;
1072: if (tree->t.op==TIMES)
1073: tree->t.tr2->c.value *= tree->t.tr1->t.tr2->c.value;
1074: else
1075: tree->t.tr2->c.value = tree->t.tr1->t.tr2->c.value << d;
1076: tree->t.tr1->t.tr2->c.value = d;
1077: tree->t.tr1->t.op = tree->t.op;
1078: tree->t.op = PLUS;
1079: tree = optim(tree);
1080: if (op==PLUS)
1081: goto ins;
1082: }
1083: }
1084: d = degree(tree);
1085: for (i=0; i<list->nextl; i++) {
1086: if ((d1=degree(list->llist[i]))<d) {
1087: t = list->llist[i];
1088: list->llist[i] = tree;
1089: tree = t;
1090: d = d1;
1091: }
1092: }
1093: list->llist[list->nextl++] = tree;
1094: }
1095:
1096: union tree *
1097: tnode(op, type, tr1, tr2)
1098: union tree *tr1, *tr2;
1099: {
1100: register union tree *p;
1101:
1102: p = getblk(sizeof(struct tnode));
1103: p->t.op = op;
1104: p->t.type = type;
1105: p->t.degree = 0;
1106: p->t.tr1 = tr1;
1107: p->t.tr2 = tr2;
1108: return(p);
1109: }
1110:
1111: union tree *
1112: tconst(val, type)
1113: {
1114: register union tree *p;
1115:
1116: p = getblk(sizeof(struct tconst));
1117: p->t.op = CON;
1118: p->t.type = type;
1119: p->c.value = val;
1120: return(p);
1121: }
1122:
1123: union tree *
1124: getblk(size)
1125: {
1126: register union tree *p;
1127:
1128: if (size&01) {
1129: error("compiler botch: odd size");
1130: exit(1);
1131: }
1132: p = (union tree *)curbase;
1133: if ((curbase += size) >= coremax) {
1134: if (sbrk(1024) == (char *)-1) {
1135: error("Out of space-- c1");
1136: exit(1);
1137: }
1138: coremax += 1024;
1139: }
1140: return(p);
1141: }
1142:
1143: islong(t)
1144: {
1145: if (t==LONG)
1146: return(2);
1147: return(1);
1148: }
1149:
1150: union tree *
1151: isconstant(t)
1152: register union tree *t;
1153: {
1154: if (t->t.op==CON || t->t.op==SFCON)
1155: return(t);
1156: if (t->t.op==ITOL && t->t.tr1->t.op==CON)
1157: return(t->t.tr1);
1158: return(NULL);
1159: }
1160:
1161: union tree *
1162: hardlongs(t)
1163: register union tree *t;
1164: {
1165: switch(t->t.op) {
1166:
1167: case TIMES:
1168: case DIVIDE:
1169: case MOD:
1170: t->t.op += LTIMES-TIMES;
1171: break;
1172:
1173: case ASTIMES:
1174: case ASDIV:
1175: case ASMOD:
1176: t->t.op += LASTIMES-ASTIMES;
1177: t->t.tr1 = tnode(AMPER, LONG+PTR, t->t.tr1, TNULL);
1178: break;
1179:
1180: default:
1181: return(t);
1182: }
1183: return(optim(t));
1184: }
1185:
1186: /*
1187: * Is tree of unsigned type?
1188: */
1189: uns(tp)
1190: union tree *tp;
1191: {
1192: register t;
1193:
1194: t = tp->t.type;
1195: if (t==UNSIGN || t==UNCHAR || t&XTYPE)
1196: return(1);
1197: return(0);
1198: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.