![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to coalesce.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / c2|
Return to coalesce.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / c2 |
1.1 root 1:
2: #ifndef lint
3: static char sccsid[] = "@(#)coalesce.c 1.1 86/02/03 Copyr 1985 Sun Micro";
4: #endif
5:
6: /*
7: * Copyright (c) 1985 by Sun Microsystems, Inc.
8: */
9:
10: #include "as.h"
11: #include "c2.h"
12:
13: extern struct oper *newoperand();
14: extern struct ins_bkt *moveq;
15:
16: #define previ( p ) { do p=p->back; while( ISDIRECTIVE(p->op) ); }
17: #define nexti( p ) { do p=p->forw; while( ISDIRECTIVE(p->op) ); }
18:
19: #define ispushop(o) ((o)->type_o == T_PREDEC && (o)->value_o == SPREG)
20: #define ispopop(o) ((o)->type_o == T_POSTINC && (o)->value_o == SPREG)
21:
22: extern int bytesize[];
23: #define BYTESIZE( s ) (bytesize[ (int)(s)])
24:
25: /*
26: * Can register r1 be replaced by a new register r2?
27: * The answer is yes, provided that:
28: * 1. all uses of r1 in (p) are explicit
29: * 2. r1 and r2 are of the same type (a-reg, d-reg, or fp-reg)
30: * Certain exceptions to rule 2 are permissible if both r1 and r2 are
31: * a-regs or d-regs.
32: */
33: int
34: can_replace(p, r1, r2)
35: register NODE *p;
36: register r1,r2;
37: {
38: register struct oper *o;
39: register i;
40: int r1_found;
41:
42: /* search for explicit uses of r1 */
43: r1_found = 0;
44: for (i = 0; i < p->nref; i++) {
45: o = p->ref[i];
46: switch(o->type_o) {
47: case T_REG:
48: if (o->value_o == r1) {
49: r1_found++;
50: if ((p->op == OP_MOVE || p->op == OP_ADD || p->op == OP_SUB)
51: && p->subop == SUBOP_L
52: && !inmask(CCREG, p->forw->rlive)
53: && !inmask(FPCCREG, p->forw->rlive)) {
54: int ok;
55: o->value_o = r2;
56: ok = operand_ok(p->instr, p->ref[0], p->ref[1], 0);
57: o->value_o = r1;
58: if (ok) continue;
59: }
60: if (reg_access[r1] == reg_access[r2]) {
61: continue;
62: }
63: return 0;
64: }
65: continue;
66: case T_DEFER:
67: case T_POSTINC:
68: case T_PREDEC:
69: if (o->value_o == r1) {
70: return 0;
71: }
72: continue;
73: case T_DISPL:
74: if (o->reg_o == r1) {
75: return 0;
76: }
77: continue;
78: case T_INDEX:
79: if (o->reg_o == r1) {
80: return 0;
81: }
82: if (o->value_o == r1) {
83: /* a-regs and d-regs can be used interchangeably here */
84: r1_found++;
85: }
86: continue;
87: case T_REGPAIR:
88: if (o->reg_o == r1 || o->value_o == r1) {
89: return 0;
90: }
91: continue;
92: }
93: if (o->flags_o&O_BFLD) {
94: if (o->flags_o&O_BFOREG && o->bfoffset_o == r1) {
95: return 0;
96: }
97: if (o->flags_o&O_BFWREG && o->bfwidth_o == r1) {
98: return 0;
99: }
100: }
101: }
102: /*
103: * we know that r1 is used or set by p,
104: * but if r1_found == 0, we haven't found an
105: * explicit use. In this case we should bail out.
106: */
107: return(r1_found);
108: }
109:
110: void
111: replace(p, r1, r2)
112: register NODE *p;
113: register r1, r2;
114: {
115: register struct oper *o;
116: register i;
117:
118: /* search for explicit uses of r1 */
119: for (i = 0; i < p->nref; i++) {
120: o = p->ref[i];
121: switch(o->type_o) {
122: case T_REG:
123: case T_DEFER:
124: case T_POSTINC:
125: case T_PREDEC:
126: if (o->value_o == r1) {
127: o->value_o = r2;
128: }
129: continue;
130: case T_DISPL:
131: if (o->reg_o == r1) {
132: o->reg_o = r2;
133: }
134: continue;
135: case T_INDEX:
136: case T_REGPAIR:
137: if (o->reg_o == r1) {
138: o->reg_o = r2;
139: }
140: if (o->value_o == r1) {
141: o->value_o = r2;
142: }
143: continue;
144: }
145: if (o->flags_o&O_BFLD) {
146: if (o->flags_o&O_BFOREG && o->bfoffset_o == r1) {
147: o->bfoffset_o = r2;
148: }
149: if (o->flags_o&O_BFWREG && o->bfwidth_o == r1) {
150: o->bfwidth_o = r2;
151: }
152: continue;
153: } /* if */
154: } /* for */
155: installinstruct(p, p->instr);
156: } /* replace */
157:
158: int
159: next_member(regtype, regset)
160: int regtype;
161: regmask regset;
162: {
163: register regno;
164:
165: switch(regtype) {
166: case AM_DREG:
167: /* try for d-reg first */
168: for(regno = D0REG; regno <= D7REG; regno++) {
169: if (inmask(regno,regset))
170: return(regno);
171: }
172: for(regno = A0REG; regno < A6REG; regno++) {
173: if (inmask(regno,regset))
174: return(regno);
175: }
176: break;
177: case AM_AREG:
178: /* try for a-reg first */
179: for(regno = A0REG; regno < A6REG; regno++) {
180: if (inmask(regno,regset))
181: return(regno);
182: }
183: for(regno = D0REG; regno <= D7REG; regno++) {
184: if (inmask(regno,regset))
185: return(regno);
186: }
187: break;
188: case AM_FREG:
189: /* only another fp-reg will do */
190: for(regno = FP0REG; regno <= FP7REG; regno++) {
191: if (inmask(regno,regset))
192: return(regno);
193: }
194: break;
195: }
196: return(-1);
197: }
198:
199: /*
200: * look for a register that is not live anywhere in (b)..(n).
201: * regtype is the type of register preferred (or required,
202: * in the case of a floating point register). Returns -1 if
203: * no suitable register is found.
204: */
205: int
206: find_freereg(b, n, regtype)
207: register NODE *b, *n;
208: int regtype;
209: {
210: register NODE *p,*bb;
211: regmask liveset;
212: register regno;
213:
214: bb = b->back;
215: liveset = n->rlive;
216: for (p = n; p != bb; p = p->back) {
217: liveset = addmask(liveset, p->rlive);
218: }
219: liveset = addmask(liveset, p->rlive);
220: return(next_member(regtype, notmask(liveset)));
221: }
222:
223: /*
224: * try to replace register r1 with register r2 in the
225: * set of nodes (b)..(n) (assumed to be a basic block).
226: * r2 is assumed to be available in (b)..(n).
227: * Returns 1 if the new assignment succeeds.
228: * Otherwise returns 0 and leaves (b)..(n) unchanged.
229: */
230: int
231: can_reassign_reg(b,n,r1,r2)
232: register NODE *b,*n;
233: register r1;
234: register r2;
235: {
236: register NODE *p,*bb;
237: regmask l;
238:
239: if (!inmask(r1, b->rlive) && !inmask(r1, n->forw->rlive)) {
240: /* r1 and r2 must have the same type or must both be a/d regs */
241: if (reg_access[r1] != reg_access[r2]
242: && (!dareg(r1) || !dareg(r2))) {
243: return(0);
244: }
245: /* (b)..(n) contains the lifetime of r1 */
246: bb = b->back;
247: for (p = n; p != bb; p = p->back) {
248: if (ISINSTRUC(p->op)) {
249: if ((inmask(r1, p->ruse) || inmask(r1, p->rset))
250: && !can_replace(p, r1, r2)) {
251: return(0);
252: }
253: }
254: }
255: return(1);
256: }
257: return(0);
258: } /* can_reassign_reg */
259:
260: void
261: reassign_reg(b,n,r1,r2)
262: register NODE *b,*n;
263: register r1;
264: register r2;
265: {
266: register NODE *p,*bb;
267: regmask l;
268:
269: l = n->forw->rlive;
270: bb = b->back;
271: for (p = n; p != bb; p = p->back) {
272: if (ISINSTRUC(p->op)
273: && (inmask(r1, p->ruse) || inmask(r1, p->rset)))
274: replace(p, r1, r2);
275: l = p->rlive = compute_normal(p, l);
276: }
277: }
278:
279:
280: static struct ins_bkt *
281: move_inst(b,n,x,y)
282: register NODE *b, *n;
283: register struct oper *x, *y;
284: {
285: if (operand_ok(b->instr, x, y, 0)) {
286: return(b->instr);
287: } else if (operand_ok(n->instr, x, y, 0)) {
288: return(n->instr);
289: } else {
290: /* try special cases involving floating point */
291: int Xisfp, Yisfp;
292: Xisfp = Yisfp = 0;
293: if (x->type_o==T_REG && freg(x->value_o))
294: Xisfp = 1;
295: if (y->type_o==T_REG && freg(y->value_o))
296: Yisfp = 1;
297: if (!Xisfp && !Yisfp
298: && !inmask(FPCCREG, n->forw->rlive)) {
299: /* rewrite as (b) mov{b,w,l} X,Y */
300: switch(b->subop) {
301: case SUBOP_B:
302: return(sopcode("movb"));
303: case SUBOP_W:
304: return(sopcode("movw"));
305: case SUBOP_L:
306: case SUBOP_S:
307: return(sopcode("movl"));
308: default:
309: /* if larger than a word, forget it */
310: return(NULL);
311: }
312: } else if (Xisfp && Yisfp) {
313: /* floating point reg-reg move */
314: return(sopcode("fmovex"));
315: }
316: }
317: return(NULL);
318: }
319:
320: /*
321: * Is this instruction a reg-reg operation ?
322: * To be safe, we require the instruction to use all of
323: * both registers, with no data conversions.
324: */
325: static int
326: reg_reg_op(p)
327: register NODE *p;
328: {
329: register struct oper *rm, *rn;
330:
331: if (p->nref == 2) {
332: rm = p->ref[0]; rn = p->ref[1];
333: if(rm != NULL && rm->type_o == T_REG && datareg(rm->value_o)
334: && rn != NULL && rn->type_o == T_REG && datareg(rn->value_o)) {
335: switch (p->subop) {
336: case SUBOP_L:
337: return(dareg(rm->value_o) && dareg(rn->value_o));
338: case SUBOP_X:
339: return(freg(rm->value_o) && freg(rn->value_o));
340: }
341: }
342: }
343: return(0);
344: }
345:
346: static int
347: iscommuteop(p)
348: NODE *p;
349: {
350: char *s;
351:
352: switch(p->op){
353: case OP_ADD:
354: case OP_AND:
355: case OP_OR:
356: case OP_EOR:
357: return(reg_reg_op(p));
358: case OP_OTHER:
359: /*
360: * careful: multiplication isn't really commutative
361: * unless it is also known to be reg-reg
362: */
363: s = p->instr->text_i;
364: if (!strcmp(s,"mulsl") || !strcmp(s,"mulul")
365: || !strcmp(s,"fmulx") || !strcmp(s, "faddx"))
366: return(reg_reg_op(p));
367: }
368: return(0);
369: }
370:
371: /*
372: * returns 1 if an instruction does implied data conversion
373: * to match its destination operand (assumed to be the last operand).
374: * In the 68xxx processors this occurs in cases involving address
375: * registers or floating point registers.
376: */
377: int
378: implied_conversion(p)
379: register NODE *p;
380: {
381: struct oper *o;
382:
383: if (p->nref > 0) {
384: o = p->ref[p->nref-1];
385: if (datareg_addr(o)) {
386: if (areg(o->value_o)) return (p->subop != SUBOP_L);
387: if (freg(o->value_o)) return (p->subop != SUBOP_X);
388: }
389: }
390: return 0;
391: }
392:
393: /*
394: * coalesce register usage over subranges of a basic block,
395: * eliminating unnecessary reg-reg moves.
396: */
397: int
398: coalesce()
399: {
400: register NODE *n;
401: register NODE *p,*b;
402: register struct oper *o;
403: register struct ins_bkt *ip;
404: struct oper *rm, *rn;
405: NODE *q;
406: register int regno;
407: extern NODE *deletenode();
408: int changes;
409: regmask l;
410:
411: changes = 0;
412: for (n=first.forw; n != &first; n=n->forw) {
413:
414: /*
415: * Pattern #1: given
416: * (b) move X,rn
417: * ....
418: * (n) move rn,Y
419: *
420: * rewrite #1: if possible, rewrite as:
421: * (b) move X,Y
422: * ....
423: * (n) (deleted)
424: *
425: * rewrite #2: if possible, rewrite as:
426: * (b) (deleted)
427: * ....
428: * (n) move X,Y
429: *
430: * requirements:
431: * -- (b) and (n) must be moves of the same type
432: * -- (n) must not do sign-extension or other data conversion
433: * -- X must not be an immediate operand.
434: * -- Y must be a legal replacement for rn in (b).
435: * -- neither X nor Y can be a control register or i/o device
436: * -- rn must not be live at (n).
437: * -- rn must be neither used nor set in the interim.
438: * -- side effects of X and Y must not be used in the interim.
439: * -- condition codes should not be live at either (b) or (n).
440: *
441: * for #1:
442: * -- Y must not be used or modified in the interim.
443: *
444: * for #2:
445: * -- X must not be modified in the interim.
446: */
447: o = n->ref[0];
448: if (n->op == OP_MOVE && o->type_o == T_REG && datareg(o->value_o)
449: && !implied_conversion(n)
450: && !inmask(o->value_o, n->forw->rlive)) {
451: struct oper *x, *y;
452: x = y = NULL;
453: regno = o->value_o;
454: b = n;
455: do {
456: previ(b);
457: if (b->op == OP_FIRST || b->op == OP_LABEL
458: || ISBRANCH(b->op)) {
459: /* flow of control to reach this point is unknown */
460: break;
461: }
462: if (b->op == OP_MOVE && b->subop == n->subop
463: && b->ref[1]->type_o == T_REG
464: && b->ref[1]->value_o == o->value_o) {
465: /* have move x,rn;...;move rn,y */
466: x = b->ref[0];
467: y = n->ref[1];
468: /* do checks on x,y */
469: if (x->type_o == T_IMMED
470: || x->type_o == T_REG && !datareg(x->value_o)
471: || y->type_o == T_REG && !datareg(y->value_o)
472: || inmask(CCREG, b->forw->rlive)
473: || inmask(CCREG, n->forw->rlive)
474: || inmask(FPCCREG, b->forw->rlive)
475: || inmask(FPCCREG, n->forw->rlive)) {
476: /* can't optimize */
477: x = y = NULL;
478: }
479: break;
480: }
481: if (inmask(regno,b->rset) || inmask(regno,b->ruse)) {
482: /* unknown use/modification of regno */
483: break;
484: }
485: } while (1);
486: /*
487: * if the preceding search yielded a suitable operand
488: * pair, try to delete either node (b) or node (n).
489: */
490: if (y != NULL) {
491: int can_move_x = (x->type_o == T_REG || cancache(x));
492: int can_move_y = (y->type_o == T_REG || cancache(y));
493: /* determine side effects of (n) other than defining Y */
494: if (y->type_o == T_REG) {
495: l = submask(n->rset, MAKEWMASK(y->value_o, BW|WW|LW));
496: } else {
497: l = n->rset;
498: }
499: if (emptymask(andmask(l, n->forw->rlive))) {
500: /*
501: * search for defs/uses of Y and defs affecting access to Y;
502: * if none are found, move def of Y back to node (b).
503: */
504: p = n;
505: previ(p);
506: while (p != b) {
507: if (may_touch(p, y, n->subop, RMASK|WMASK)) {
508: can_move_y = 0;
509: break;
510: }
511: if (!emptymask(andmask(n->ruse, p->rset))) {
512: /* try salvaging by reassigning registers */
513: int r1, r2;
514: if (p->op != OP_MOVE
515: || p->ref[1]->type_o != T_REG ) {
516: /* def is implicit; give up */
517: can_move_y = 0;
518: break;
519: }
520: r1 = p->ref[1]->value_o;
521: r2 = find_freereg(p, n, reg_access[r1]);
522: if (r2 == -1 || !can_reassign_reg(p, n, r1, r2)) {
523: can_move_y = 0;
524: break;
525: }
526: reassign_reg(p, n, r1, r2);
527: }
528: previ(p);
529: }
530: if (can_move_y && (ip = move_inst(b, n, x, y)) != NULL) {
531: /* rewrite */
532: freeoperand(b->ref[1]);
533: b->ref[1] = newoperand(y);
534: installinstruct(b, ip);
535: n = deletenode(n);
536: changes++;
537: meter.redunm++;
538: if (ispopop(x) && ispushop(y)) {
539: b = deletenode(b);
540: changes++;
541: meter.redunm++;
542: }
543: l = n->forw->rlive;
544: for (p = n; p != b; p = p->back) {
545: l = p->rlive = compute_normal(p, l);
546: }
547: continue;
548: } /* if can_move_y */
549: } /* if */
550: /*
551: * search for defs of X and defs affecting access to X;
552: * if none are found, move use of X forward to node (n).
553: */
554: p = n;
555: previ(p);
556: while (p != b) {
557: if (may_touch(p, x, n->subop, WMASK)) {
558: can_move_x = 0;
559: break;
560: }
561: if (!emptymask(andmask(b->ruse, p->rset))) {
562: /* try salvaging by reassigning registers */
563: int r1, r2;
564: if (p->op != OP_MOVE
565: || p->ref[1]->type_o != T_REG ) {
566: /* def is implicit; give up */
567: can_move_x = 0;
568: break;
569: }
570: r1 = p->ref[1]->value_o;
571: r2 = find_freereg(p, n, reg_access[r1]);
572: if (r2 == -1 || !can_reassign_reg(p, n, r1, r2)) {
573: can_move_x = 0;
574: break;
575: }
576: reassign_reg(p, n, r1, r2);
577: }
578: previ(p);
579: }
580: if (can_move_x && (ip = move_inst(b, n, x, y)) != NULL) {
581: /* rewrite */
582: freeoperand(n->ref[0]);
583: n->ref[0] = newoperand(x);
584: installinstruct(n, ip);
585: b = deletenode(b);
586: changes++;
587: meter.redunm++;
588: if (ispopop(x) && ispushop(y)) {
589: n = deletenode(n);
590: changes++;
591: meter.redunm++;
592: }
593: l = n->forw->rlive;
594: for (p = n; p != b; p = p->back) {
595: l = p->rlive = compute_normal(p, l);
596: }
597: continue;
598: } /* if can_move_x */
599: } /* y != NULL */
600: } /* if */
601:
602: /*
603: * Pattern #2: given
604: * (b) move X,rn
605: * ....
606: * (computations involving rn)
607: * ....
608: * (n) move rn,rm
609: *
610: * if possible, rewrite as:
611: * (b) move X,rm
612: * ....
613: * (all defs/uses of rn changed to def/use rm)
614: * ....
615: * (n) (deleted)
616: *
617: * requirements:
618: * -- rn must not be live at (n).
619: * -- condition codes should not be live at (n).
620: * -- rm must neither be used nor set in the interim.
621: * -- all defs/uses of rn in (b)..(n) must be replaceable with rm.
622: */
623: o = n->ref[0];
624: if (n->op == OP_MOVE && reg_reg_op(n)
625: && !inmask(CCREG, n->forw->rlive)
626: && !inmask(FPCCREG, n->forw->rlive)
627: && !inmask(o->value_o, n->forw->rlive)) {
628: regno = n->ref[1]->value_o;
629: b = n;
630: do {
631: previ(b);
632: if (b->op == OP_FIRST || b->op == OP_LABEL
633: || ISBRANCH(b->op)) {
634: /* flow of control to reach this point is unknown */
635: break;
636: }
637: if (b->op == OP_MOVE && b->subop == n->subop
638: && sameops(o, b->ref[1])
639: && !inmask(regno, b->forw->rlive)) {
640: /* have move x,rn;...;move rn,rm */
641: if (can_reassign_reg(b, n, o->value_o, regno)) {
642: reassign_reg(b, n, o->value_o, regno);
643: b->ref[1]->value_o = regno;
644: n = deletenode(n);
645: changes++;
646: meter.redunm++;
647: l = n->forw->rlive;
648: for (p = n; p != b; p = p->back) {
649: l = p->rlive = compute_normal(p, l);
650: }
651: }
652: break;
653: }
654: if (inmask(regno,b->rset) || inmask(regno,b->ruse)) {
655: /* unknown use/modification of regno */
656: break;
657: }
658: } while (1);
659: } /* if */
660:
661: /*
662: * Pattern #3: (forward copy propagation)
663: * (n) move rm,rn (rm is dead after (n))
664: * ....
665: * (computations involving rn)
666: * ....
667: * (p) lastuse(rn) (rn is dead after (p))
668: *
669: * if possible, rewrite as:
670: * (n) (deleted)
671: * ....
672: * (all defs/uses of rn changed to def/use rm)
673: * ....
674: * (p) lastuse(rm)
675: *
676: * requirements:
677: * -- the move at (n) must not involve data conversions.
678: * -- rm must not be live after (n).
679: * -- rn must not be live after (p).
680: * -- rm must neither be used nor set in the interim.
681: * -- condition codes must not be live after (n).
682: * -- if condition codes are live at (p), rm and rn must be
683: * of the same type.
684: * -- all defs/uses of rn in (n)..(p) must be replaceable with rm.
685: */
686: if (n->op == OP_MOVE && reg_reg_op(n)
687: && !inmask(CCREG, n->forw->rlive)
688: && !inmask(FPCCREG, n->forw->rlive)
689: && !inmask(n->ref[0]->value_o, n->forw->rlive)) {
690: rm = n->ref[0];
691: rn = n->ref[1];
692: regno = rn->value_o;
693: p = n;
694: do {
695: /* scan forward for last use of value in rn */
696: nexti(p);
697: if (p->op == OP_FIRST || p->op == OP_LABEL
698: || ISBRANCH(p->op)) {
699: /* flow of control to reach this point is unknown */
700: break;
701: }
702: if (!inmask(regno, p->forw->rlive)) {
703: if (can_reassign_reg(n, p, regno, rm->value_o)) {
704: reassign_reg(n, p, regno, rm->value_o);
705: n = deletenode(n);
706: changes++;
707: meter.redunm++;
708: n->rlive = compute_normal(n, n->forw->rlive);
709: }
710: break;
711: }
712: if (inmask(rm->value_o,p->rset)||inmask(rm->value_o,p->ruse)) {
713: /* unknown use/modification of rm */
714: break;
715: }
716: } while(1);
717: } /* if */
718:
719: /*
720: * Pattern #4: (similar to #3, but exploits commutativity)
721: * (n) move rm,rn
722: * (q) <op> ro,rn (ro is dead after (q))
723: * ....
724: * (computations involving rn)
725: * ....
726: * (p) lastuse(rn) (rn is dead after (p))
727: *
728: * if possible, rewrite as:
729: * (n) (deleted)
730: * (q) <op> rm,ro
731: * ....
732: * (all defs/uses of rn changed to def/use ro)
733: * ....
734: * (p) lastuse(ro)
735: *
736: * requirements:
737: * -- the move at (n) must not involve data conversions.
738: * -- <op> must be commutative
739: * -- ro must not be live after (q).
740: * -- condition codes must not be live after (q).
741: * -- if condition codes are live after (p), rn and ro
742: * must be registers of the same type.
743: * -- rn must not be live after (p).
744: * -- ro must neither be used nor set in the interim.
745: * -- all defs/uses of rn in (q)..(p) must be replaceable with ro.
746: */
747: if (n->op == OP_MOVE && reg_reg_op(n)) {
748: rm = n->ref[0];
749: rn = n->ref[1];
750: q = n;
751: nexti(q);
752: if (iscommuteop(q)
753: && sameops(rn, q->ref[1])
754: && operand_ok(q->instr, rm, (o = q->ref[0]), 0)
755: && !inmask(o->value_o, q->forw->rlive)
756: && !inmask(CCREG, q->forw->rlive)
757: && !inmask(FPCCREG, q->forw->rlive) ) {
758: /*
759: * ro is dead, and its last use is in
760: * a commutative operator with rn. Scan for
761: * the last use of the value in rn.
762: */
763: regno = rn->value_o;
764: p = q;
765: do {
766: nexti(p);
767: if (p->op == OP_FIRST || p->op == OP_LABEL
768: || ISBRANCH(p->op)) {
769: /* flow of control to reach this point is unknown */
770: break;
771: }
772: if (!inmask(regno, p->forw->rlive)) {
773: if (can_reassign_reg(n, p, regno, o->value_o)) {
774: /*
775: * use rm as the first operand of q,
776: * propagate ro through the lifetime of rn,
777: * and delete the move from rm to rn.
778: */
779: q->ref[0] = newoperand(rm);
780: reassign_reg(n, p, regno, o->value_o);
781: freeoperand(o);
782: n = deletenode(n);
783: changes++;
784: meter.redunm++;
785: n->rlive = compute_normal(n, n->forw->rlive);
786: }
787: break;
788: } /* if */
789: if(inmask(o->value_o,p->ruse)||inmask(o->value_o,p->rset)) {
790: /* unknown use/def of ro */
791: break;
792: }
793: } while (1);
794: } /* if */
795: } /* if */
796:
797: } /* for */
798: return(changes);
799: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.