![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / gen0|
Return to gen.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / gen0 |
1.1 root 1: /* C compiler: symbolic code generator */
2:
3: #include "c.h"
4:
5: static int maxoffset; /* maximum value of offset */
6: static int offset; /* current frame offset */
7: static Node *tail;
8:
9: dclproto(static Node gen,(Node));
10: dclproto(static int gen1,(Node, int, int));
11: dclproto(static int regoffset,(int, int));
12: dclproto(static unsigned regloc,(Symbol));
13: dclproto(static void address,(Symbol, Symbol, int));
14: dclproto(static void blockbeg,(Env *));
15: dclproto(static void blockend,(Env *));
16: dclproto(static void defaddress,(Symbol));
17: dclproto(static void defconst,(int, Value));
18: dclproto(static void defstring,(int, char *));
19: dclproto(static void defsymbol,(Symbol));
20: dclproto(static void emit,(Node));
21: dclproto(static void export,(Symbol));
22: dclproto(static void function,(Symbol, Symbol [], Symbol [], int));
23: dclproto(static void global,(Symbol));
24: dclproto(static void import,(Symbol));
25: dclproto(static void local,(Symbol));
26: dclproto(static void progbeg,(int, char **));
27: dclproto(static void progend,(void));
28: dclproto(static void segment,(int));
29: dclproto(static void space,(int));
30: dclproto(static void stabend,(Coordinate *, Symbol, Coordinate **, Symbol *, Symbol *));
31: dclproto(static void stabline,(Coordinate *));
32: dclproto(static void sym,(char *, Symbol, char *));
33: dclproto(static void symname,(Symbol));
34:
35: static Interface symbolic = {
36: "symbolic",
37: 1, 1, 0, /* char */
38: 2, 2, 0, /* short */
39: 4, 4, 0, /* int */
40: 4, 4, 1, /* float */
41: 8, 4, 1, /* double */
42: 4, 4, 0, /* T * */
43: 0, 4, 0, /* struct */
44: 1, /* left_to_right */
45: 0, /* little_endian */
46: 1, /* jump_on_return */
47: 0, /* mulops_are_calls */
48: 0, /* compl_band */
49: 0, /* no_argb */
50: 0, /* no_dag */
51: address,
52: blockbeg,
53: blockend,
54: defaddress,
55: defconst,
56: defstring,
57: defsymbol,
58: emit,
59: export,
60: function,
61: gen,
62: global,
63: import,
64: local,
65: progbeg,
66: progend,
67: segment,
68: space,
69: 0, /* stabblock */
70: stabend,
71: 0, /* stabfend */
72: 0, /* stabinit */
73: stabline,
74: 0, /* stabsym */
75: 0, /* stabtype */
76: };
77: Interface *interfaces[] = { &symbolic, 0 };
78:
79: /* address - initialize q for addressing expression p+n */
80: static void address(q, p, n) Symbol q, p; int n; {
81: q->x.name = stringf("%s%s%d", p->x.name, n > 0 ? "+" : "", n);
82: }
83:
84: /* blockbeg - begin a compound statement */
85: static void blockbeg(e) Env *e; {
86: *e = offset;
87: }
88:
89: /* blockend - end a compound statement */
90: static void blockend(e) Env *e; {
91: if (offset > maxoffset)
92: maxoffset = offset;
93: offset = *e;
94: }
95:
96: /* defaddress - initialize an address */
97: static void defaddress(p) Symbol p; {
98: print("defaddress %s\n", p->x.name);
99: }
100:
101: /* defconst - define a constant */
102: static void defconst(ty, v) Value v; {
103: print("defconst ");
104: switch (ty) {
105: case C: print("char %d\n", v.uc); break;
106: case S: print("short %d\n", v.ss); break;
107: case I: print("int %d\n", v.i ); break;
108: case U: print("unsigned 0x%x\n", v.u ); break;
109: case P: print("void* 0x%x\n", v.p ); break;
110: case F: {
111: char buf[MAXLINE];
112: sprintf(buf, "float %.8e\n", v.f); /* fix */
113: outs(buf);
114: break;
115: }
116: case D: {
117: char buf[MAXLINE];
118: sprintf(buf, "double %.18e\n", v.d); /* fix */
119: outs(buf);
120: break;
121: }
122: default: assert(0);
123: }
124: }
125:
126: /* defstring - emit a string constant */
127: static void defstring(len, s) char *s; {
128: int n;
129:
130: print("defstring \"");
131: for (n = 0; len-- > 0; s++) {
132: if (n >= 72) {
133: print("\n");
134: n = 0;
135: }
136: if (*s == '"' || *s == '\\') {
137: print("\\%c", *s);
138: n += 2;
139: } else if (*s >= ' ' && *s < 0177) {
140: *bp++ = *s;
141: n += 1;
142: } else {
143: print("\\%d%d%d", (*s>>6)&3, (*s>>3)&7, *s&7);
144: n += 4;
145: }
146: }
147: print("\"\n");
148: }
149:
150: /* defsymbol - define a symbol: initialize p->x */
151: static void defsymbol(p) Symbol p; {
152: p->x.name = p->name;
153: if (glevel > 2 && p->scope >= LOCAL && p->type && isfunc(p->type))
154: sym("extern", p, "\n");
155: }
156:
157: /* emit - emit the dags on list p */
158: static void emit(p) Node p; {
159: for (; p; p = p->x.next)
160: if (p->op == LABEL+V) {
161: assert(p->syms[0]);
162: print("%s:\n", p->syms[0]->x.name);
163: } else {
164: int i;
165: assert(p->link == 0 || p->x.lev == 0);
166: print("node%c%d %s count=%d", p->x.lev == 0 ? '\'' : '#', p->x.id,
167: opname(p->op), p->count);
168: for (i = 0; i < MAXKIDS && p->kids[i]; i++)
169: print(" #%d", p->kids[i]->x.id);
170: for (i = 0; i < MAXSYMS && p->syms[i]; i++) {
171: if (p->syms[i]->x.name)
172: print(" %s", p->syms[i]->x.name);
173: if (p->syms[i]->name != p->syms[i]->x.name)
174: print(" (%s)", p->syms[i]->name);
175: }
176: print("\n");
177: }
178: }
179:
180: /* export - announce p as exported */
181: static void export(p) Symbol p; {
182: print("export %s\n", p->x.name);
183: }
184:
185: /* function - generate code for a function */
186: static void function(f, caller, callee, ncalls) Symbol f, caller[], callee[]; {
187: int i;
188:
189: sym("function", f, ncalls ? (char *)0 : "\n");
190: if (ncalls)
191: print(" ncalls=%d\n", ncalls);
192: offset = 0;
193: for (i = 0; caller[i] && callee[i]; i++) {
194: offset = roundup(offset, caller[i]->type->align);
195: caller[i]->x.name = caller[i]->name;
196: callee[i]->x.name = callee[i]->name;
197: caller[i]->x.offset = callee[i]->x.offset = offset;
198: sym("caller's parameter", caller[i], "\n");
199: sym("callee's parameter", callee[i], "\n");
200: offset += caller[i]->type->size;
201: }
202: maxoffset = offset = 0;
203: gencode(caller, callee);
204: print("maxoffset=%d\n", maxoffset);
205: emitcode();
206: print("end %s\n", f->x.name);
207: }
208:
209: /* gen - generate code for the dags on list p */
210: static Node gen(p) Node p; {
211: int n;
212: Node nodelist;
213:
214: tail = &nodelist;
215: for (n = 0; p; p = p->link) {
216: switch (generic(p->op)) { /* check for valid nodelist */
217: case CALL:
218: assert(!IR->no_dag || p->count == 0);
219: break;
220: case ARG:
221: case ASGN: case JUMP: case LABEL: case RET:
222: case EQ: case GE: case GT: case LE: case LT: case NE:
223: assert(p->count == 0);
224: break;
225: case INDIR:
226: assert(!IR->no_dag && p->count > 0);
227: break;
228: default:
229: assert(0);
230: }
231: n = gen1(p, 0, n);
232: }
233: *tail = 0;
234: return nodelist;
235: }
236:
237: /* gen1 - generate code for *p */
238: static int gen1(p, lev, n) Node p; {
239: if (p && p->x.id == 0) {
240: p->x.lev = lev;
241: p->x.id = ++n;
242: n = gen1(p->kids[0], lev + 1, n);
243: n = gen1(p->kids[1], lev + 1, n);
244: *tail = p;
245: tail = &p->x.next;
246: }
247: return n;
248: }
249:
250: /* global - announce a global */
251: static void global(p) Symbol p; {
252: sym("global", p, "\n");
253: }
254:
255: /* import - import a symbol */
256: static void import(p) Symbol p; {
257: print("import %s\n", p->x.name);
258: }
259:
260: /* local - local variable */
261: static void local(p) Symbol p; {
262: offset = roundup(offset, p->type->align);
263: p->x.name = p->name;
264: p->x.offset = offset;
265: sym("local", p, "\n");
266: offset += p->type->size;
267: }
268:
269: /* progbeg - beginning of program */
270: static void progbeg(argc, argv) char *argv[]; {
271: print("progbeg argv=");
272: while (argc--)
273: print("%s ", *argv++);
274: print("\n");
275: }
276:
277: /* progend - end of program */
278: static void progend() {
279: print("progend\n");
280: }
281:
282: /* regloc - return "id" for p's register */
283: static unsigned regloc(p) Symbol p; {
284: assert(p && p->sclass == REGISTER);
285: return 0;
286: }
287:
288: /* regoffset - return stack offset of cell that saves reg */
289: static int regoffset(regset, regnum) {
290: return -1;
291: }
292:
293: /* segment - switch to segment s */
294: static void segment(s) {
295: print("segment %s\n", &"text\0bss\0.data\0lit\0.sym\0."[5*s-5]);
296: }
297:
298: /* space - initialize n bytes of space */
299: static void space(n) {
300: print("space %d\n", n);
301: }
302:
303: /* sym - print symbol table entry for p, followed by str */
304: static void sym(kind, p, str) char *kind, *str; Symbol p; {
305: assert(kind);
306: if (glevel > 2) {
307: print("%s ", kind);
308: symname(p);
309: } else
310: print("%s %s", kind, p->name);
311: if (p->name != p->x.name)
312: print(" (%s)", p->x.name);
313: print(" type=%t class=%k scope=", p->type, p->sclass);
314: switch (p->scope) {
315: case CONSTANTS: print("CONSTANTS"); break;
316: case LABELS: print("LABELS"); break;
317: case GLOBAL: print("GLOBAL"); break;
318: case PARAM: print("PARAM"); break;
319: case LOCAL: print("LOCAL"); break;
320: default:
321: if (p->scope > LOCAL)
322: print("LOCAL+%d", p->scope - LOCAL);
323: else
324: print("%d", p->scope);
325: }
326: if (p->scope >= PARAM && p->sclass != STATIC)
327: print(" offset=%d ref=%d", p->x.offset, (int)(1000*p->ref));
328: if (glevel > 2) {
329: print(" up=");
330: symname(p->up);
331: }
332: if (str)
333: print(str);
334: }
335:
336: /* symname - print prefix, p's name, declaration source coordinate, suffix */
337: static void symname(p) Symbol p; {
338: if (p)
339: print("%s@%w.%d", p->name, &p->src, p->src.x);
340: else
341: print("0");
342: }
343:
344: /* stabend - finalize stab output */
345: static void stabend(cp, p, cpp, sp, stab) Coordinate *cp, **cpp; Symbol p, *sp, *stab; {
346: int i;
347:
348: symname(p);
349: print("\n");
350: for (i = 0; cpp[i] && sp[i]; i++) {
351: print("%w.%d: ", cpp[i], cpp[i]->x);
352: symname(sp[i]);
353: print("\n");
354: }
355: }
356:
357: /* stabline - emit line number information for source coordinate *cp */
358: static void stabline(cp) Coordinate *cp; {
359: if (cp->file)
360: print("%s:", cp->file);
361: print("%d.%d:\n", cp->y, cp->x);
362: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.