![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to amd.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 / i8086|
Return to amd.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 / i8086 |
1.1 root 1: /*
2: * This routine sets the addressing flags for a tree node.
3: * This version is for both the SMALL and LARGE model iAPX-86.
4: * There is no provision for double indexed address modes;
5: * the compiler does not attempt to use them at this time.
6: */
7: #ifdef vax
8: #include "INC$LIB:cc1.h"
9: #else
10: #include "cc1.h"
11: #endif
12:
13: TREE *findoffs();
14:
15: /*
16: * Determine access mode.
17: * The mode set is stored into the 't_flag' field.
18: * The subtrees have already been marked.
19: * Knows how the output writer will map
20: * the logical segments into physical segments.
21: * This routine is usually called by 'walk'.
22: */
23: amd(tp, ptp)
24: register TREE *tp;
25: TREE *ptp;
26: {
27: register TREE *xp;
28: register ival_t half;
29: register int op;
30: register REGNAME r;
31: register FLAG flag;
32: register FLAG mask;
33: register KIND kind;
34: register TYPE t;
35: register lval_t n;
36: register int i;
37: register int seg;
38:
39: if ((op=tp->t_op) == LEAF) {
40: tp->t_flag = tp->t_lp->t_flag;
41: return;
42: }
43: flag = 0;
44: if (op==ICON || op==LCON) {
45: if ((n=grabnval(tp)) == 0)
46: flag |= T_0;
47: else if (n == 1)
48: flag |= T_1;
49: else if (n == 2)
50: flag |= T_2;
51: if (n>=-128 && n<=127)
52: flag |= T_BYTE;
53: if (op == LCON) {
54: flag |= T_LCN;
55: half = lower(n);
56: if (half == 0)
57: flag |= T_LHC;
58: if (half == -1)
59: flag |= T_LHS;
60: half = upper(n);
61: if (half == 0)
62: flag |= T_UHC;
63: if (half == -1)
64: flag |= T_UHS;
65: } else
66: flag |= T_ICN;
67: }
68: if (op == DCON) {
69: flag |= T_DCN;
70: i = 0;
71: while (i<sizeof(dval_t) && tp->t_dval[i]==0)
72: ++i;
73: if (i == sizeof(dval_t))
74: flag |= T_0;
75: }
76: if (op == REG) {
77: flag |= T_DIR;
78: kind = pertype[tp->t_type].p_kind;
79: if ((reg[tp->t_reg].r_lvalue&kind) != 0)
80: flag |= T_LREG;
81: if ((reg[tp->t_reg].r_rvalue&kind) != 0)
82: flag |= T_RREG;
83: #if !ONLYSMALL
84: if (tp->t_reg==SSSP || tp->t_reg==SSBP)
85: flag |= T_SREG;
86: #endif
87: } else if (op == ADDR) {
88: if (isvariant(VSMALL))
89: flag |= T_ADS;
90: else {
91: xp = tp->t_lp;
92: if (xp->t_op==LID || xp->t_op==GID) {
93: switch (xp->t_seg) {
94: case SCODE:
95: case SLINK:
96: flag |= T_ACS;
97: break;
98: case SPURE:
99: if (isvariant(VRAM))
100: flag |= T_ADS;
101: else
102: flag |= T_ACS;
103: break;
104: case SSTRN:
105: if (notvariant(VROM))
106: flag |= T_ADS;
107: else
108: flag |= T_ACS;
109: break;
110: case SDATA:
111: case SBSS:
112: flag |= T_ADS;
113: break;
114: }
115: }
116: }
117: } else if (op==LID || op==GID) {
118: #if ONLYSMALL
119: flag |= T_DIR;
120: #else
121: seg = tp->t_seg;
122: if (isvariant(VSMALL)
123: || (ptp!=NULL && ptp->t_op==CALL && tp==ptp->t_lp)
124: || seg==SCODE
125: || seg==SLINK
126: || (seg==SPURE && notvariant(VRAM)))
127: flag |= T_DIR;
128: #endif
129: } else if ((op==ADD || op==SUB) && ispoint(t=tp->t_type)) {
130: mask = T_CON;
131: if (op == SUB)
132: mask = T_NUM;
133: xp = tp;
134: do {
135: if ((xp->t_rp->t_flag&mask) == 0)
136: break;
137: xp = xp->t_lp;
138: } while (xp->t_op==ADD || xp->t_op==SUB);
139: if ((xp->t_flag&T_REG) != 0) {
140: while (xp->t_op == LEAF)
141: xp = xp->t_lp;
142: r = xp->t_reg;
143: #if !ONLYSMALL
144: if (notvariant(VSMALL)) {
145: if (r == SSBP)
146: flag |= T_LSS;
147: } else {
148: #endif
149: if (r==SI || r==DI || r==BX || r==BP)
150: flag |= T_LEA;
151: #if !ONLYSMALL
152: }
153: #endif
154: }
155: } else if (op == STAR) {
156: xp = findoffs(tp);
157: if ((xp->t_flag&T_CON) != 0 && notvariant(VLARGE))
158: flag |= T_DIR;
159: else if ((xp->t_flag&T_REG) != 0) {
160: while (xp->t_op == LEAF)
161: xp = xp->t_lp;
162: r = xp->t_reg;
163: #if !ONLYSMALL
164: if (notvariant(VSMALL)) {
165: if (r==SSBP
166: || r==ESSI || r==ESDI || r==ESBX
167: || r==DSSI || r==DSDI || r==DSBX)
168: flag |= T_DIR;
169: } else {
170: #endif
171: if (r==BP
172: || r==SI || r==DI || r==BX)
173: flag |= T_DIR;
174: #if !ONLYSMALL
175: }
176: #endif
177: }
178: flag |= T_OFS;
179: }
180: tp->t_flag = flag;
181: }
182:
183: /*
184: * Given a pointer to an offset type
185: * tree, run down the chain of indirections
186: * and additions, looking for the tree that
187: * must be loaded into a register to get
188: * an addressable tree. Return a pointer to
189: * this tree.
190: */
191: TREE *
192: findoffs(tp)
193: register TREE *tp;
194: {
195: register flag, ct=0, op;
196:
197: while (tp->t_op == LEAF)
198: tp = tp->t_lp;
199: for (;;) {
200: tp = tp->t_lp;
201: switch (op=tp->t_op) {
202: case SUB: /* can't load neg addr */
203: if(tp->t_rp->t_flag&T_NUM)
204: break;
205: return tp;
206: case ADD: /* add one addr max */
207: if((flag=(tp->t_rp->t_flag))&T_NUM)
208: break;
209: else
210: if(flag&T_CON&&0==ct++)
211: break;
212: default:
213: return tp;
214: }
215: }
216: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.