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