![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to outmch.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 outmch.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 / i8086 |
1.1 root 1: /*
2: * This file contains a number of small, machine dependent output
3: * routines called from the main code output routines in 'out.c'.
4: * Most have something to do with function calls and argument lists.
5: */
6: #ifdef vax
7: #include "INC$LIB:cc1.h"
8: #else
9: #include "cc1.h"
10: #endif
11:
12: /*
13: * Output a call.
14: * Make the left subtree (the name) addressable if required.
15: * Take a quick look to see if the semantics of the indirect call will work.
16: * If this is not an indirect call (iflag==0), then the "nsef" flag is set
17: * in the call to "genadr", to supress the generation of escape prefix bytes.
18: */
19: outcall(tp, cxt, lab)
20: register TREE *tp;
21: {
22: register int nb;
23: register int iflag;
24: register int isalien;
25: register int isptr;
26: register int type;
27:
28: isalien = 0;
29: if (isvariant(VALIEN)) {
30: if (tp->t_lp->t_op == GID && tp->t_lp->t_seg == SALIEN) {
31: ++isalien;
32: type = tp->t_type;
33: isptr = ispoint(type);
34: /* Adjust types not adjusted in parser. */
35: if (type == S8)
36: tp->t_type = S16;
37: else if (type == U8)
38: tp->t_type = U16;
39: #if !OMF286
40: callfixup(tp->t_lp);
41: #endif
42: }
43: }
44: if (isalien) {
45: genr(ZPUSH, A_RSI);
46: genr(ZPUSH, A_RDI);
47: if (isvariant(VSMALL))
48: genr(ZPUSH, A_RES);
49: }
50: nb = outargs(tp->t_rp, isalien);
51: iflag = 0;
52: tp = tp->t_lp;
53: if (tp->t_op == STAR) {
54: iflag = 1;
55: tp = tp->t_lp;
56: if (!isadr(tp->t_flag)) {
57: while (tp->t_op == LEAF)
58: tp = tp->t_lp;
59: outofs(tp);
60: }
61: }
62: outopcall(iflag);
63: genadr(tp, iflag==0, 0, NULL);
64: if (isalien) {
65: if (isptr) {
66: genrr(ZMOV, A_RAX, A_RBX);
67: #if !ONLYSMALL
68: if (isvariant(VLARGE))
69: genrr(ZMOV, A_RDX, A_RES);
70: #endif
71: }
72: if (type == S8) {
73: bput(CODE); bput(ZCBW);
74: }
75: else if (type == U8)
76: genrr(ZSUBB, A_RAH, A_RAH);
77: if (isvariant(VSMALL))
78: genr(ZPOP, A_RES);
79: genr(ZPOP, A_RDI);
80: genr(ZPOP, A_RSI);
81: } else if (nb != 0)
82: genri(ZADD, A_RSP, nb);
83: }
84:
85: #if !OMF286
86: /* Remove the trailing '_' appended to GID's by cc0, for alien call. */
87: callfixup(tp)
88: TREE *tp;
89: {
90: register char *cp1, *cp2;
91:
92: cp1 = tp->t_sp->s_id;
93: cp2 = id;
94: while (*cp2++ = *cp1++)
95: ;
96: cp2[-2] = 0;
97: tp->t_sp = gidpool(id);
98: }
99: #endif
100:
101: /*
102: * Output the argument list of a function.
103: * The arguments are moved to the stack right to left.
104: * Structure arguments, marked by a PTB type, get block moved into place.
105: * If the function is "alien" we push in the opposite order.
106: */
107: outargs(atp, isalien)
108: TREE *atp;
109: {
110: register TREE *tp;
111: register s, n;
112: TYPE type;
113:
114: if ((tp=atp) == NULL)
115: return (0);
116: if (tp->t_op == ARGLST) {
117: s = 0;
118: if (isalien)
119: s += outargs(tp->t_lp, isalien);
120: s += outargs(tp->t_rp, isalien);
121: if ( ! isalien)
122: s += outargs(tp->t_lp, isalien);
123: return (s);
124: }
125: #if !ONLYSMALL
126: if ((type=tp->t_type)==LPTB || type==SPTB) {
127: #else
128: if ((type=tp->t_type) == SPTB) {
129: #endif
130: n = s = tp->t_size;
131: if (isvariant(VALIGN))
132: n = (s+1)&~01;
133: if (n != 0) {
134: if (isvariant(V80186)) {
135: genri(ZSUB, A_RSP, n);
136: geni(ZPUSH, s);
137: } else {
138: if (s == n) {
139: genri(ZMOV, A_RAX, s);
140: genrr(ZSUB, A_RSP, A_RAX);
141: } else {
142: genri(ZSUB, A_RSP, n);
143: genri(ZMOV, A_RAX, s);
144: }
145: genr(ZPUSH, A_RAX);
146: }
147: output(tp, MFNARG, 0, 0);
148: #if !ONLYSMALL
149: if (type == LPTB) {
150: genr(ZPUSH, A_RSS);
151: genrr(ZMOV, A_RAX, A_RSP);
152: genri(ZADD, A_RAX, 8);
153: genr(ZPUSH, A_RAX);
154: geng(ZXCALL, "blkmv");
155: genri(ZADD, A_RSP, 10);
156: } else {
157: #endif
158: genrr(ZMOV, A_RAX, A_RSP);
159: genri(ZADD, A_RAX, 4);
160: genr(ZPUSH, A_RAX);
161: geng(ZCALL, "blkmv");
162: genri(ZADD, A_RSP, 6);
163: #if !ONLYSMALL
164: }
165: #endif
166: }
167: return (n);
168: }
169: output(tp, MFNARG, 0, 0);
170: return (pertype[type].p_size);
171: }
172:
173: /*
174: * This routine does the work of the [TLOP0], [TLOP1] and [TLOP2] macros.
175: * It is given an opcode and returns the opcode that is used.
176: */
177: maptype(opvariant, opcode, tp)
178: int opvariant;
179: register int opcode;
180: register TREE *tp;
181: {
182: if (opvariant == M_TL)
183: tp = tp->t_lp;
184: else if (opvariant == M_TR)
185: tp = tp->t_rp;
186: else if (opvariant != M_TN)
187: return (opcode);
188: if (isbyte(tp->t_type)) {
189: if (opcode == ZADD)
190: opcode = ZADDB;
191: if (opcode == ZSUB)
192: opcode = ZSUBB;
193: if (opcode == ZINC)
194: opcode = ZINCB;
195: if (opcode == ZDEC)
196: opcode = ZDECB;
197: }
198: return (opcode);
199: }
200:
201: /*
202: * This routine does the ZLDES opcode mapping.
203: */
204: mapzldes(tp)
205: register TREE *tp;
206: {
207: if (hihalf(tp->t_treg) == DS)
208: return (ZLDS);
209: else if (hihalf(tp->t_treg) == ES)
210: return (ZLES);
211: else
212: cbotch("ldes");
213: }
214:
215: /*
216: * Emit call opcode.
217: */
218: outopcall(iflag)
219: {
220: register op;
221:
222: #if !ONLYSMALL
223: if (notvariant(VSMALL)) {
224: op = ZXCALL;
225: if (iflag)
226: op = ZIXCALL;
227: } else {
228: #endif
229: op = ZCALL;
230: if (iflag)
231: op = ZICALL;
232: #if !ONLYSMALL
233: }
234: #endif
235: bput(CODE);
236: bput(op);
237: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.