![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 7.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests|
Return to 7.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests |
1.1 root 1: /* local2.c */
2: extern struct _iobuf {
3: int _cnt;
4: char *_ptr;
5: char *_base;
6: short _flag;
7: char _file;
8: } _iob[20];
9: struct _iobuf *fopen();
10: struct _iobuf *fdopen();
11: struct _iobuf *freopen();
12: long ftell();
13: char *fgets();
14: char *hash();
15: char *savestr();
16: char *tstr();
17: extern int tstrused;
18: extern char *tstrbuf[];
19: extern char **curtstr;
20: extern int nerrors;
21: typedef union ndu NODE;
22: typedef unsigned int TWORD;
23: typedef long CONSZ;
24:
25:
26: extern int dope[];
27: extern char *opst[];
28:
29: union ndu {
30: struct {
31: int op;
32: int goal;
33: TWORD type;
34: int cst[(6+4)];
35: char * name;
36: char pad[8 -sizeof(char *)];
37: NODE *left;
38: NODE *right;
39: }in;
40:
41: struct {
42: int op;
43: int goal;
44: TWORD type;
45: int cst[(6+4)];
46: char * name;
47: char pad[8 -sizeof(char *)];
48: CONSZ lval;
49: int rval;
50: }tn;
51:
52: struct {
53: int op;
54: int goal;
55: TWORD type;
56: int cst[(6+4)];
57: int label;
58: int lop;
59: }bn;
60: struct {
61: int op;
62: int goal;
63: TWORD type;
64: int cst[(6+4)];
65: int stsize;
66: short stalign;
67: short argsize;
68: }stn;
69: struct {
70: int op;
71: int goal;
72: TWORD type;
73: int cdim;
74: int csiz;
75: }fn;
76:
77: struct {
78:
79: int op;
80: int goal;
81: TWORD type;
82: int cdim;
83: int csiz;
84: double dval;
85: }fpn;
86: };
87:
88:
89:
90:
91:
92:
93:
94:
95: extern int busy[];
96: extern NODE node[];
97: typedef struct shape SHAPE;
98:
99: extern struct shape {
100: int op;
101: SHAPE *sl;
102: SHAPE *sr;
103: int sh;
104: int sc;
105: } shapes[];
106: extern SHAPE *pshape[];
107: typedef struct optab OPTAB;
108: struct optab {
109: int op;
110: int tyop;
111: OPTAB *nextop;
112: SHAPE **lshape;
113: int ltype;
114: SHAPE **rshape;
115: int rtype;
116: int needs;
117: int rewrite;
118: char *cstring;
119: int cost;
120: int lcount;
121: int rcount;
122: int stinline;
123: };
124: extern OPTAB
125: *match(),
126: *ophead[],
127: table[];
128: extern NODE resc[];
129: extern int tmpoff;
130: extern int maxboff;
131: extern int maxtemp;
132: extern int maxarg;
133: extern int ftnno;
134: extern int sideff;
135: extern NODE
136: *talloc(),
137: *ind2type(),
138: *tcopy(),
139: *getadr(),
140: *getlr();
141: extern CONSZ rdin();
142: extern char *rnames[];
143: extern int lineno;
144: extern char ftitle[];
145: extern int fldshf, fldsz;
146: extern int lflag, udebug, e2debug, odebug, rdebug, radebug, sdebug;
147: extern int fast;
148:
149:
150:
151:
152: typedef struct inst INST;
153: struct inst {
154: NODE *p;
155: OPTAB *q;
156: int goal;
157: };
158: extern INST inst[300];
159: extern nins;
160:
161:
162: typedef SHAPE *SHTABLE[2][20];
163: extern SHTABLE sha;
164: eobl2()
165: {
166: }
167: char *
168: exname( ix )
169: char *ix;
170: {
171:
172: static char text[100];
173: if( ix == 0 ) cerror("no name in exname");
174: sprintf( text, "_%s", ix );
175: return( text );
176: }
177: lineid( l, fn )
178: int l;
179: char *fn;
180: {
181: extern int gdebug;
182:
183: printf( "# line %d, file %s\n", l, fn );
184: }
185: deflab( n )
186: int n;
187: {
188: printf( "L%d:\n", n );
189: }
190: genubr( n )
191: int n;
192: {
193:
194: printf( " jbr L%d\n", n );
195: }
196: genret( s, l, n )
197: int s, l, n;
198: {
199:
200:
201: deflab(n);
202: if( s ) printf( " movab L%d,r0\n", l );
203: dbfunret();
204: printf( " ret\n" );
205: }
206: defalign(n)
207: int n;
208: {
209:
210: if( n % 8 ) cerror( "funny alignment: %d", n );
211: else n /= 8;
212: if( n == 1 ) return;
213: else if( n==2 ) n=1;
214: else if( n==4 ) n=2;
215: else cerror( "funny alignment: %d", n );
216: printf( " .align %d\n", n );
217: }
218: char *locnames[] = {
219:
220: " .text\n",
221: " .data\n",
222: " .data\n",
223: " .data 2\n",
224: " .data 1\n",
225: };
226: bycode( t, i )
227: int t, i;
228: {
229:
230: i &= 07;
231: if( t < 0 )
232: {
233: if( i != 0 ) printf("\n");
234: }
235: else
236: {
237: if( i == 0 ) printf( "\n .byte " );
238: else printf(",");
239: printf("0x%x", t);
240: }
241: }
242: genshort( s )
243: short s;
244: {
245:
246: printf( " .short %d\n", (short) s );
247: }
248: genlong( l )
249: long l;
250: {
251:
252: printf( " .long 0x%lx\n", l );
253: }
254: char *
255: rnames[]= {
256: "r0", "r1",
257: "r2", "r3", "r4",
258: "r5", "r6", "r7", "r8", "r9", "r10", "r11",
259: "ap", "fp", "sp", "pc"
260: };
261: zzzcode( p, ppc, q )
262: NODE *p; char **ppc; OPTAB *q;
263: {
264: register c;
265: switch( c= *++(*ppc) )
266: {
267: case 'I':
268: cbgen( p->bn.lop, p->bn.label, c );
269: return;
270: case 'k':
271: printf("$%ld", ~p->in.right->tn.lval);
272: return;
273: case 'c':
274:
275: printf( "$%d", p->stn.argsize/32);
276: return;
277: case 'U':
278: printf("$%d", 32 - p->in.right->tn.lval );
279: return;
280: case 'T':
281: printf("$%d", p->stn.stsize/8);
282: break;
283: case 'M':
284: staradr( p->in.right );
285: break;
286: case 'S':
287: {
288: register NODE *l, *r;
289: register size;
290: if( p->in.op == 98 )
291: {
292: l = p->in.left;
293: r = p->in.right;
294: }
295: else if( p->in.op == 99 )
296: {
297: r = p->in.left;
298: }
299: else cerror( "STASG bad" );
300: size = p->stn.stsize/8;
301: if( size <= 0 || size > 65535 )
302: cerror("structure size <0=0 or >65535");
303: switch(size)
304: {
305: case 1:
306: printf(" movb ");
307: break;
308: case 2:
309: printf(" movw ");
310: break;
311: case 4:
312: printf(" movl ");
313: break;
314: case 8:
315: printf(" movq ");
316: break;
317: default:
318: printf(" movc3 $%d,", size);
319: break;
320: }
321: staradr( r );
322: printf(",");
323: if( p->in.op == 99 ) printf( "(sp)" );
324: else staradr( l );
325: printf("\n");
326: }
327: break;
328: default:
329: cerror( "illegal zzzcode" );
330: }
331: }
332: staradr( p )
333: NODE *p;
334: {
335: NODE *pp;
336: pp = talloc();
337: pp->in.op = (2+ 11);
338: pp->in.left = p;
339: upput( pp );
340: pp->in.op = 97;
341: }
342: conput( p )
343: register NODE *p;
344: {
345: switch( p->in.op )
346: {
347: case 4:
348: acon( p );
349: return;
350: case 94:
351: printf( "%s", rnames[p->tn.rval] );
352: return;
353: default:
354: cerror( "illegal conput" );
355: }
356: }
357: insput( p )
358: NODE *p;
359: {
360: cerror( "insput" );
361: }
362: upput( p )
363: NODE *p;
364: {
365: register NODE *r, *l, *pp;
366: register o;
367: pp = ( (2+ 11) == p->in.op ) ? p->in.left : p ;
368: o = pp->in.op;
369: if( o==2 || o==(2+ 11) || o==95 || o==116 || o==117 )
370: {
371: printf( "*" );
372: adrput(pp);
373: return;
374: }
375: if( o==4 )
376: {
377: acon( pp );
378: sideff = 0;
379: return;
380: }
381: if( o == 6 )
382: {
383: r = pp->in.right;
384: l = pp->in.left;
385: if( l->in.op == 94 && r->in.op == 4 )
386: {
387: acon( r );
388: pp = pp->in.left;
389: }
390: else
391: {
392:
393:
394: if( l->in.op == 2+ 14 )
395: {
396: adrput( l->in.left );
397: l = r;
398: }
399: else
400: {
401: p->in.left = r;
402: adrput( p );
403: p->in.left = pp;
404: }
405: if( l->in.op == 64 ) l = l->in.left;
406: if( l->in.op != 94 ) cerror("illegal address");
407: printf( "[%s]", rnames[l->tn.rval] );
408: return;
409: }
410: }
411: else if( o == 8 )
412: {
413: r = pp->in.right;
414: if( r->tn.op != 4 || r->tn.name ) cerror("illegal address");
415: r->tn.lval = -r->tn.lval;
416: acon( r );
417: r->tn.lval = -r->tn.lval;
418: pp = pp->in.left;
419: }
420: else if( o == 1+ 8 )
421: {
422: r = pp->in.right;
423: if( r->tn.op != 4 ) cerror("illegal address");
424: r = pp->in.left;
425: if( r->tn.op != 94 ) cerror("illegal address");
426:
427: printf( "-(%s)", rnames[r->tn.rval] );
428: sideff = 1;
429: return;
430: }
431: else if( o == 78 )
432: {
433: r = pp->in.right;
434: if( r->tn.op != 4 ) cerror("illegal address");
435: r = pp->in.left;
436: if( r->tn.op != 94 ) cerror("illegal address");
437: if( sideff ) printf( "(%s)+", rnames[r->tn.rval] );
438: else printf( "(%s)", rnames[r->tn.rval] );
439: return;
440: }
441: if( pp->tn.op != 94 ) cerror("illegal address");
442: printf( "(%s)", rnames[pp->tn.rval] );
443: return;
444: }
445: adrput( p )
446: register NODE *p;
447: {
448:
449: register o;
450: while( (o=p->in.op) == 103 || o==104 )
451: {
452: p = p->in.left;
453: o = p->in.op;
454: }
455: switch( o )
456: {
457: case 2:
458: acon( p );
459: sideff = 0;
460: return;
461: case 4:
462:
463: printf( "$" );
464: acon( p );
465: sideff = 0;
466: return;
467: case 94:
468: printf( "%s", rnames[p->tn.rval] );
469: sideff = 0;
470: return;
471: case (2+ 11):
472: upput( p );
473: return;
474: case 95:
475: sideff = 0;
476: printf( "%ld(fp)", p->tn.lval - maxboff );
477: return;
478: case 116:
479: sideff = 0;
480: printf( "%ld(fp)", p->tn.lval );
481: return;
482: case 117:
483: sideff = 0;
484: printf( "%ld(ap)", p->tn.lval );
485: return;
486: default:
487: cerror( "illegal address" );
488: return;
489: }
490: }
491: acon(p)
492: NODE *p;
493: {
494: if( p->tn.name == 0 )
495: {
496: printf( "%ld", p->tn.lval);
497: }
498: else if( p->tn.lval == 0 )
499: {
500: printf( "%s", p->tn.name );
501: }
502: else
503: {
504: printf( "%s+%ld", p->tn.name, p->tn.lval );
505: }
506: }
507: char *
508: ccbranches[] = {
509: " jeql L%d\n",
510: " jneq L%d\n",
511: " jleq L%d\n",
512: " jlss L%d\n",
513: " jgeq L%d\n",
514: " jgtr L%d\n",
515: " jlequ L%d\n",
516: " jlssu L%d\n",
517: " jgequ L%d\n",
518: " jgtru L%d\n",
519: };
520: cbgen( o, lab, mode )
521: int o, lab, mode;
522: {
523: if( !o ) printf( " jbr L%d\n", lab );
524: else if( o > 89 ) cerror( "bad conditional branch: %s", opst[o] );
525: else printf( ccbranches[o-80], lab );
526: }
527: special()
528: {
529: cerror("reached special");
530: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.