![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / c|
Return to tree.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / c |
1.1 root 1: /* C compiler: tree management */
2:
3: #include "c.h"
4:
5: static struct arena first[] = {
6: 0, 0, 0, &first[0], 0,
7: 0, 0, 0, &first[1], 0,
8: };
9: Arena permanent = &first[0]; /* permanent storage */
10: Arena transient = &first[1]; /* transient storage; released at function end */
11: static Arena freearenas; /* list of free arenas */
12:
13: /* allocate - allocate n bytes in arena **p, adding a new arena if necessary */
14: char *allocate(n, p) Arena *p; {
15: Arena ap = *p;
16:
17: while (ap->avail + n > ap->limit)
18: if (ap->next) { /* move to next arena */
19: ap = ap->next;
20: ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
21: } else if (ap->next = freearenas) {
22: freearenas = freearenas->next;
23: ap = ap->next;
24: ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
25: ap->first = (*p)->first;
26: ap->next = 0;
27: } else { /* allocate a new arena */
28: int m = n + MEMINCR*1024 + roundup(sizeof *ap, sizeof (double));
29: ap->next = (Arena) malloc(m);
30: assert(ap->next && (int)ap->next >= 0);
31: if ((char *)ap->next == ap->limit) /* extend previous arena? */
32: ap->limit = (char *)ap->next + m;
33: else { /* link to a new arena */
34: ap = ap->next;
35: ap->limit = (char *)ap + m;
36: ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
37: }
38: ap->first = (*p)->first;
39: ap->next = 0;
40: }
41: *p = ap;
42: ap->avail += n;
43: return ap->avail - n;
44: }
45:
46: /* deallocate - release all space in arena *p, except the first arena; reset *p */
47: void deallocate(p) Arena *p; {
48: Arena first = (*p)->first;
49:
50: (*p)->next = freearenas;
51: freearenas = first->next;
52: first->next = 0;
53: *p = first;
54: }
55:
56:
57: /* cvtconst - convert a constant tree into tree for a global variable */
58: Tree cvtconst(p) Tree p; {
59: Symbol q = constant(p->type, p->u.v);
60: Tree e;
61:
62: if (q->u.c.loc == 0)
63: q->u.c.loc = genident(STATIC, p->type, GLOBAL);
64: if (isarray(p->type)) {
65: e = tree(ADDRG+P, atop(p->type), 0, 0);
66: e->u.sym = q->u.c.loc;
67: } else
68: e = idnode(q->u.c.loc);
69: return e;
70: }
71:
72: /* hascall - does tree p contain a CALL? */
73: int hascall(p) Tree p; {
74: if (p == 0)
75: return 0;
76: if (generic(p->op) == CALL || (IR->mulops_are_calls &&
77: (p->op == DIV+I || p->op == MOD+I || p->op == MUL+I
78: || p->op == DIV+U || p->op == MOD+U || p->op == MUL+U)))
79: return 1;
80: return hascall(p->kids[0]) || hascall(p->kids[1]);
81: }
82:
83: /* opname - return string for operator op */
84: char *opname(op) {
85: static char *opnames[] = {
86: "",
87: #define NEEDNAMES
88: #include "ops.h"
89: };
90: char *name;
91:
92: switch (op) {
93: case AND: return "AND";
94: case NOT: return "NOT";
95: case OR: return "OR";
96: case COND: return "COND";
97: case RIGHT:return "RIGHT";
98: case FIELD:return "FIELD";
99: }
100: if (opindex(op) > 0 && opindex(op) < sizeof opnames/sizeof opnames[0])
101: name = opnames[opindex(op)];
102: else
103: name = stringd(opindex(op));
104: if (optype(op) > 0 && optype(op) < sizeof (TYPENAMES) - 1)
105: return stringf("%s%c", name, TYPENAMES[optype(op)]);
106: else
107: return stringf("%s+%d", name, optype(op));
108: }
109:
110: /* tree - allocate and initialize a tree node */
111: int ntree = 0; /* next free tree in trees */
112: static struct tree trees[100]; /* default allocation area for trees */
113:
114: Tree tree(op, type, left, right) Type type; Tree left, right; {
115: register Tree p;
116:
117: if (ntree < sizeof trees/sizeof trees[0])
118: p = &trees[ntree++];
119: else
120: p = (Tree)talloc(sizeof *p);
121: BZERO(p, struct tree);
122: p->op = op;
123: p->type = type;
124: p->kids[0] = left;
125: p->kids[1] = right;
126: return p;
127: }
128:
129: /* retype - return a copy of tree p with type field = ty */
130: Tree retype(p, ty) Tree p; Type ty;{
131: Tree q;
132:
133: if (p->type == ty)
134: return p;
135: q = tree(p->op, ty, p->kids[0], p->kids[1]);
136: q->u = p->u;
137: return q;
138: }
139:
140: /* root - tree p will be a root; remove unnecessary temporaries */
141: Tree root(p) Tree p; {
142: if (p == 0)
143: return p;
144: switch (generic(p->op)) {
145: case COND: {
146: Tree q = p->kids[1];
147: assert(q && q->op == RIGHT);
148: if (p->u.sym && q->kids[0] && generic(q->kids[0]->op) == ASGN)
149: q->kids[0] = root(q->kids[0]->kids[1]);
150: else
151: q->kids[0] = root(q->kids[0]);
152: if (p->u.sym && q->kids[1] && generic(q->kids[1]->op) == ASGN)
153: q->kids[1] = root(q->kids[1]->kids[1]);
154: else
155: q->kids[1] = root(q->kids[1]);
156: if (p->u.sym)
157: release(p->u.sym);
158: p->u.sym = 0;
159: if (q->kids[0] == 0 && q->kids[1] == 0)
160: p = root(p->kids[0]);
161: }
162: break;
163: case AND: case OR:
164: if ((p->kids[1] = root(p->kids[1])) == 0)
165: p = root(p->kids[0]);
166: break;
167: case NOT:
168: return root(p->kids[0]);
169: case RIGHT:
170: if (p->kids[1] == 0)
171: return root(p->kids[0]);
172: if (p->kids[0] && p->kids[0]->op == CALL+B
173: && p->kids[1] && p->kids[1]->op == INDIR+B)
174: /* avoid premature release of the CALL+B temporary */
175: return p->kids[0];
176: if (p->kids[0] && p->kids[0]->op == RIGHT
177: && p->kids[1] == p->kids[0]->kids[0])
178: /* de-construct e++ construction */
179: return p->kids[0]->kids[1];
180: /* fall thru */
181: case EQ: case NE: case GT: case GE: case LE: case LT:
182: case ADD: case SUB: case MUL: case DIV: case MOD:
183: case LSH: case RSH: case BAND: case BOR: case BXOR:
184: p = tree(RIGHT, p->type, root(p->kids[0]), root(p->kids[1]));
185: return p->kids[0] || p->kids[1] ? p : 0;
186: case INDIR:
187: if (p->type->size == 0 && unqual(p->type) != voidtype)
188: warning("reference to `%t' elided\n", p->type);
189: if (isptr(p->kids[0]->type) && isvolatile(p->kids[0]->type->type))
190: warning("reference to `volatile %t' elided\n", p->type);
191: /* fall thru */
192: case CVI: case CVF: case CVD: case CVU: case CVC: case CVS: case CVP:
193: case NEG: case BCOM: case FIELD:
194: return root(p->kids[0]);
195: case ADDRL:
196: if (p->u.sym->temporary)
197: release(p->u.sym);
198: /* fall thru */
199: case ADDRG: case ADDRF: case CNST:
200: return 0;
201: case ARG: case ASGN: case CALL: case JUMP: case LABEL:
202: break;
203: default: assert(0);
204: }
205: return p;
206: }
207:
208: /* texpr - parse an expression via f(tok), allocating trees in transient area */
209: Tree texpr(f, tok) dclproto(Tree (*f),(int)); {
210: int n = ntree;
211: Tree p;
212:
213: ntree = sizeof trees/sizeof trees[0];
214: p = (*f)(tok);
215: ntree = n;
216: return p;
217: }
218:
219: /* tfree - release space in all transient arenas and default tree area */
220: void tfree() {
221: if (glevel < 3 && !xref)
222: deallocate(&transient);
223: ntree = 0;
224: }
225:
226: static int nid = 1; /* identifies trees & nodes in debugging output */
227: static struct nodeid {
228: int printed;
229: Tree node;
230: } ids[500]; /* if ids[i].node == p, then p's id is i */
231:
232: dclproto(static void printtree1,(Tree, int, int));
233:
234: /* nodeid - lookup id for tree or node p */
235: int nodeid(p) Tree p; {
236: int i = 1;
237:
238: ids[nid].node = p;
239: while (ids[i].node != p)
240: i++;
241: if (i == nid)
242: ids[nid++].printed = 0;
243: return i;
244: }
245:
246: /* printed - return pointer to ids[id].printed */
247: int *printed(id) {
248: if (id)
249: return &ids[id].printed;
250: nid = 1;
251: return 0;
252: }
253:
254: /* printtree - print tree p on fd */
255: void printtree(p, fd) Tree p; {
256: (void)printed(0);
257: printtree1(p, fd, 1);
258: }
259:
260: /* printtree1 - recursively print tree p */
261: static void printtree1(p, fd, lev) Tree p; {
262: int i;
263: static char blanks[] = " ";
264:
265: if (p == 0 || *printed(i = nodeid(p)))
266: return;
267: fprint(fd, "#%d%s%s", i, &" "[i < 10 ? 0 : i < 100 ? 1 : 2],
268: &blanks[sizeof blanks - lev]);
269: fprint(fd, "%s %t", opname(p->op), p->type);
270: *printed(i) = 1;
271: for (i = 0; i < sizeof p->kids/sizeof p->kids[0]; i++)
272: if (p->kids[i])
273: fprint(fd, " #%d", nodeid(p->kids[i]));
274: if (generic(p->op) == FIELD && p->u.field)
275: fprint(fd, " %s %d..%d", p->u.field->name,
276: fieldsize(p->u.field) + fieldright(p->u.field), fieldright(p->u.field));
277: else if (generic(p->op) == CNST)
278: fprint(fd, " %s", vtoa(p->type, p->u.v));
279: else if (p->u.sym)
280: fprint(fd, " %s", p->u.sym->name);
281: if (p->node)
282: fprint(fd, " node=0x%x", p->node);
283: fprint(fd, "\n");
284: for (i = 0; i < sizeof p->kids/sizeof p->kids[0]; i++)
285: printtree1(p->kids[i], fd, lev + 1);
286: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.