![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optim.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / mip|
Return to optim.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / mip |
1.1 root 1: # include "mfile1"
2:
3: # define SWAP(p,q) {sp=p; p=q; q=sp;}
4: # define RCON(p) (p->in.right->in.op==ICON)
5: # define RO(p) p->in.right->in.op
6: # define RV(p) p->in.right->tn.lval
7: # define LCON(p) (p->in.left->in.op==ICON)
8: # define LO(p) p->in.left->in.op
9: # define LV(p) p->in.left->tn.lval
10:
11: int oflag = 0;
12:
13: NODE *
14: fortarg( p ) NODE *p; {
15: /* fortran function arguments */
16:
17: if( p->in.op == CM ){
18: p->in.left = fortarg( p->in.left );
19: p->in.right = fortarg( p->in.right );
20: return(p);
21: }
22:
23: while( ISPTR(p->in.type) ){
24: p = buildtree( UNARY MUL, p, NIL );
25: }
26: return( optim(p) );
27: }
28:
29: /* mapping relationals when the sides are reversed */
30: short revrel[] ={ EQ, NE, GE, GT, LE, LT, UGE, UGT, ULE, ULT };
31: NODE *
32: optim(p) register NODE *p; {
33: /* local optimizations, most of which are probably machine independent */
34:
35: register o, ty;
36: NODE *sp;
37: int i;
38: TWORD t;
39:
40: if( (t=BTYPE(p->in.type))==ENUMTY || t==MOETY ) econvert(p);
41: if( oflag ) return(p);
42: ty = optype( o=p->in.op);
43: if( ty == LTYPE ) return(p);
44:
45: if( ty == BITYPE ) p->in.right = optim(p->in.right);
46: p->in.left = optim(p->in.left);
47:
48: /* collect constants */
49:
50: switch(o){
51:
52: case SCONV:
53: case PCONV:
54: return( clocal(p) );
55:
56: case FORTCALL:
57: p->in.right = fortarg( p->in.right );
58: break;
59:
60: case UNARY AND:
61: if( LO(p) != NAME ) cerror( "& error" );
62:
63: if( !andable(p->in.left) ) return(p);
64:
65: LO(p) = ICON;
66:
67: setuleft:
68: /* paint over the type of the left hand side with the type of the top */
69: p->in.left->in.type = p->in.type;
70: p->in.left->fn.cdim = p->fn.cdim;
71: p->in.left->fn.csiz = p->fn.csiz;
72: p->in.op = FREE;
73: return( p->in.left );
74:
75: case UNARY MUL:
76: if( LO(p) != ICON ) break;
77: LO(p) = NAME;
78: goto setuleft;
79:
80: case MINUS:
81: if( !nncon(p->in.right) ) break;
82: RV(p) = -RV(p);
83: o = p->in.op = PLUS;
84:
85: case MUL:
86: case PLUS:
87: case AND:
88: case OR:
89: case ER:
90: /* commutative ops; for now, just collect constants */
91: /* someday, do it right */
92: if( nncon(p->in.left) || ( LCON(p) && !RCON(p) ) ) SWAP( p->in.left, p->in.right );
93: /* make ops tower to the left, not the right */
94: if( RO(p) == o ){
95: NODE *t1, *t2, *t3;
96: t1 = p->in.left;
97: sp = p->in.right;
98: t2 = sp->in.left;
99: t3 = sp->in.right;
100: /* now, put together again */
101: p->in.left = sp;
102: sp->in.left = t1;
103: sp->in.right = t2;
104: p->in.right = t3;
105: }
106: if(o == PLUS && LO(p) == MINUS && RCON(p) && RCON(p->in.left) &&
107: conval(p->in.right, MINUS, p->in.left->in.right)){
108: zapleft:
109: RO(p->in.left) = FREE;
110: LO(p) = FREE;
111: p->in.left = p->in.left->in.left;
112: }
113: if( RCON(p) && LO(p)==o && RCON(p->in.left) && conval( p->in.right, o, p->in.left->in.right ) ){
114: goto zapleft;
115: }
116: else if( LCON(p) && RCON(p) && conval( p->in.left, o, p->in.right ) ){
117: zapright:
118: RO(p) = FREE;
119: p->in.left = makety( p->in.left, p->in.type, p->fn.cdim, p->fn.csiz );
120: p->in.op = FREE;
121: return( clocal( p->in.left ) );
122: }
123:
124: /* change muls to shifts */
125:
126: if( o==MUL && nncon(p->in.right) && (i=ispow2(RV(p)))>=0){
127: if( i == 0 ){ /* multiplication by 1 */
128: goto zapright;
129: }
130: o = p->in.op = LS;
131: p->in.right->in.type = p->in.right->fn.csiz = INT;
132: RV(p) = i;
133: }
134:
135: /* change +'s of negative consts back to - */
136: if( o==PLUS && nncon(p->in.right) && RV(p)<0 ){
137: RV(p) = -RV(p);
138: o = p->in.op = MINUS;
139: }
140: break;
141:
142: case DIV:
143: if( nncon( p->in.right ) && p->in.right->tn.lval == 1 ) goto zapright;
144: break;
145:
146: case EQ:
147: case NE:
148: case LT:
149: case LE:
150: case GT:
151: case GE:
152: case ULT:
153: case ULE:
154: case UGT:
155: case UGE:
156: if( !LCON(p) ) break;
157:
158: /* exchange operands */
159:
160: sp = p->in.left;
161: p->in.left = p->in.right;
162: p->in.right = sp;
163: p->in.op = revrel[p->in.op - EQ ];
164: break;
165:
166: }
167:
168: return(p);
169: }
170:
171: ispow2( c ) CONSZ c; {
172: register i;
173: if( c <= 0 || (c&(c-1)) ) return(-1);
174: for( i=0; c>1; ++i) c >>= 1;
175: return(i);
176: }
177:
178: nncon( p ) NODE *p; {
179: /* is p a constant without a name */
180: return( p->in.op == ICON && p->tn.rval == NONAME );
181: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.