![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to util.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 util.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / c2 |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)util.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: int
13: cntbits( vl )
14: {
15: register unsigned long v = vl;
16: register n;
17: n = 0;
18: do{
19: n += v&1;
20: }while( v>>=1 );
21: return n;
22: }
23:
24:
25: /* can this address operand be incremented by n? */
26: int
27: incraddr( o, n )
28: register struct oper *o;
29: {
30: /*
31: * Because we don't want to mess up potential device drivers,
32: * we must be very prudent here. Too bad.
33: * We can only do this to a memory location if its an offset from
34: * the stack or frame pointers. Those had better not point to
35: * device registers, damn them.
36: * We must also (I fear) be careful around immediates that are still
37: * relocatable.
38: */
39: extern int Xperimental;
40:
41: switch (o->type_o){
42: case T_IMMED:
43: if (n!=0 && o->sym_o!=NULL) return 1;
44: return 0;
45: case T_REG:
46: if (o->value_o >= A0REG && n != 0 ) return 1;
47: else return 0;
48: case T_DISPL:
49: if (!Xperimental)
50: if ( (o->reg_o < (fortranprog?(A0REG+4):FPREG))
51: || (n+o->value_o > 0x7fff) ) return 1;
52: o->value_o += n;
53: return 0;
54: case T_DEFER:
55: if (!Xperimental)
56: if (o->value_o < (fortranprog?(A0REG+4):FPREG)) return 1;
57: if (n != 0){
58: o->reg_o = o->value_o;
59: o->value_o = n;
60: o->sym_o = 0;
61: o->type_o = T_DISPL;
62: }
63: return 0;
64: case T_INDEX:
65: if (!Xperimental)
66: if (o->reg_o < (fortranprog?(A0REG+4):FPREG)) return 1;
67: if (!Xperimental)
68: if (o->disp_o+n > 0x7f) return 1;
69: if (o->flags_o & O_INDIRECT)
70: o->disp2_o += n;
71: else
72: o->disp_o += n;
73: return 0;
74: }
75: /* default falls through here */
76: return 1; /* no way */
77: }
78:
79: /* can this operand reference be deleted? */
80: int
81: deladdr( o )
82: struct oper *o;
83: {
84: return !incraddr( o, 0) ;
85: }
86:
87: /* compare operands, instructions */
88:
89: int
90: sameops( op1, op2)
91: register struct oper *op1, *op2;
92: {
93: # define SAME( a ) if (op1->a != op2->a) return 0
94: /* are these two operands the same? */
95: SAME( type_o );
96: SAME( flags_o );
97: switch (op1->type_o){
98: case T_IMMED:
99: if ( op1->flags_o & O_FLOAT ){
100: SAME( fval_o );
101: break;
102: }
103: /* fall through */
104: case T_NORMAL:
105: case T_ABSS:
106: case T_ABSL:
107: SAME( sym_o );
108: /* fall through */
109: case T_REG:
110: case T_DEFER:
111: case T_POSTINC:
112: case T_PREDEC:
113: SAME( value_o );
114: break;
115: case T_INDEX:
116: SAME( disp_o );
117: if (op1->flags_o & O_INDIRECT){
118: SAME( disp2_o );
119: SAME( sym2_o );
120: }
121: if (op1->flags_o & (O_PREINDEX|O_POSTINDEX)){
122: SAME( scale_o );
123: }
124: /* fall through */
125: case T_DISPL:
126: SAME( sym_o );
127: /* fall through */
128: case T_REGPAIR:
129: SAME( value_o );
130: SAME( reg_o );
131: break;
132: default: return 0;
133: }
134: if (op1->flags_o & O_BFLD){
135: SAME( bfoffset_o );
136: SAME( bfwidth_o );
137: }
138: return 1;
139: # undef SAME
140: }
141:
142: int
143: sameins( i1, i2 )
144: register NODE *i1, *i2;
145: {
146: register int refs, nrefs;
147:
148: if (!ISINSTRUC( i1->op) )
149: sys_error("sameins: got non-instruction as comperand\n");
150: if (i1->instr != i2->instr|| (nrefs=i1->nref) != i2->nref)
151: return 0;
152: for (refs=0; refs<nrefs; refs++)
153: if (!sameops( i1->ref[refs], i2->ref[refs]) )
154: return 0;
155: return 1;
156: }
157:
158:
159: extern void printmask();
160:
161: /* flush an instruction directly to stdout */
162: putinstr( ip )
163: struct ins_bkt *ip;
164: {
165: register i,n;
166: printf(" %s", ip->text_i);
167: if (n = numops ){
168: putchar('\t');
169: printoperand( &operands[0] );
170: for (i=1; i<n; i++){
171: putchar(',');
172: printoperand( &operands[i] );
173: }
174: }
175: putchar('\n');
176: }
177:
178:
179: void
180: dumpnode( np, verbose )
181: register NODE *np;
182: {
183: register i,n;
184: struct sym_bkt *switchlabel;
185:
186: switch (np->op){
187: case OP_LABEL:
188: if (verbose)
189: printf("%s: | referenced %d times",
190: np->name->name_s, np->nref );
191: else
192: printf("%s:", np->name->name_s );
193: break;
194: case OP_COMMENT:
195: printf("|%s", (char *)(np->ref[0]));
196: break;
197: default:
198: printf(" %s", np->instr->text_i);
199: if (n = np->nref ){
200: putchar('\t');
201: printoperand( np->ref[0] );
202: for (i=1; i<n; i++){
203: putchar(',');
204: printoperand( np->ref[i] );
205: }
206: }
207: if ( np->op==OP_JUMP || np->op==OP_DJMP ){
208: if (np->subop==JIND){
209: fputs("\tpc@(2,d0:w)", stdout);
210: switchlabel = np->luse->name;
211: } else {
212: putchar((n)?',':'\t');
213: fputs(np->luse->name->name_s, stdout);
214: }
215: } else if (np->op==OP_CSWITCH){
216: putchar('\t');
217: fputs(np->luse->name->name_s, stdout);
218: putchar('-');
219: fputs(switchlabel->name_s, stdout);
220: }
221: break;
222: }
223: if (verbose){
224: fputs(" | ", stdout);
225: if (!emptymask(np->ruse)){
226: fputs(" reads:", stdout); printmask( np->ruse);
227: }
228: if (!emptymask(np->rset)){
229: fputs(" writes:", stdout);printmask( np->rset);
230: }
231: if (!emptymask(np->rlive)){
232: fputs(" live:", stdout); printmask( np->rlive);
233: }
234: }
235: putchar('\n');
236: }
237:
238: void
239: dumpprogram(verbose)
240: {
241: NODE *np;
242:
243: printf(" .text\n");
244: for (np=first.forw; np != &first; np = np->forw){
245: dumpnode( np, verbose );
246: }
247: }
248:
249: void
250: sortints( ip, n )
251: register int *ip;
252: register n;
253: {
254: /* sort the array of n ints. Not quick, but compact */
255: register int *np, *p;
256: register changed, temp;
257: np = ip + n - 1;
258: changed = 1;
259: while(changed){
260: changed = 0;
261: for (p = ip; p < np; p++)
262: if (*p > *(p+1) ){
263: temp = *p;
264: *p = *(p+1);
265: *(p+1) = temp;
266: changed = 1;
267: }
268: }
269: }
270:
271: void
272: xref(){
273: register NODE *p, *u;
274: int allocsize = 100, usecnt;
275: int *ip, *tp;
276: ip = (int *)malloc( allocsize * sizeof * p );
277: for (p=first.forw; p != &first; p=p->forw){
278: if (p->op==OP_LABEL){
279: fputs( p->name->name_s, stdout );
280: if (p->nref+1 > allocsize ){
281: allocsize += allocsize;
282: if (p->nref+1 > allocsize )
283: allocsize = p->nref + 5;
284: ip = (int *)realloc( ip, allocsize * sizeof * p );
285: }
286: tp = ip;
287: *tp++ = p->lineno;
288: for (usecnt = p->nref, u=p->luse; usecnt--; ){
289: if (u==NULL)
290: *tp++ = -1;
291: else {
292: *tp++ = u->lineno;
293: u = u->lnext;
294: }
295: }
296: sortints( ip, p->nref+1 );
297: putchar( ':' );
298: for ( usecnt = p->nref+1, tp=ip ; usecnt--; tp++ ){
299: if (*tp == -1)
300: fputs(" ???", stdout);
301: else
302: printf(" %3d", *tp);
303: if (*tp == p->lineno)
304: putchar('*' );
305: }
306: putchar('\n');
307: }
308: }
309: free( ip );
310: }
311:
312: /*
313: * Insert a node after another one
314: */
315: insert(p, after)
316: NODE *p;
317: NODE *after;
318: {
319: NODE *lastp;
320:
321: for (lastp = p; lastp->forw != NULL; lastp = lastp->forw)
322: ;
323: after->forw->back = lastp;
324: lastp->forw = after->forw;
325: after->forw = p;
326: p->back = after;
327: }
328:
329: #ifdef C2
330: char *
331: docomment(p)
332: register char *p;
333: {
334: extern char *c2pseudocomment();
335: NODE *n;
336:
337: if (*p != '#' && *p != '|') return p;
338: n = new();
339: n->op = OP_COMMENT;
340: n->ref[0] = (struct oper *)malloc( strlen(p) );
341: strcpy( (char *)n->ref[0], p+1 );
342: addnode( n );
343: if (strncmp(p,C2MAGIC,C2MAGICSIZE) == 0){
344: p = c2pseudocomment( p+=C2MAGICSIZE );
345: }
346: return p;
347: }
348: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.