![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to peep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / alef / k|
Return to peep.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / alef / k |
1.1 root 1: #include <u.h>
2: #include <libc.h>
3: #include <bio.h>
4: #include <ctype.h>
5: #define Extern extern
6: #include "parl.h"
7: #include "globl.h"
8:
9: void
10: peep(void)
11: {
12: Reg *r, *r1, *r2;
13: Inst *p;
14: int t;
15: /*
16: * complete R structure
17: */
18: t = 0;
19: for(r=firstr; r!=R; r=r1) {
20: r1 = r->next;
21: if(r1 == R)
22: break;
23: p = r->prog->next;
24: while(p != r1->prog)
25: switch(p->op) {
26: default:
27: r2 = rega();
28: r->next = r2;
29: r2->next = r1;
30:
31: r2->prog = p;
32: r2->p1 = r;
33: r->s1 = r2;
34: r2->s1 = r1;
35: r1->p1 = r2;
36:
37: r = r2;
38: t++;
39:
40: case ADATA:
41: case ADYNT:
42: case AINIT:
43: case AGLOBL:
44: case ANAME:
45: p = p->next;
46: }
47: }
48:
49: loop1:
50: t = 0;
51: for(r=firstr; r!=R; r=r->next) {
52: p = r->prog;
53: if(p->op == AMOVW || p->op == AFMOVF || p->op == AFMOVD)
54: if(regtyp(&p->dst)) {
55: if(regtyp(&p->src1))
56: if(p->src1.type == p->dst.type) {
57: if(copyprop(r)) {
58: excise(r);
59: t++;
60: } else
61: if(subprop(r) && copyprop(r)) {
62: excise(r);
63: t++;
64: }
65: }
66: if(regzer(&p->src1))
67: if(p->dst.type == A_REG) {
68: p->src1.type = A_REG;
69: p->src1.reg = 0;
70: if(copyprop(r)) {
71: excise(r);
72: t++;
73: } else
74: if(subprop(r) && copyprop(r)) {
75: excise(r);
76: t++;
77: }
78: }
79: }
80: }
81: if(t)
82: goto loop1;
83: }
84:
85: void
86: excise(Reg *r)
87: {
88: Inst *p;
89:
90: p = r->prog;
91: p->op = ANOP;
92: p->src1 = zprog.src1;
93: p->dst = zprog.dst;
94: p->reg = zprog.reg; /**/
95: }
96:
97: Reg*
98: uniqp(Reg *r)
99: {
100: Reg *r1;
101:
102: r1 = r->p1;
103: if(r1 == R) {
104: r1 = r->p2;
105: if(r1 == R || r1->p2next != R)
106: return R;
107: } else
108: if(r->p2 != R)
109: return R;
110: return r1;
111: }
112:
113: Reg*
114: uniqs(Reg *r)
115: {
116: Reg *r1;
117:
118: r1 = r->s1;
119: if(r1 == R) {
120: r1 = r->s2;
121: if(r1 == R)
122: return R;
123: } else
124: if(r->s2 != R)
125: return R;
126: return r1;
127: }
128:
129: regzer(Adres *a)
130: {
131:
132: if(a->type == A_CONST)
133: if(a->sym == ZeroS)
134: if(a->ival == 0)
135: return 1;
136: if(a->type == A_REG)
137: if(a->reg == 0)
138: return 1;
139: return 0;
140: }
141:
142: regtyp(Adres *a)
143: {
144:
145: if(a->type == A_REG) {
146: if(a->reg != 0)
147: return 1;
148: return 0;
149: }
150: if(a->type == A_FREG)
151: return 1;
152: return 0;
153: }
154:
155: /*
156: * the idea is to substitute
157: * one register for another
158: * from one MOV to another
159: * MOV a, R0
160: * ADD b, R0 / no use of R1
161: * MOV R0, R1
162: * would be converted to
163: * MOV a, R1
164: * ADD b, R1
165: * MOV R1, R0
166: * hopefully, then the former or latter MOV
167: * will be eliminated by copy propagation.
168: */
169: int
170: subprop(Reg *r0)
171: {
172: Inst *p;
173: Adres *v1, *v2;
174: Reg *r;
175: int t;
176:
177: p = r0->prog;
178: v1 = &p->src1;
179: if(!regtyp(v1))
180: return 0;
181: v2 = &p->dst;
182: if(!regtyp(v2))
183: return 0;
184: for(r=uniqp(r0); r!=R; r=uniqp(r)) {
185: if(uniqs(r) == R)
186: break;
187: p = r->prog;
188: switch(p->op) {
189: case AJMPL:
190: return 0;
191:
192: case AADD:
193: case ASUB:
194: case ASLL:
195: case ASRL:
196: case ASRA:
197: case AOR:
198: case AAND:
199: case AXOR:
200: case AMUL:
201: case ADIV:
202: case ADIVL:
203: case AMOD:
204: case AMODL:
205:
206: case AFADDD:
207: case AFADDF:
208: case AFSUBD:
209: case AFSUBF:
210: case AFMULD:
211: case AFMULF:
212: case AFDIVD:
213: case AFDIVF:
214: if(p->dst.type == v1->type)
215: if(p->dst.reg == v1->reg) {
216: if(p->reg == Nreg)
217: p->reg = p->dst.reg;
218: goto gotit;
219: }
220: break;
221:
222: case AFMOVF:
223: case AFMOVD:
224: case AMOVW:
225: if(p->dst.type == v1->type)
226: if(p->dst.reg == v1->reg)
227: goto gotit;
228: break;
229: }
230: if(copyau(&p->src1, v2) ||
231: copyau1(p, v2) ||
232: copyau(&p->dst, v2))
233: break;
234: if(copysub(&p->src1, v1, v2, 0) ||
235: copysub1(p, v1, v2, 0) ||
236: copysub(&p->dst, v1, v2, 0))
237: break;
238: }
239: return 0;
240:
241: gotit:
242: copysub(&p->dst, v1, v2, 1);
243: if(opt('P')) {
244: print("gotit: %a->%a\n%i", v1, v2, r->prog);
245: if(p->src1.type == v2->type)
246: print(" excise");
247: print("\n");
248: }
249: for(r=uniqs(r); r!=r0; r=uniqs(r)) {
250: p = r->prog;
251: copysub(&p->src1, v1, v2, 1);
252: copysub1(p, v1, v2, 1);
253: copysub(&p->dst, v1, v2, 1);
254: if(opt('P'))
255: print("%i\n", r->prog);
256: }
257: t = v1->reg;
258: v1->reg = v2->reg;
259: v2->reg = t;
260: if(opt('P'))
261: print("%i last\n", r->prog);
262: return 1;
263: }
264:
265: /*
266: * The idea is to remove redundant copies.
267: * v1->v2 F=0
268: * (use v2 s/v2/v1/)*
269: * set v1 F=1
270: * use v2 return fail
271: * -----------------
272: * v1->v2 F=0
273: * (use v2 s/v2/v1/)*
274: * set v1 F=1
275: * set v2 return success
276: */
277: int
278: copyprop(Reg *r0)
279: {
280: Inst *p;
281: Adres *v1, *v2;
282: Reg *r;
283:
284: p = r0->prog;
285: v1 = &p->src1;
286: v2 = &p->dst;
287: if(copyas(v1, v2))
288: return 1;
289: for(r=firstr; r!=R; r=r->next)
290: r->active = 0;
291: return copy1(v1, v2, r0->s1, 0);
292: }
293:
294: copy1(Adres *v1, Adres *v2, Reg *r, int f)
295: {
296: int t;
297: Inst *p;
298:
299: if(r->active) {
300: if(opt('P'))
301: print("act set; return 1\n");
302: return 1;
303: }
304: r->active = 1;
305: if(opt('P'))
306: print("copy %a->%a f=%d\n", v1, v2, f);
307: for(; r != R; r = r->s1) {
308: p = r->prog;
309: if(opt('P'))
310: print("%i", p);
311: if(!f && uniqp(r) == R) {
312: f = 1;
313: if(opt('P'))
314: print("; merge; f=%d", f);
315: }
316: t = copyu(p, v2, A);
317: switch(t) {
318: case 2: /* rar, cant split */
319: if(opt('P'))
320: print("; %arar; return 0\n", v2);
321: return 0;
322:
323: case 3: /* set */
324: if(opt('P'))
325: print("; %aset; return 1\n", v2);
326: return 1;
327:
328: case 1: /* used, substitute */
329: case 4: /* use and set */
330: if(f) {
331: if(!opt('P'))
332: return 0;
333: if(t == 4)
334: print("; %aused+set and f=%d; return 0\n", v2, f);
335: else
336: print("; %aused and f=%d; return 0\n", v2, f);
337: return 0;
338: }
339: if(copyu(p, v2, v1)) {
340: if(opt('P'))
341: print("; sub fail; return 0\n");
342: return 0;
343: }
344: if(opt('P'))
345: print("; sub%a/%a", v2, v1);
346: if(t == 4) {
347: if(opt('P'))
348: print("; %aused+set; return 1\n", v2);
349: return 1;
350: }
351: break;
352: }
353: if(!f) {
354: t = copyu(p, v1, A);
355: if(!f && (t == 2 || t == 3 || t == 4)) {
356: f = 1;
357: if(opt('P'))
358: print("; %aset and !f; f=%d", v1, f);
359: }
360: }
361: if(opt('P'))
362: print("\n");
363: if(r->s2)
364: if(!copy1(v1, v2, r->s2, f))
365: return 0;
366: }
367: return 1;
368: }
369:
370: /*
371: * return
372: * 1 if v only used (and substitute),
373: * 2 if read-alter-rewrite
374: * 3 if set
375: * 4 if set and used
376: * 0 otherwise (not touched)
377: */
378: int
379: copyu(Inst *p, Adres *v, Adres *s)
380: {
381:
382: switch(p->op) {
383:
384: default:
385: if(opt('P'))
386: print(" (???)");
387: return 2;
388:
389:
390: case ANOP: /* read, write */
391: case AMOVW:
392: case AMOVH:
393: case AMOVHU:
394: case AMOVB:
395: case AMOVBU:
396:
397: case AFMOVF:
398: case AFMOVD:
399: case AFMOVDW:
400: case AFMOVWD:
401: case AFMOVFW:
402: case AFMOVWF:
403: case AFMOVFD:
404: case AFMOVDF:
405: if(s != A) {
406: if(copysub(&p->src1, v, s, 1))
407: return 1;
408: if(!copyas(&p->dst, v))
409: if(copysub(&p->dst, v, s, 1))
410: return 1;
411: return 0;
412: }
413: if(copyas(&p->dst, v)) {
414: if(copyau(&p->src1, v))
415: return 4;
416: return 3;
417: }
418: if(copyau(&p->src1, v))
419: return 1;
420: if(copyau(&p->dst, v))
421: return 1;
422: return 0;
423:
424: case AADD: /* read read write */
425: case ASUB:
426: case ASLL:
427: case ASRL:
428: case ASRA:
429: case AOR:
430: case AAND:
431: case AXOR:
432: case AMUL:
433: case ADIV:
434: case ADIVL:
435: case AMOD:
436: case AMODL:
437:
438: case AFADDF:
439: case AFADDD:
440: case AFSUBF:
441: case AFSUBD:
442: case AFMULF:
443: case AFMULD:
444: case AFDIVF:
445: case AFDIVD:
446: if(s != A) {
447: if(copysub(&p->src1, v, s, 1))
448: return 1;
449: if(copysub1(p, v, s, 1))
450: return 1;
451: if(!copyas(&p->dst, v))
452: if(copysub(&p->dst, v, s, 1))
453: return 1;
454: return 0;
455: }
456: if(copyas(&p->dst, v)) {
457: if(p->reg == Nreg)
458: p->reg = p->dst.reg;
459: if(copyau(&p->src1, v))
460: return 4;
461: if(copyau1(p, v))
462: return 4;
463: return 3;
464: }
465: if(copyau(&p->src1, v))
466: return 1;
467: if(copyau1(p, v))
468: return 1;
469: if(copyau(&p->dst, v))
470: return 1;
471: return 0;
472:
473: case ABA: /* no reference */
474: case ABCC:
475: case ABCS:
476: case ABE:
477: case ABG:
478: case ABGE:
479: case ABGU:
480: case ABL:
481: case ABLE:
482: case ABLEU:
483: case ABN:
484: case ABNE:
485: case ABNEG:
486: case ABPOS:
487: case ABVC:
488: case ABVS:
489: case AFBA:
490: case AFBE:
491: case AFBG:
492: case AFBGE:
493: case AFBL:
494: case AFBLE:
495: case AFBLG:
496: case AFBN:
497: case AFBNE:
498: case AFBO:
499: case AFBU:
500: case AFBUE:
501: case AFBUG:
502: case AFBUGE:
503: case AFBUL:
504: case AFBULE:
505: break;
506:
507: case ACMP: /* read read */
508: case AFCMPD:
509: case AFCMPF:
510: if(s != A) {
511: if(copysub(&p->src1, v, s, 1))
512: return 1;
513: return copysub(&p->dst, v, s, 1);
514: }
515: if(copyau(&p->src1, v))
516: return 1;
517: if(copyau(&p->dst, v))
518: return 1;
519: break;
520:
521: case AJMP: /* funny */
522: if(s != A) {
523: if(copysub(&p->dst, v, s, 1))
524: return 1;
525: return 0;
526: }
527: if(copyau(&p->dst, v))
528: return 1;
529: return 0;
530:
531: case ARETURN: /* funny */
532: if(v->type == A_REG && v->reg == REGRET)
533: return 2;
534: if(v->type == A_FREG && v->reg == FREGRET)
535: return 2;
536:
537: case AJMPL: /* funny */
538: if(v->type == A_REG) {
539: if(v->reg == Regspass)
540: return 2;
541: if(v->reg == RegSP)
542: return 2;
543: }
544: if(s != A) {
545: if(copysub(&p->dst, v, s, 1))
546: return 1;
547: return 0;
548: }
549: if(copyau(&p->dst, v))
550: return 4;
551: return 3;
552:
553: case ATEXT: /* funny */
554: if(v->type == A_REG)
555: if(v->reg == Regspass)
556: return 3;
557: return 0;
558: }
559: return 0;
560: }
561:
562: int
563: a2type(Inst *p)
564: {
565:
566: switch(p->op) {
567: case AADD:
568: case ASUB:
569: case ASLL:
570: case ASRL:
571: case ASRA:
572: case AOR:
573: case AAND:
574: case AXOR:
575: case AMUL:
576: case ADIV:
577: case ADIVL:
578: case AMOD:
579: case AMODL:
580: return A_REG;
581:
582: case AFADDF:
583: case AFADDD:
584: case AFSUBF:
585: case AFSUBD:
586: case AFMULF:
587: case AFMULD:
588: case AFDIVF:
589: case AFDIVD:
590: return A_FREG;
591: }
592: return A_NONE;
593: }
594:
595: /*
596: * direct reference,
597: * could be set/use depending on
598: * semantics
599: */
600: int
601: copyas(Adres *a, Adres *v)
602: {
603:
604: if(regtyp(v))
605: if(a->type == v->type)
606: if(a->reg == v->reg)
607: return 1;
608: return 0;
609: }
610:
611: /*
612: * either direct or indirect
613: */
614: int
615: copyau(Adres *a, Adres *v)
616: {
617:
618: if(copyas(a, v))
619: return 1;
620: if(v->type == A_REG)
621: if(a->type == A_INDREG)
622: if(v->reg == a->reg)
623: return 1;
624: return 0;
625: }
626:
627: int
628: copyau1(Inst *p, Adres *v)
629: {
630:
631: if(regtyp(v))
632: if(p->src1.type == v->type || p->dst.type == v->type)
633: if(p->reg == v->reg) {
634: if(a2type(p) != v->type)
635: print("botch a2type %i\n", p);
636: return 1;
637: }
638: return 0;
639: }
640:
641: /*
642: * substitute s for v in a
643: * return failure to substitute
644: */
645: int
646: copysub(Adres *a, Adres *v, Adres *s, int f)
647: {
648:
649: if(f)
650: if(copyau(a, v))
651: a->reg = s->reg;
652: return 0;
653: }
654:
655: int
656: copysub1(Inst *p1, Adres *v, Adres *s, int f)
657: {
658:
659: if(f)
660: if(copyau1(p1, v))
661: p1->reg = s->reg;
662: return 0;
663: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.