![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pool.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1|
Return to pool.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 |
1.1 root 1: /*
2: * The routines in this file
3: * are responsible for managing the pool of
4: * literals. This is needed on a machine that
5: * lacks immediate addressing modes.
6: */
7: #ifdef vax
8: #include "INC$LIB:cc1.h"
9: #else
10: #include "cc1.h"
11: #endif
12:
13: /*
14: * Data structure for
15: * remembering the constants in the pool.
16: * A chain of these is built up as the
17: * compilation proceeds. The pool entries are
18: * written out as new entries are added.
19: */
20: typedef struct pool {
21: struct pool *p_pp; /* Link */
22: int p_op; /* Type of node */
23: int p_lab; /* Literal label */
24: union {
25: ival_t p_ival; /* Value of ICON */
26: lval_t p_lval; /* Value of LCON */
27: dval_t p_dval;
28: struct {
29: int p_label; /* LID t_label */
30: sizeof_t p_loffs; /* LID t_offs */
31: } pl;
32: struct {
33: SYM *p_sp; /* GID t_sp */
34: sizeof_t p_goffs; /* GID t_offs */
35: } pg;
36: } pd;
37: } POOL;
38:
39: static POOL *poolp = NULL; /* The pool */
40:
41: /*
42: * Given a pointer to a tree node with opcode
43: * ICON, LCON, DCON, LID or GID,
44: * build an entry in the literal pool
45: * and rewrite the tree to refer to the label.
46: * The only potential fixups left to the caller
47: * are a change to the type and a call to amd to set tflag.
48: * The pool should ideally be in SLINK without exception,
49: * but it isn't possible so we call poolseg(op)
50: * (defined in cc1mch.h) to determine where we're going.
51: */
52: pool(tp)
53: register TREE *tp;
54: {
55: register POOL *pp;
56: register int i;
57: register int op;
58: register int old;
59:
60: op = tp->t_op;
61: if (op==ICON||op==LCON||op==DCON||op==LID||op==GID||op==ADDR) {
62: pp = poolp;
63: while (pp != NULL) {
64: if (pp->p_op == op) {
65: if (op == ICON) {
66: if (pp->pd.p_ival == tp->t_ival)
67: break;
68: } else if (op == LCON) {
69: if (pp->pd.p_lval == tp->t_lval)
70: break;
71: } else if (op == DCON) {
72: i = 0;
73: while (i < sizeof(dval_t)
74: && pp->pd.p_dval[i] == tp->t_dval[i])
75: ++i;
76: if (i == sizeof(dval_t))
77: break;
78: } else if (op == LID) {
79: if (pp->pd.pl.p_label == tp->t_label
80: && pp->pd.pl.p_loffs == tp->t_offs)
81: break;
82: } else if (op == GID) {
83: if (pp->pd.pg.p_sp == tp->t_sp
84: && pp->pd.pg.p_goffs == tp->t_offs)
85: break;
86: }
87: }
88: pp = pp->p_pp;
89: }
90: if (pp==NULL && (pp=(POOL *)malloc(sizeof(POOL))) != NULL) {
91: pp->p_pp = poolp;
92: poolp = pp;
93: pp->p_op = op;
94: pp->p_lab = newlab();
95: if (op == ICON)
96: pp->pd.p_ival = tp->t_ival;
97: else if (op == LCON)
98: pp->pd.p_lval = tp->t_lval;
99: else if (op == DCON) {
100: for (i=0; i<sizeof(dval_t); ++i)
101: pp->pd.p_dval[i] = tp->t_dval[i];
102: } else if (op == LID) {
103: pp->pd.pl.p_label = tp->t_label;
104: pp->pd.pl.p_loffs = tp->t_offs;
105: } else if (op == GID) {
106: pp->pd.pg.p_sp = tp->t_sp;
107: pp->pd.pg.p_goffs = tp->t_offs;
108: }
109: old = newseg(poolseg(op));
110: genlab(pp->p_lab);
111: if (op==LID || op==GID) {
112: iexpr(tp, iptrtype());
113: } else
114: iexpr(tp, tp->t_type);
115: newseg(old);
116: } else if (pp == NULL) {
117: cnomem("pool malloc");
118: }
119: } else
120: cbotch("unpoolable tree");
121: tp->t_op = LID;
122: tp->t_label = pp->p_lab;
123: tp->t_seg = poolseg(op);
124: tp->t_offs = 0;
125: if (op == ADDR) {
126: poolp = pp->p_pp;
127: free(pp);
128: }
129: }
130:
131: #if OVERLAID
132: /*
133: * Free all of the entries in the
134: * literal pool. Called at the end of the
135: * code generator phase.
136: */
137: freepool()
138: {
139: register POOL *p1;
140: register POOL *p2;
141:
142: p1 = poolp;
143: while (p1 != NULL) {
144: p2 = p1->p_pp;
145: free((char *) p1);
146: p1 = p2;
147: }
148: poolp = NULL;
149: }
150: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.