![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pseudos.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / gen2 / vax|
Return to pseudos.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / gen2 / vax |
1.1 root 1: /* C compiler: VAX code generator */
2:
3: #include "c.h"
4:
5: dclproto(static void address,(Symbol, Symbol, int));
6: dclproto(static void defaddress,(Symbol));
7: dclproto(static void defconst,(int, Value));
8: dclproto(static void defstring,(int, char *));
9: dclproto(static void defsymbol,(Symbol));
10: dclproto(static void doarg,(Node));
11: dclproto(static void emitspecial,(Node));
12: dclproto(static void function,(Symbol, Symbol [], Symbol [], int));
13: dclproto(static void global,(Symbol));
14: dclproto(static void import,(Symbol));
15: dclproto(static void local,(Symbol));
16: dclproto(static void progbeg,(int, char **));
17: dclproto(static void segment,(int));
18: dclproto(static void space,(int));
19:
20: #ifdef vax
21: #ifdef V9
22: dclproto(static void stabblock,(int, int, Symbol*));
23: dclproto(static void stabend,(Coordinate *, Symbol, Coordinate **, Symbol *, Symbol *));
24: dclproto(static void stabfend,(Symbol, int));
25: dclproto(static void stabinit,(char *, int, char *[]));
26: dclproto(static void stabline,(Coordinate *));
27: dclproto(static void stabsym,(Symbol));
28: dclproto(static void stabtype,(Symbol));
29: #else
30: #include <stab.h>
31: #include "stabbsd.c"
32: #define stabend 0
33: #endif
34: #endif
35:
36: dclproto(static void initgen,(void));
37: dclproto(static void final,(Node));
38:
39: #ifdef GEN4
40: dclproto(static unsigned emit2,(Node,Node[],short[]));
41: dclproto(static void target,(Node));
42: #endif
43:
44: Interface vaxInterface = {
45: "vax",
46: 1, 1, 0, /* char */
47: 2, 2, 0, /* short */
48: 4, 4, 0, /* int */
49: 4, 4, 1, /* float */
50: 8, 4, 1, /* double */
51: 4, 4, 0, /* T * */
52: 0, 1, 0, /* struct */
53: 0, /* left_to_right */
54: 1, /* little_endian */
55: 0, /* jump_on_return */
56: 0, /* mulops_are_calls */
57: 1, /* compl_band */
58: 0, /* no_argb */
59: NODAG, /* no_dag */
60: address,
61: blockbeg,
62: blockend,
63: defaddress,
64: defconst,
65: defstring,
66: defsymbol,
67: 0,
68: export,
69: function,
70: gen,
71: global,
72: import,
73: local,
74: progbeg,
75: progend,
76: segment,
77: space,
78: #ifdef vax
79: stabblock, stabend, stabfend, stabinit, stabline, stabsym, stabtype,
80: #else
81: 0, 0, 0, 0, 0, 0, 0,
82: #endif
83: {".globl %s\n", 0, 0, {".text", ".data", ".data", ".text 1", ".data 2"},
84: doarg, docall, 0, 0, 0,
85: final, 0, emitspecial,
86: #ifdef GEN4
87: vax_kids, vax_ntname, vax_nts, vax_rule, vax_state, vax_string, vax_cost,
88: rules, emit2, target
89: #endif
90: }
91: };
92:
93: static Symbol d0, f0, r0, r1;
94:
95: /* address - initialize q for addressing expression p+n */
96: static void address(q, p, n) Symbol q, p; {
97: q->x.offset = p->x.offset + n;
98: if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN)
99: q->x.name = stringf("%s%s%d", p->x.name, n >= 0 ? "+" : "", n);
100: else
101: q->x.name = stringd(q->x.offset);
102: }
103:
104: static void defaddress(p) Symbol p; {
105: print(".long %s\n", p->x.name);
106: }
107:
108: /* defconst - define a constant */
109: static void defconst(ty, v) Value v; {
110: switch (ty) {
111: case C: print(".byte %d\n", v.uc); break;
112: case S: print(".word %d\n", v.ss); break;
113: case I: print(".long %d\n", v.i ); break;
114: case U: print(".long 0x%x\n", v.u ); break;
115: case P: print(".long 0x%x\n", v.p ); break;
116: case F:
117: if (v.f == 0.0)
118: print(".long 0x0\n");
119: else {
120: struct real r;
121: r = decode(F, v.f);
122: r.exp = (r.exp + 129)&0xff;
123: r.msb &= ~0x1ff;
124: print(".long 0x%x\n", (r.msb<<7) | (r.sign<<15) | (r.exp<<7) | (r.msb>>25));
125: }
126: break;
127: case D:
128: if (v.d == 0.0)
129: print(".long 0x0,0x0\n");
130: else {
131: unsigned u;
132: struct real r;
133: r = decode(D, v.d);
134: r.exp = (r.exp + 129)&0xff;
135: u = r.msb&~0x1ff;
136: print(".long 0x%x,", (u<<7) | (r.sign<<15) | (r.exp<<7) | (u>>25));
137: u = (r.msb<<23) | (r.lsb>>9);
138: print("0x%x\n", (u<<16) | (u>>16));
139: }
140: break;
141: default:
142: assert(0);
143: }
144: }
145:
146: static void defstring(n, s) char *s; {
147: genascii(".ascii", ".byte", n, s);
148: }
149:
150: /* defsymbol - compute and store p's back-end name */
151: static void defsymbol(p) Symbol p; {
152: if (p->scope == CONSTANTS)
153: p->x.name = p->name;
154: else if (p->scope >= LOCAL && p->sclass == STATIC)
155: p->x.name = stringf("L%d", genlabel(1));
156: else if (p->generated)
157: p->x.name = stringf("L%s", p->name);
158: else
159: p->x.name = stringf("_%s", p->name);
160: }
161:
162: /* doarg - assign offset for next ARG node */
163: static void doarg(p) Node p; {
164: assert(p);
165: assert(p->syms[0]);
166: assert(p->syms[1]);
167: p->syms[2] = intconst(mkactual(p->syms[1]->u.c.v.i, p->syms[0]->u.c.v.i, 4));
168: }
169:
170: static void emitspecial(p) Node p; {}
171:
172: /* function - generate code for a function */
173: static void function(p, caller, callee, n) Symbol p, callee[], caller[]; {
174: int i;
175:
176: initfunc(n, 4, 0);
177: for (i = 0; callee[i]; i++) {
178: assert(caller[i]);
179: callee[i]->x.offset = caller[i]->x.offset = offset;
180: callee[i]->x.name = caller[i]->x.name = stringd(offset);
181: offset = roundup(offset + caller[i]->type->size, 4);
182: getregvar(callee[i], rmap[ttob(callee[i]->type)]);
183: }
184: assert(caller[i] == 0);
185: offset = 0;
186: gencode(caller, callee);
187: mvregvars();
188: savemask[0] = usedmask[0]&eemask[0];
189: savebase[0] = 20;
190: print(".align 1\n%s:.word 0x%x\n", p->x.name, savemask[0]);
191: if (maxoffset > 0)
192: print("subl2 $%d,sp\n", maxoffset);
193: if (isstruct(freturn(p->type)))
194: print("movl r1,-4(fp)\n");
195: if (pflag) {
196: int lab = genlabel(1);
197: print("movab L%d,r0\njsb mcount\n", lab);
198: print(".data\n.align 2\nL%d: .long 0\n.text\n", lab);
199: }
200: emitcode();
201: if (glevel > 1)
202: print("ret\n");
203: }
204:
205: /* global - global id */
206: static void global(p) Symbol p; {
207: assert(p->u.seg);
208: if (p->u.seg == BSS && (p->sclass == STATIC || Aflag >= 2))
209: print(".lcomm %s,", p->x.name);
210: else if (p->u.seg == BSS)
211: print(".comm %s,", p->x.name);
212: else {
213: if (p->type->align > 1)
214: print(".align %c; ", "..1.2...3"[p->type->align]);
215: print("%s:", p->x.name);
216: }
217: }
218:
219: static void import(p) Symbol p; {}
220:
221: /* local - local */
222: static void local(p) Symbol p; {
223: if (getregvar(p, rmap[ttob(p->type)]) == 0)
224: p->x.name = stringd(mkauto(p, 4));
225: }
226:
227: /* progbeg - beginning of program */
228: static void progbeg(argc, argv) char *argv[]; {
229: nregsets = 1;
230: eemask[0] = 0xfc0;
231: tmask[0] = 0x03f;
232: vmask[0] = 0xfc0;
233: parseflags(argc, argv);
234: initgen();
235: d0 = mkregs("%d", 0, 0, 2, 3, 0, D, 0);
236: r0 = mkregs("%d", 0, 0, 1, 1, 0, I, 0);
237: f0 = mkregs("%d", 0, 0, 1, 1, 0, F, 0);
238: r1 = mkregs("%d", 1, 1, 1, 1, 0, I, 0);
239: rmap[D] = mkregs("%d", 0, 10, 2, 3, 0, D, 0);
240: rmap[F] = mkregs("%d", 0, 11, 1, 1, 0, F, 0);
241: rmap[I] = mkregs("%d", 0, 11, 1, 1, 0, I, 0);
242: rmap[C] = rmap[S] = rmap[P] = rmap[U] = rmap[I];
243: }
244:
245: static void segment(n) {
246: setseg(n);
247: }
248:
249: static void space(n) {
250: spacen(n, ".space");
251: }
252:
253: #ifndef V9
254: #include <errno.h>
255: #ifndef errno
256: extern int errno;
257: #endif
258:
259: /* strtol - interpret str as a base b number; if ptr!=0, *ptr gets updated str */
260: long strtol(str, ptr, b) char *str, **ptr; {
261: long n = 0;
262: char *s, sign = '+';
263: int d, overflow = 0;
264:
265: if (ptr)
266: *ptr = str;
267: if (b < 0 || b == 1 || b > 36)
268: return 0;
269: while (*str==' '||*str=='\f'||*str=='\n'||*str=='\r'||*str=='\t'||*str=='\v')
270: str++;
271: if (*str == '-' || *str == '+')
272: sign = *str++;
273: if (b == 0)
274: if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
275: b = 16;
276: str += 2;
277: } else if (str[0] == '0')
278: b = 8;
279: else
280: b = 10;
281: for (s = str; *str; str++) {
282: if (*str >= '0' && *str <= '9')
283: d = *str - '0';
284: else if (*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')
285: d = (*str&~040) - 'A' + 10;
286: else
287: break;
288: if (d >= b)
289: break;
290: if (n < (LONG_MIN + d)/b)
291: overflow = 1;
292: n = b*n - d;
293: }
294: if (s == str)
295: return 0;
296: if (ptr)
297: *ptr = str;
298: if (overflow || (sign == '+' && n == LONG_MIN)) {
299: errno = ERANGE;
300: return sign == '+' ? LONG_MAX : LONG_MIN;
301: }
302: return sign == '+' ? -n : n;
303: }
304: #endif
305:
306: #ifdef vax
307: #ifdef V9
308: #include <stab.h>
309: static char *currentfile; /* current file name */
310:
311: dclproto(static void emittype,(int desc, int s, Type ty, char *str));
312: dclproto(extern long time,(long *));
313:
314: /* emittype - emit p's type */
315: static void emittype(desc, s, ty, str) Type ty; char *str; {
316: ty = unqual(ty);
317: switch (ty->op) {
318: case CHAR: desc |= (ty == unsignedchar ? 12 : 2); break;
319: case SHORT: desc |= (ty == unsignedshort ? 13 : 3); break;
320: case INT: desc |= 4; break;
321: case UNSIGNED: desc |= 14; break;
322: case FLOAT: desc |= 6; break;
323: case DOUBLE: desc |= 7; break;
324: case STRUCT: case UNION: case ENUM:
325: if (ty->op == STRUCT)
326: desc |= 8;
327: else if (ty->op == UNION)
328: desc |= 9;
329: else
330: desc |= 10;
331: print("0x%x,%s\n", desc, str);
332: if (glevel > 1)
333: if (*ty->u.sym->name >= '0' && *ty->u.sym->name <= '9')
334: print(".stabs \"%s$%d.%s\",0x%x,0,0,0\n", ty->u.sym->src.file,
335: ty->u.sym->src.y, ty->u.sym->name, N_TYID);
336: else
337: print(".stabs \"%s\",0x%x,0,0,0\n", ty->u.sym->name, N_TYID);
338: return;
339: case ARRAY:
340: emittype(desc | (3<<s), s + 2, ty->type, str);
341: if (glevel > 1)
342: print(".stabn 0x%x,0,0,%d\n", N_DIM, ty->size/ty->type->size);
343: return;
344: case POINTER:
345: emittype(desc | (1<<s), s + 2, ty->type, str);
346: return;
347: case FUNCTION:
348: emittype(desc | (2<<s), s + 2, ty->type, str);
349: return;
350: case VOID: desc |= 16; break;
351: default: break;
352: }
353: print("0x%x,%s\n", desc, str);
354: }
355:
356: /* stabblock - output a stab entry for '{' or '}' at level lev */
357: static void stabblock(brace, lev, p) Symbol *p; {
358: if (brace == '}')
359: while (*p)
360: stabsym(*p++);
361: print(".stabd 0x%x,0,%d\n", brace == '{' ? N_LBRAC : N_RBRAC, lev);
362: }
363:
364: /* stabend - finalize stab output */
365: static void stabend(cp, p, cpp, sp, syms) Coordinate *cp; Symbol p, *sp, *syms; Coordinate **cpp; {
366: if (glevel && cp->file && *cp->file) {
367: segment(CODE);
368: print("Lend:.stabs \"%s\",0x%x,0,%d,Lend\n", cp->file, N_ESO, cp->y);
369: }
370: }
371:
372: /* stabfend - end of function p */
373: static void stabfend(p, line) Symbol p; {
374: int lab;
375:
376: if (glevel <= 1)
377: return;
378: lab = genlabel(1);
379: print(".stabn 0x%x,0,%d,L%d\n", N_RFUN, line, p->u.f.label);
380: print("L%d:.stabs \"%s\",0x%x,0,%d,L%d\n", lab,
381: p->name, N_EFUN, line, lab);
382: }
383:
384: /* stabinit - initialize stab output */
385: static void stabinit(file, argc, argv) char *file, *argv[]; {
386: if (file && *file) {
387: segment(CODE);
388: print("Ltext:.stabs \"%s\",0x%x,0,0,Ltext\n", file, N_SO);
389: print(".stabs \"rcc\",0x%x,0,17665,%d\n", N_VER, time(0));
390: currentfile = file;
391: }
392: }
393:
394: /* stabline - emit stab entry for source coordinate *cp */
395: static void stabline(cp) Coordinate *cp; {
396: if (glevel <= 1)
397: return;
398: if (cp->file && cp->file != currentfile) {
399: int lab = genlabel(1);
400: print("L%d: .stabs \"%s\",0x%x,0,%d,L%d\n", lab,
401: cp->file, N_SOL, line, lab);
402: currentfile = cp->file;
403: }
404: print(".stabd 0x%x,0,%d\n", N_SLINE, cp->y);
405: }
406:
407: /* stabsym - output a stab entry for symbol p */
408: static void stabsym(p) Symbol p; {
409: char buf[100], *adr = p->x.name;
410:
411: if (p->generated || p->computed)
412: return;
413: print(".stabs \"%s\",", p->name);
414: if (isfunc(p->type)) {
415: print("0x%x,0,0x%x,_%s\n", N_FUN, p->u.f.pt[0].y, p->name);
416: print(".stabs \"%s\",0x%x,0,", p->name,
417: p->sclass == STATIC ? N_STFUN : N_GSYM);
418: adr = "0";
419: } else if (p->sclass == AUTO && p->scope == GLOBAL || p->sclass == EXTERN) {
420: print("0x%x,0,", N_GSYM);
421: adr = "0";
422: } else if (p->sclass == STATIC)
423: print("0x%x,0,", p->u.seg == BSS ? N_LCSYM : N_STSYM);
424: else if (p->scope == PARAM)
425: print("0x%x,0,", p->sclass == REGISTER ? N_RSYM : N_PSYM);
426: else if (p->scope >= LOCAL) {
427: print("0x%x,0,", p->sclass == REGISTER ? N_RSYM : N_LSYM);
428: if (p->sclass != REGISTER)
429: adr = p->x.name + 1; /* skip - sign */
430: } else
431: assert(0);
432: emittype(0, 5, p->type, adr);
433: }
434:
435: /* stabtype - output a stab entry for type name, ty */
436: static void stabtype(p) Symbol p; {
437: char *name = p->name;
438:
439: if (p->sclass || p->type == 0 || glevel <= 1)
440: return;
441: if (*p->name >= '0' && *p->name <= '9')
442: name = stringf("%s$%d.%s", p->src.file, p->src.y, p->name);
443: switch (p->type->op) {
444: case STRUCT: case UNION: {
445: Field q;
446: print(".stabs \"%s\",0x%x,0,%d,0\n", name, N_BSTR,
447: p->type->op == STRUCT ? 8 : 9);
448: for (q = fieldlist(p->type); q; q = q->link) {
449: print(".stabs \"%s\",", q->name ? q->name : "");
450: if (q->lsb)
451: print("0x%x,0,0x%x,%d\n", N_SFLD,
452: fieldsize(q)<<5|(q->type == inttype ? 4 : 14),
453: 8*q->offset + fieldright(q));
454: else {
455: print("0x%x,0,", N_SSYM);
456: emittype(0, 5, q->type, stringd(q->offset));
457: }
458: }
459: print(".stabs \"%s\",0x%x,0,%d,%d\n", name, N_ESTR,
460: p->type->op == STRUCT ? 8 : 9, p->type->size);
461: break;
462: }
463: case ENUM: {
464: Symbol *q;
465: print(".stabs \"%s\",0x%x,0,10,0\n", name, N_BSTR);
466: for (q = p->u.idlist; *q; q++)
467: print(".stabs \"%s\",0x%x,0,11,%d\n", (*q)->name,
468: N_SSYM, (*q)->u.value);
469: print(".stabs \"%s\",0x%x,0,10,%d\n", name, N_ESTR,
470: p->type->size);
471: break;
472: }
473: }
474: }
475: #endif
476: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.