![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to local2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax|
Return to local2.c CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax |
1.1 root 1: # include "mfile2.h"
2: /* a lot of the machine dependent parts of the second pass */
3:
4: char *
5: ccbranches[] = {
6: " jeql L%d\n",
7: " jneq L%d\n",
8: " jleq L%d\n",
9: " jlss L%d\n",
10: " jgeq L%d\n",
11: " jgtr L%d\n",
12: " jlequ L%d\n",
13: " jlssu L%d\n",
14: " jgequ L%d\n",
15: " jgtru L%d\n",
16: };
17:
18: cbgen( o, lab, mode )
19: int o, lab, mode;
20: { /* printf conditional and unconditional branches */
21:
22: if( !o ) printf( " jbr L%d\n", lab );
23: else if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] );
24: else printf( ccbranches[o-EQ], lab );
25: }
26:
27: zzzcode( p, ppc, q )
28: NODE *p; char **ppc; OPTAB *q;
29: {
30: register c;
31:
32: switch( c= *++(*ppc) )
33: {
34: case 'I':
35: cbgen( p->bn.lop, p->bn.label, c );
36: return;
37:
38:
39: case 'k': /* complement mask for bit instr */
40: printf("$%ld", ~p->in.right->tn.lval);
41: return;
42:
43: case 'c':
44: /* argument size */
45: printf( "$%d", p->stn.argsize/SZINT);
46: return;
47:
48: case 'U': /* 32 - n, for unsigned right shifts */
49: printf("$%d", 32 - p->in.right->tn.lval );
50: return;
51:
52: case 'T': /* structure length for arguments */
53: printf("$%d", p->stn.stsize / SZCHAR);
54: break;
55:
56: case 'M': /* move address */
57: staradr( p->in.right );
58: break;
59:
60: case 'S': /* structure assignment */
61: {
62: register NODE *l, *r;
63: register size;
64:
65: if( p->in.op == STASG )
66: {
67: l = p->in.left;
68: r = p->in.right;
69: }
70: else if( p->in.op == STARG )
71: { /* store an arg */
72: r = p->in.left;
73: }
74: else cerror( "STASG bad" );
75:
76: size = p->stn.stsize/SZCHAR;
77:
78: if( size <= 0 || size > 65535 )
79: cerror("structure size <0=0 or >65535");
80:
81: switch(size)
82: {
83: case 1:
84: printf(" movb ");
85: break;
86: case 2:
87: printf(" movw ");
88: break;
89: case 4:
90: printf(" movl ");
91: break;
92: case 8:
93: printf(" movq ");
94: break;
95: default:
96: printf(" movc3 $%d,", size);
97: break;
98: }
99: staradr( r );
100: printf(",");
101: if( p->in.op == STARG ) printf( "(sp)" );
102: else staradr( l );
103: printf("\n");
104:
105: }
106: break;
107:
108: default:
109: cerror( "illegal zzzcode" );
110: }
111: }
112:
113: staradr( p )
114: NODE *p;
115: {
116: NODE *pp;
117: pp = talloc();
118: pp->in.op = STAR;
119: pp->in.left = p;
120: upput( pp );
121: pp->in.op = FREE;
122: }
123:
124: conput( p )
125: register NODE *p;
126: {
127: switch( p->in.op )
128: {
129: case ICON:
130: acon( p );
131: return;
132:
133: case REG:
134: printf( "%s", rnames[p->tn.rval] );
135: return;
136:
137: default:
138: cerror( "illegal conput" );
139: }
140: }
141:
142: insput( p )
143: NODE *p;
144: {
145: cerror( "insput" );
146: }
147:
148: /* new use for an old routine
149: * upput now puts out an indirect address ( STAR node )
150: * equivalent to the old case STAR in adrput
151: * as upput, we can now get to this routine directly from the
152: * templates, using the U symbol
153: */
154:
155: int sideff;
156:
157: upput( p )
158: NODE *p;
159: {
160: register NODE *r, *l, *pp;
161: register o;
162: pp = ( STAR == p->in.op ) ? p->in.left : p ;
163: o = pp->in.op;
164: if( o==NAME || o==STAR || o==TEMP || o==VAUTO || o==VPARAM )
165: {
166: printf( "*" );
167: adrput(pp);
168: return;
169: }
170: if( o==ICON )
171: {
172: acon( pp );
173: sideff = 0;
174: return;
175: }
176: if( o == PLUS )
177: {
178: r = pp->in.right;
179: l = pp->in.left;
180: if( l->in.op == REG && r->in.op == ICON )
181: {
182: acon( r );
183: pp = pp->in.left;
184: }
185: else
186: {
187: /* index mode (shudder) */
188: /* save the index, rewrite p to point to
189: /* the rest, call adrput recursively, and
190: /* then tack on the index */
191: if( l->in.op == UNARY AND )
192: { /* double index */
193: adrput( l->in.left );
194: l = r;
195: }
196: else
197: {
198: p->in.left = r;
199: adrput( p );
200: p->in.left = pp; /* back to normal */
201: }
202: if( l->in.op == LS ) l = l->in.left;
203: if( l->in.op != REG ) cerror("illegal address");
204: printf( "[%s]", rnames[l->tn.rval] );
205: return;
206: }
207: }
208: else if( o == MINUS )
209: {
210: r = pp->in.right;
211: if( r->tn.op != ICON || r->tn.name ) cerror("illegal address");
212: r->tn.lval = -r->tn.lval;
213: acon( r );
214: r->tn.lval = -r->tn.lval;
215: pp = pp->in.left;
216: }
217: else if( o == ASG MINUS )
218: {
219: r = pp->in.right;
220: if( r->tn.op != ICON ) cerror("illegal address");
221: r = pp->in.left;
222: if( r->tn.op != REG ) cerror("illegal address");
223: /* always do the side effect */
224: printf( "-(%s)", rnames[r->tn.rval] );
225: sideff = 1; /* cream it */
226: return;
227: }
228: else if( o == INCR )
229: {
230: r = pp->in.right;
231: if( r->tn.op != ICON ) cerror("illegal address");
232: r = pp->in.left;
233: if( r->tn.op != REG ) cerror("illegal address");
234: if( sideff ) printf( "(%s)+", rnames[r->tn.rval] );
235: else printf( "(%s)", rnames[r->tn.rval] );
236: return;
237: }
238: if( pp->tn.op != REG ) cerror("illegal address");
239: printf( "(%s)", rnames[pp->tn.rval] );
240: return;
241: }
242:
243: adrput( p )
244: register NODE *p;
245: {
246: /* output an address, with offsets, from p */
247: register o;
248:
249: while( (o=p->in.op) == FLD || o==CONV )
250: {
251: p = p->in.left;
252: o = p->in.op;
253: }
254: switch( o )
255: {
256: case NAME:
257: acon( p );
258: sideff = 0;
259: return;
260:
261: case ICON:
262: /* addressable value of the constant */
263: printf( "$" );
264: acon( p );
265: sideff = 0;
266: return;
267:
268: case REG:
269: printf( "%s", rnames[p->tn.rval] );
270: sideff = 0;
271: return;
272:
273: case STAR:
274: upput( p );
275: return;
276:
277: case TEMP:
278: sideff = 0;
279: printf( "%ld(fp)", p->tn.lval - maxboff / SZCHAR );
280: return;
281:
282: case VAUTO:
283: sideff = 0;
284: printf( "%ld(fp)", p->tn.lval );
285: return;
286:
287: case VPARAM:
288: sideff = 0;
289: printf( "%ld(ap)", p->tn.lval );
290: return;
291:
292: default:
293: cerror( "illegal address" );
294: return;
295: }
296: }
297:
298: acon(p)
299: NODE *p;
300: { /* print out a constant */
301:
302: if( p->tn.name == 0 )
303: { /* constant only */
304: printf( "%ld", p->tn.lval);
305: }
306: else if( p->tn.lval == 0 )
307: { /* name only */
308: printf( "%s", p->tn.name );
309: }
310: else
311: { /* name + offset */
312: printf( "%s+%ld", p->tn.name, p->tn.lval );
313: }
314: }
315:
316: special()
317: {
318: cerror("reached special");
319: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.