![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genmore.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / ccom / vax|
Return to genmore.c CVS log | Up to [Research Unix] / researchv10dc / cmd / ccom / vax |
1.1 root 1: #include "gencode.h"
2: char *jeq = "jeql";
3: char *jne = "jneq";
4: char *jgt = "jgtr";
5: char *jge = "jgeq";
6: char *jlt = "jlss";
7: char *jle = "jleq";
8: char *jugt = "jgtru";
9: char *juge = "jgequ";
10: char *jult = "jlssu";
11: char *jule = "jlequ";
12: mnod *gimmemnod();
13:
14: char prbuf[10*1024];
15: extern int bothdebug, nosharp;
16: #define NBUF 256 /* must fit in an unsigned char */
17: char bufs[NBUF][BUF], *buf;
18: char *bufend = (char *)bufs + sizeof(bufs);
19: pr(fmt, list)
20: char *fmt; long list;
21: { char *n;
22: char *sprintxl();
23: nosharp = !bothdebug;
24: prptr = sprintxl(n=prptr, fmt, &list);
25: if(prptr > prbuf + sizeof(prbuf))
26: cerror("prbuf overflow");
27: nosharp = 0;
28: }
29:
30: outpr()
31: {
32: *prptr = 0;
33: printbuf(prbuf, prptr-prbuf);
34: }
35:
36: ret
37: checksize(p, s, regmask)
38: mnod *p;
39: ret s;
40: { ret t;
41: if(p->type != Tdouble)
42: return(s);
43: regmask |= s.regmask;
44: t = allocreg(p, regmask);
45: return(t);
46: }
47:
48: gimmetemp(n)
49: {
50: return(freetemp(n)/8 - maxboff/SZCHAR);
51: }
52:
53: commutes(op)
54: {
55: switch(op) {
56: default:
57: cerror("unexpected op in commutes");
58: case Plus: case Mul: case Or: case Xor: case And:
59: return(1);
60: case Minus: case Div: case Mod:
61: return(0);
62: }
63: }
64:
65: strshift(s, n)
66: char *s;
67: { int i, j;
68: i = strlen(s);
69: if(n > 0)
70: for(j = i; j >= 0; j--)
71: s[j + n] = s[j];
72: else
73: for(j = -n; j <= i; j++)
74: s[j + n] = s[j];
75: }
76:
77: ret
78: tostack()
79: { ret s;
80: sprintx(buf, "-(sp)");
81: done(s, 0, 0);
82: }
83:
84: char *
85: genjbc(n)
86: {
87: if(n == EQ)
88: return("jbc");
89: if(n == NE)
90: return("jbs");
91: cerror("impossible jmp mask type");
92: return("jweird");
93: }
94:
95: char *
96: genjmp(n)
97: {
98: switch(n) {
99: default: cerror("impossible jmp type"); return("jweird");
100: case EQ: return(jeq);
101: case NE: return(jne);
102: case GT: return(jgt);
103: case GE: return(jge);
104: case LT: return(jlt);
105: case LE: return(jle);
106: case UGT: return(jugt);
107: case UGE: return(juge);
108: case ULT: return(jult);
109: case ULE: return(jule);
110: }
111: }
112:
113: pow2(n)
114: { int i;
115: if(n & (n-1))
116: return(-1);
117: for(i = 0; i < 32; i++) /* good old vax */
118: if(n & (1 << i))
119: return(i);
120: return(-1); /* can't happen */
121: }
122:
123: ret
124: indirit(s)
125: ret s;
126: {
127: if(s.flag & ISREG) {
128: strcat(str(s), ")");
129: strshift(str(s), 1);
130: str(s)[0] = '(';
131: return(s);
132: }
133: if(s.flag & CANINDIR) {
134: strshift(str(s), 1);
135: str(s)[0] = '*';
136: return(s);
137: }
138: if(str(s)[0] == '(') { /* (r3)[r11] */
139: strshift(str(s), 1);
140: str(s)[0] = '*';
141: return(s);
142: }
143: if(str(s)[0] == '$') { /* an icon for structure returns */
144: strshift(str(s), -1);
145: return(s);
146: }
147: debugpr("# FAIL ");
148: s.flag = FAIL;
149: return(s);
150: }
151:
152: ret /* unseal the seals for Stasg */
153: addrsimp(a, b)
154: ret a, b;
155: { extern char *index();
156: char *p;
157: if(str(b)[0] == '(') { /* posit register */
158: reg:
159: strshift(str(b), -1);
160: *index(str(b), ')') = 0;
161: return(b);
162: }
163: if(str(a)[0] == '(') { /* posit register */
164: b = a;
165: goto reg;
166: }
167: if(str(b)[0] == '_') { /* posit name of struct */
168: name:
169: pr("#\tmoval\t%s,r0\n", str(b));
170: b.regmask = 1;
171: b.flag = ISREG|SCRATCH;
172: strcpy(str(b), "r0"); /* arrrrrgh */
173: return(b);
174: }
175: if(str(a)[0] == '_') {
176: b = a;
177: goto name;
178: }
179: if(str(b)[0] == '*') {
180: unstar:
181: p = index(str(b), '+');
182: if(!p)
183: p = index(str(b), '-');
184: if(p && (*(p+1) == 0 || *(p+1) == '('))
185: goto bad;
186: strshift(str(b), -1);
187: return(b);
188: }
189: if(str(a)[0] == '*') {
190: b = a;
191: goto unstar;
192: }
193: if(str(b)[0] == 'L') {
194: label:
195: strshift(str(b), 1);
196: str(b)[0] = '&';
197: return(b);
198: }
199: if(str(a)[0] == 'L') {
200: b = a;
201: goto label;
202: }
203: bad:
204: cerror("(addrsimp) rewrite struct asg");
205: }
206:
207: ret
208: simpler(a, b) /* returns b (as dest) preferentially */
209: ret a, b;
210: {
211: if(b.flag & ISREG)
212: return(b);
213: if(a.flag & ISREG)
214: return(a);
215: if(b.flag & SCRATCH)
216: return(b);
217: if(a.flag & SCRATCH)
218: return(a);
219: if(!(b.flag & INDEX))
220: return(b);
221: if(!(a.flag & INDEX))
222: return(a);
223: /* disallow *p++ = *q++ but not p[i]=q[i]*/
224: if(!index(str(b), '-') && !index(str(b), '+'))
225: return(b);
226: if(!index(str(a), '-') && !index(str(a), '+'))
227: return(a);
228: b.flag |= USED;
229: return(b);
230: }
231:
232: hasqnode(p)
233: mnod *p;
234: {
235: if(p->op == Asg && p->left->op == Qnode) {
236: return(1);
237: }
238: if(1) {
239: return(0);
240: }
241: switch(p->op) {
242: default:
243: cerror("hasqnode\n");
244: case Andeq: case And: case Cmp: case Comop: case Decr:
245: case Diveq: case Div: case Xoreq: case Xor:
246: case Incr: case Lseq: case Ls: case Minuseq: case Minus:
247: case Modeq: case Mod: case Muleq: case Mul: case Oreq:
248: case Or: case Pluseq: case Plus: case Rseq: case Rs:
249: case Asg: case Cm:
250: case Call: case Stcall:
251: case Stasg:
252: return(hasqnode(p->left) || hasqnode(p->right));
253: case Compl: case Conv: case Genbr: case Genlab:
254: case Genubr: case Star: case Addr: case Ucall:
255: case Uminus: case Ustcall: case Init: case Funarg:
256: case Fld:case Starg:
257: return(hasqnode(p->left));
258: case Auto: case Reg: case Name: case Param: case Icon:
259: case Snode: case Rnode:
260: return(0);
261: case Qnode:
262: return(1);
263: }
264: }
265:
266: mnod *
267: copytree(p)
268: NODE *p;
269: { mnod *a, *b, *c;
270: c = gimmemnod();
271: switch(p->in.op) {
272: case ASG AND: case AND: case CMP: case COMOP: case DECR:
273: case ASG DIV: case DIV: case ASG ER: case ER:
274: case INCR: case ASG LS: case LS: case ASG MINUS: case MINUS:
275: case ASG MOD: case MOD: case ASG MUL: case MUL: case ASG OR:
276: case OR: case ASG PLUS: case PLUS: case ASG RS: case RS:
277: case ASSIGN: case CM:
278: a = copytree(p->in.left);
279: b = copytree(p->in.right);
280: c->left = a;
281: c->right = b;
282: break;
283: case CALL: case STCALL:
284: a = copytree(p->in.left);
285: b = copytree(p->in.right);
286: c->argsize = p->stn.argsize;
287: c->left = a;
288: c->right = b;
289: break;
290: case STASG:
291: a = copytree(p->in.left);
292: b = copytree(p->in.right);
293: c->stsize = p->stn.stsize;
294: c->left = a;
295: c->right = b;
296: break;
297: case COMPL: case CONV: case GENBR: case GENLAB:
298: case GENUBR: case STAR: case UNARY AND: case UNARY CALL:
299: case UNARY MINUS: case UNARY STCALL: case INIT: case FUNARG:
300: a = copytree(p->in.left);
301: c->label = p->bn.label; /* should be separated out */
302: c->lop = p->bn.lop;
303: c->left = a;
304: break;
305: case FLD:case STARG:
306: a = copytree(p->in.left);
307: c->left = a;
308: c->rval = p->tn.rval;
309: c->stsize = p->stn.stsize;
310: break;
311: case VAUTO: case REG: case NAME: case VPARAM: case ICON:
312: case SNODE: case RNODE: case QNODE:
313: c->name = p->tn.name;
314: c->lval = p->tn.lval;
315: c->rval = p->tn.rval;
316: break;
317: }
318: switch(p->in.op) {
319: default:
320: cerror("unk op in copytree");
321: case ASG AND: c->op = Andeq; break;
322: case AND: c->op = And; break;
323: case CMP: c->op = Cmp; break;
324: case COMOP: c->op = Comop; break;
325: case DECR: c->op = Decr; break;
326: case ASG DIV: c->op = Diveq; break;
327: case DIV: c->op = Div; break;
328: case ASG ER: c->op = Xoreq; break;
329: case ER: c->op = Xor; break;
330: case INCR: c->op = Incr; break;
331: case ASG LS: c->op = Lseq; break;
332: case LS: c->op = Ls; break;
333: case ASG MINUS: c->op = Minuseq; break;
334: case MINUS: c->op = Minus; break;
335: case ASG MOD: c->op = Modeq; break;
336: case MOD: c->op = Mod; break;
337: case ASG MUL: c->op = Muleq; break;
338: case MUL: c->op = Mul; break;
339: case ASG OR: c->op = Oreq; break;
340: case OR: c->op = Or; break;
341: case ASG PLUS: c->op = Pluseq; break;
342: case PLUS: c->op = Plus; break;
343: case ASG RS: c->op = Rseq; break;
344: case RS: c->op = Rs; break;
345: case ASSIGN: c->op = Asg; break;
346: case CM: c->op = Cm; break;
347: case CALL: c->op = Call; break;
348: case STCALL: c->op = Stcall; break;
349: case STASG: c->op = Stasg; break;
350: case COMPL: c->op = Compl; break;
351: case CONV: c->op = Conv; break;
352: case GENBR: c->op = Genbr; break;
353: case GENLAB: c->op = Genlab; break;
354: case GENUBR: c->op = Genubr; break;
355: case STAR: c->op = Star; break;
356: case UNARY AND: c->op = Addr; break;
357: case UNARY CALL: c->op = Ucall; break;
358: case UNARY MINUS: c->op = Uminus; break;
359: case UNARY STCALL: c->op = Ustcall; break;
360: case INIT: c->op = Init; break;
361: case FUNARG: c->op = Funarg; break;
362: case FLD: c->op = Fld; break;
363: case STARG: c->op = Starg; break;
364: case VAUTO: c->op = Auto; break;
365: case REG: c->op = Reg; break;
366: case NAME: c->op = Name; break;
367: case VPARAM: c->op = Param; break;
368: case ICON: c->op = Icon; break;
369: case SNODE: c->op = Snode; break;
370: case QNODE: c->op = Qnode; break;
371: case RNODE: c->op = Rnode; break;
372: }
373: switch(p->in.type) {
374: default:
375: cerror("incomprehensible type");
376: case TCHAR: c->type = Tchar; break;
377: case TUCHAR: c->type = Tuchar; break;
378: case TSHORT: c->type = Tshort; break;
379: case TUSHORT: c->type = Tushort; break;
380: case TINT: c->type = Tint; break;
381: case TUNSIGNED: c->type = Tuint; break;
382: case TLONG: c->type = Tlong; break;
383: case TULONG: c->type = Tulong; break;
384: case TPOINT: c->type = Tpoint; break;
385: case TFLOAT: c->type = Tfloat; break;
386: case TDOUBLE: c->type = Tdouble; break;
387: case TSTRUCT: c->type = Tstruct; break;
388: case TVOID: c->type = Tvoid; break;
389: }
390: }
391:
392: /* does p contain an asgop or Incr (or could it be evaluated twice) */
393: sideffects(p)
394: mnod *p;
395: {
396: switch(p->op) {
397: case Andeq: case Decr: case Diveq: case Xoreq: case Incr:
398: case Lseq: case Minuseq:case Modeq: case Muleq: case Oreq:
399: case Pluseq: case Rseq: case Call: case Stcall: case Ucall:
400: return(1);
401: case And: case Cmp: case Comop: case Div: case Xor:
402: case Ls: case Minus: case Mod: case Mul:
403: case Or: case Plus: case Rs: case Asg: case Cm: case Stasg:
404: return(sideffects(p->left) || sideffects(p->right));
405: case Compl: case Conv: case Genbr: case Genlab:
406: case Genubr: case Star: case Addr:
407: case Uminus: case Ustcall: case Init: case Funarg:
408: case Fld: case Starg:
409: return(sideffects(p->left));
410: case Auto: case Reg: case Name: case Param: case Icon:
411: case Snode: case Rnode: case Qnode:
412: return(0);
413: default:
414: cerror("unk mnod in sideffects");
415: }
416: }
417: /* to make up for pointless 9th edition name change */
418: char *
419: index(s, c)
420: char *s;
421: {
422: return(strchr(s, c));
423: }
424:
425: char *
426: rindex(s, c)
427: {
428: return(strrchr(s, c));
429: }
430:
431: overr()
432: {
433: cerror("expression too complicated");
434: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.