![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hardexp.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 hardexp.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / c2 |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)hardexp.c 1.1 86/02/03 Copyr 1985 Sun Micro";
3: #endif
4:
5: /*
6: * Copyright (c) 1985 by Sun Microsystems, Inc.
7: */
8:
9: #include "as.h"
10: #include "c2.h"
11:
12: extern struct oper * newoperand();
13: extern struct optree * newtree();
14:
15: void
16: ocomplex( operation, subop1, subop2 )
17: char operation;
18: struct oper * subop1, *subop2;
19: {
20: register struct optree *otp;
21: otp = newtree();
22: otp->left_t = newoperand( subop1 );
23: otp->right_t = subop2 ? newoperand( subop2 ) : NULL;
24: otp->op_t = operation;
25: subop1->sym_o = (struct sym_bkt *)otp;
26: subop1->flags_o |= O_COMPLEX;
27: }
28:
29:
30: static void
31: valcomplex( op )
32: struct oper *op;
33: {
34: register struct optree *tp;
35: register struct oper *r, *l;
36: register int * vp;
37: struct sym_bkt *sp;
38: int operation;
39: vp = (op->type_o == T_INDEX) ? &op->disp_o : &op->value_o;
40: if (op->flags_o&O_COMPLEX){
41: tp = (struct optree *)op->sym_o;
42: operation = tp->op_t;
43: l = tp->left_t ;
44: valcomplex( l );
45: if ((r=tp->right_t) == NULL)
46: operation = -operation; /* so we can tell unary SUB from binary */
47: else
48: valcomplex( r );
49: if (l->sym_o || (r && r->sym_o)) {
50: if ( operation == SUB
51: && !(l->flags_o&O_COMPLEX) && !(r->flags_o&O_COMPLEX)
52: && l->sym_o->csect_s == r->sym_o->csect_s
53: && l->sym_o->csect_s != C_TEXT
54: && l->sym_o->attr_s&S_DEF && r->sym_o->attr_s&S_DEF
55: && l->sym_o->value_s >= 0 && r->sym_o->value_s >= 0 ){
56: /*
57: * special case: it is ok to subtract two symbols in data
58: * space, as long as we know their values.
59: */
60: *vp = l->sym_o->value_s - r->sym_o->value_s;
61: goto uncomplex;
62: }
63: return;
64: }
65: switch( operation ){
66: case ADD: *vp = l->value_o + r->value_o; break;
67: case SUB: *vp = l->value_o - r->value_o; break;
68: case MUL: *vp = l->value_o * r->value_o; break;
69: case DIV: *vp = l->value_o / r->value_o; break;
70: case -SUB: *vp = - l->value_o; break;
71: case -NOT: *vp = ~ l->value_o; break;
72: }
73: uncomplex:
74: op->flags_o &= ~O_COMPLEX;
75: op->sym_o = NULL;
76: if (op->type_o == T_INDEX
77: && !(op->flags_o&(O_INDIRECT|O_BSUPRESS|O_PREINDEX|O_POSTINDEX))
78: && op->disp_o >= -32768 && op->disp_o <= 32767) {
79: /* a T_DISPL disguised as a T_INDEX */
80: op->type_o = T_DISPL;
81: op->value_o = op->disp_o;
82: op->disp_o = 0;
83: }
84: freeoperand(l);
85: freeoperand(r);
86: freetree(tp);
87: } else {
88: if ( op->sym_o == NULL ) return ;
89: sp = op->sym_o;
90: if ((sp->attr_s & S_DEF) == 0) return ;
91: if ( sp->csect_s == C_UNDEF ) {
92: *vp += sp->value_s;
93: op->sym_o = NULL;
94: }
95: }
96: return ;
97: }
98:
99:
100: void
101: rectify()
102: {
103: /* look at all operands. Try to fix up the complex ones */
104: register NODE *np;
105: register struct oper *op;
106: register struct optree *tp;
107: register opno, nops;
108: struct sym_bkt * sp;
109: short m;
110:
111: for (np=first.forw; np!= &first; np = np->forw){
112: if (np->op==OP_LABEL){
113: np->nref = np->name->nuse_s;
114: continue;
115: }
116: nops = np->nref;
117: for (opno=0; opno<nops; opno++){
118: op = np->ref[opno];
119: if (op->flags_o&O_COMPLEX || op->sym_o)
120: valcomplex( op );
121: }
122: switch( np->op){
123: case OP_BRANCH:
124: case OP_DBRA:
125: if (op->type_o==T_NORMAL &&
126: !(op->flags_o&O_COMPLEX) && op->value_o==0 ){
127: /* make jump references point right at the label node */
128: sp = op->sym_o;
129: if (sp->attr_s&S_DEF && sp->csect_s == C_TEXT){
130: np->luse = sp->where_s;
131: np->lnext = np->luse->luse;
132: np->luse->luse = np;
133: switch( np->op){
134: case OP_BRANCH: np->op = OP_JUMP; break;
135: case OP_DBRA: np->op = OP_DJMP; break;
136: }
137: freeoperand(op);
138: np->nref--;
139: continue;
140: }
141: }
142: break;
143: case OP_MOVEM:
144: /* try to fix up register use mask */
145: np->ruse = addmask( np->ruse, movemmask( np->subop, RMASK, np->ref ));
146: np->rset = addmask( np->rset, movemmask( np->subop, WMASK, np->ref ));
147: break;
148: case OP_MOVE:
149: /*
150: * look for set pattern:
151: * movw pc@(6,d?:w),d0
152: * jmp pc@(2,d0:w)
153: * Lnnn:
154: * .word Lyyy-Lnnn
155: * : :
156: * : :
157: * This is a C-style switch.
158: * When we find one of these, we want to treat it specially,
159: * so that flow-analysis will recognize it as a multi-way
160: * branch, and not as an unknown branch. So:
161: * Make the jmp instruction a OP_JUMP, JIND op/subop;
162: * Make the .word pseudoops OP_CSWITCH, and make them
163: * reference Lyyy like branches reference their labels.
164: */
165: /* make sure we recognize the set pattern */
166: if (np->subop!=SUBOP_W
167: || (op=np->ref[0])->type_o!= T_INDEX || op->reg_o != PCREG
168: || op->disp_o!=6 || op->value_o>=A0REG
169: || (op=np->ref[1])->type_o!= T_REG || op->value_o != D0REG)
170: break;
171: np = np->forw;
172: if (np->op!=OP_BRANCH || (op=np->ref[0])->type_o!=T_INDEX
173: || op->reg_o!=PCREG || op->disp_o!=2 || op->value_o!=D0REG
174: || op->flags_o!=(O_WINDEX|O_PREINDEX) )
175: break;
176: /* following operand must be label */
177: if (np->forw->op!=OP_LABEL)
178: break;
179: /* all looks good: fiddle the jmp instruction */
180: np->op = OP_JUMP;
181: np->subop = JIND;
182: freeoperand( op );
183: newreference( np->forw, np);
184: np->nref=0;
185: np = np->forw;
186: np->nref += np->name->nuse_s;
187: np= np->forw;
188: while (np->op==OP_WORD){
189: int i;
190: register NODE *csw;
191: NODE *next;
192: np->op = OP_CSWITCH;
193: next = np->forw;
194: for (i=0; i<np->nref; i++){
195: op = np->ref[i];
196: if (!(op->flags_o&O_COMPLEX)) continue; /* trouble */
197: /* CSWITCH can handle only one operand */
198: if (i>0){
199: /* this will never happen */
200: csw = new();
201: csw->back = next->back;
202: csw->back->forw = next->back = csw;
203: csw->forw=next;
204: csw->op = OP_CSWITCH;
205: csw->instr = np->instr;
206: csw->nref = 0;
207: } else {
208: csw = np;
209: }
210: tp = (struct optree *)op->sym_o;
211: freeoperand( tp->right_t );
212: csw->luse = tp->left_t->sym_o->where_s;
213: csw->lnext = csw->luse->luse;
214: csw->luse->luse = csw;
215: freeoperand( tp->left_t );
216: freetree( tp );
217: }
218: np->nref = 0;
219: np = next;
220: }
221: np=np->back; /* so the for-loop increment will do the right thing */
222: break;
223: }
224: }
225: if (first.forw != first.back){
226: /*
227: * if this routine is non-empty, then we want to make sure that
228: * its entry-point has at least one reference. Most routines get
229: * this through the .globl pseudo-op, but class static routine
230: * will not. Thus we make sure here.
231: */
232: for (np=first.forw; np != &first ; np=np->forw )
233: if (np->op == OP_LABEL ){
234: np->nref++;
235: break;
236: }
237: }
238: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.