![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtree2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / c / n1 / i386|
Return to mtree2.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / n1 / i386 |
1.1 root 1: /*
2: * n1/i386/mtree2.c
3: * Machine dependent parts of the tree modifier.
4: * A conditionalization handles machines that have an 80x87.
5: * i386.
6: */
7:
8: #ifdef vax
9: #include "INC$LIB:cc1.h"
10: #else
11: #include "cc1.h"
12: #endif
13:
14: int blkflab;
15:
16: #if SPLIT_CC1
17: /*
18: * Function prolog.
19: * Clear "BLK function" label.
20: */
21: doprolog()
22: {
23: blkflab = 0;
24: }
25:
26: /*
27: * Copy auto information.
28: */
29: doautos()
30: {
31: iput(iget());
32: iput(iget());
33: }
34: #endif
35:
36: /*
37: * This function performs machine specific tree modifications.
38: * It is called from "modtree" after all of the machine
39: * independent transformations have been done.
40: * It returns either a pointer to the new tree
41: * (telling "modtree" to do another pass)
42: * or NULL (which implies that no changes were made).
43: */
44: TREE *
45: modoper(tp, ac, ptp) register TREE *tp; int ac; TREE *ptp;
46: {
47: register TREE *lp, *rp, *tp1, *tp2, *tp3;
48: register int c, op, nseg;
49: register int tt, lt, rt;
50: sizeof_t offs;
51:
52: c = ac;
53: if (c==MRETURN || c==MSWITCH || c==MINIT)
54: c = MRVALUE;
55: op = tp->t_op;
56: if (isleaf(op)) {
57: if (op==AID || op==PID) {
58: /* Modify autos and parameters to "*(%ebp+offset)". */
59: offs = tp->t_offs;
60: tp->t_op = STAR;
61: tp->t_rp = NULL;
62: tp->t_lp = tp2 = makenode(ADD, PTR);
63: tp2->t_lp = tp3 = makenode(REG, PTR);
64: tp3->t_reg = EBP;
65: tp2->t_rp = ivalnode((ival_t)offs);
66: return tp;
67: } else
68: goto done;
69: }
70:
71: /*
72: * Beat on lvalue fields.
73: */
74: if ((op==ASSIGN || (op>=AADD && op<=ASHR)
75: || (op>=INCBEF && op<=DECAFT))
76: && tp->t_lp->t_op==FIELD && tp->t_lp->t_type<FLD8)
77: return modlfld(tp, c);
78:
79: /*
80: * Non leaf.
81: * Gather up subtrees.
82: * Rewrite some things as calls to library routines.
83: */
84: tt = tp->t_type;
85: lp = tp->t_lp;
86: if (lp != NULL)
87: lt = lp->t_type;
88: rp = NULL;
89: if (op != FIELD) {
90: rp = tp->t_rp;
91: if (rp != NULL)
92: rt = rp->t_type;
93: }
94:
95: /*
96: * If there is an NDP, rewrite conversions
97: * from bytes and unsigned things
98: * and all conversions from float to fixed
99: * as calls of support routines.
100: */
101: if (isvariant(VNDP)) {
102: if (isflt(tt)) {
103: if (op==CONVERT || op==CAST) {
104: if ((lp->t_flag&T_REG) != 0
105: || (lp->t_flag&T_LEAF) == 0
106: || (lt!=S16 && lt!=S32 && lt!=F32))
107: return modxfun(tp);
108: }
109: } else if ((op>=GT && op<=LT) && isflt(lt))
110: tp->t_op += UGT-GT;
111: else if ((op==CONVERT || op==CAST) && isflt(lt))
112: return modxfun(tp);
113: }
114: switch (op) {
115:
116: case FIELD:
117: if (c != MLADDR)
118: return modefld(tp->t_lp, tp, c, 1);
119: break;
120:
121: case ASSIGN:
122: if (tt == BLK) {
123: tp = modsasg(lp, rp, tp->t_size);
124: if (c != MEFFECT)
125: tp = leftnode(STAR, tp, BLK, tp->t_size);
126: return tp;
127: }
128: break;
129:
130: case CONVERT:
131: case CAST:
132: if (modkind(tt) == modkind(lp->t_type)) {
133: lp->t_type = tt;
134: return lp;
135: }
136: }
137:
138: /*
139: * If this tree is the return value of a structure function,
140: * arrange to copy the value into a secret place
141: * and return the address of the place.
142: */
143: done:
144: if (tp->t_type==BLK && ac==MRETURN) {
145: if (blkflab == 0) {
146: blkflab = newlab();
147: nseg = newseg(SBSS);
148: genlab(blkflab);
149: bput(BLOCK);
150: iput((ival_t) tp->t_size);
151: newseg(nseg);
152: }
153: lp = makenode(LID, BLK, tp->t_size);
154: lp->t_label = blkflab;
155: lp->t_seg = SBSS;
156: return modsasg(lp, tp, tp->t_size);
157: }
158: return NULL;
159: }
160:
161: /*
162: * Given a type, return a kind that is used to see
163: * if two objects are just different names for the same bits.
164: */
165: modkind(t) register int t;
166: {
167: if (t == U8)
168: t = S8;
169: else if (t == U16)
170: t = S16;
171: else if (t == U32)
172: t = S32;
173: return t;
174: }
175:
176: /*
177: * Build a call node for the assignment of structure data.
178: * The rep and a copy operation are not used so that the ES need not be used.
179: * The type of the CALL is PTR.
180: * The size is valid.
181: */
182: TREE *
183: modsasg(lp, rp, s) register TREE *lp, *rp;
184: {
185: register TREE *tp;
186:
187: rp = leftnode(ADDR, rp, PTR);
188: rp = leftnode(ARGLST, rp, PTR);
189: rp->t_rp = ivalnode((ival_t)s);
190: lp = leftnode(ADDR, lp, PTR);
191: lp = leftnode(ARGLST, lp, PTR);
192: lp->t_rp = rp;
193: tp = makenode(GID, PTR);
194: tp->t_sp = gidpool("memcpy");
195: tp->t_seg = SANY;
196: tp = leftnode(CALL, tp, PTR);
197: tp->t_size = s;
198: tp->t_rp = lp;
199: return tp;
200: }
201:
202: /*
203: * Modify function calls.
204: * Handle functions that return objects of type "BLK"
205: * by adding a free indirection node.
206: */
207: TREE *
208: modcall(tp, c) register TREE *tp; int c;
209: {
210: fixtoptype(tp);
211: tp->t_lp = modtree(tp->t_lp, MLADDR, tp);
212: tp->t_rp = modargs(tp->t_rp, tp);
213: if (tp->t_type == BLK) {
214: tp->t_type = PTR;
215: if (c != MEFFECT)
216: tp = leftnode(STAR, tp, BLK, tp->t_size);
217: }
218: return tp;
219: }
220:
221: /*
222: * Modify argument lists.
223: */
224: TREE *
225: modargs(tp, ptp) register TREE *tp; TREE *ptp;
226: {
227: if (tp == NULL)
228: return NULL;
229: if (tp->t_op == ARGLST) {
230: tp->t_lp = modargs(tp->t_lp, tp);
231: tp->t_rp = modargs(tp->t_rp, tp);
232: return tp;
233: }
234: if (tp->t_type == BLK) {
235: tp = leftnode(ADDR, tp, PTB, tp->t_size);
236: return modtree(tp, MRVALUE, ptp);
237: }
238: return modtree(tp, MFNARG, ptp);
239: }
240:
241: static char modoptab[] = {
242: 'i', 'u', /* S8 U8 */
243: 'i', 'u', /* S16 U16 */
244: 'i', 'u', /* S32 U32 */
245: 'f', 'd', /* F32 F64 */
246: 'b', /* BLK */
247: 'i', 'i', 'i', /* FLD8 FLD16 FLD32 */
248: 'p', 'p' /* PTR PTB */
249: };
250:
251: /*
252: * Rewrite a TREE node which describes an operation
253: * that the machine cannot directly perform as a CALL to a magic routine.
254: * On the i386 we rewrite NDP floating point conversions.
255: * This used to rewrite software fp as subroutine calls,
256: * now the code tables generate the calls directly instead.
257: */
258: TREE *
259: modxfun(tp)
260: TREE *tp;
261: {
262: register TREE *lp, *rp;
263: register char *p1, *p2;
264: register TREE *tp1;
265: register int tt, lt, op;
266:
267: op = tp->t_op;
268: lp = tp->t_lp;
269: rp = tp->t_rp;
270: tt = tp->t_type;
271: if (lp != NULL)
272: lt = lp->t_type;
273: p1 = id;
274: *p1++ = '_';
275: *p1++ = modoptab[tt];
276: if (lt==F32 && tt!=F64)
277: lt = F64;
278: *p1++ = modoptab[lt];
279: p2 = "cvt";
280: while (*p1++ = *p2++)
281: ;
282: *p1 = '\0';
283: tp1 = makenode(GID, PTR);
284: tp1->t_sp = gidpool(id);
285: tp1->t_seg = SANY;
286: tp->t_op = CALL;
287: tp->t_lp = tp1;
288: tp->t_rp = lp;
289: fixtoptype(tp);
290: if (tp->t_type!=tt && tt!=F32)
291: tp = leftnode(CONVERT, tp, tt);
292: if (isrelop(op)) {
293: tp = leftnode(op, tp, TRUTH);
294: tp->t_rp = ivalnode((ival_t)0);
295: }
296: return tp;
297: }
298:
299: /*
300: * Zap a DCON into a block of memory with a double in it.
301: */
302: storedcon(tp) register TREE *tp;
303: {
304: if (tp->t_op != DCON)
305: return;
306: pool(tp);
307: tp->t_flag = T_DIR;
308: }
309:
310: /*
311: * Test if 1) the tree pointed to by "tp" is a register
312: * and 2) the operation "op" can be computed in it.
313: */
314: isokareg(tp, op) register TREE *tp; register op;
315: {
316: if (op==MUL || op==DIV || op==REM)
317: return 0;
318: if (tp->t_op!=REG || !isword(tp->t_type))
319: return 0;
320: return 1;
321: }
322:
323: /*
324: * Modify bit fields in lvalue contexts.
325: * The "tp" argument is a pointer to the tree node
326: * with the FIELD operation on the left side.
327: * This routine has two tasks.
328: * First, it rewrites the type in the FIELD node to be the type used by
329: * select to match the tree; this is also used as a flag
330: * to prevent this routine from being called twice on a node.
331: * Second, it inserts explict shift nodes to
332: * the operands and results so that all of the optimizations
333: * applied to shifts work for fields.
334: * A pointer to the new top of the tree is returned.
335: */
336: TREE *
337: modlfld(tp, c) register TREE *tp; int c;
338: {
339: register TREE *lp, *rp;
340: register lt, tt;
341: register op;
342: register bmop;
343: register MASK mask;
344:
345: op = tp->t_op;
346: tt = tp->t_type;
347: lp = tp->t_lp;
348: if (lp != NULL)
349: lt = lp->t_type;
350: if (op!=AMUL && op!=ADIV && op!=ASHL && op!=ASHR) {
351: rp = tp->t_rp;
352: rp = leftnode(SHL, rp, rp->t_type);
353: rp->t_rp = ivalnode((ival_t)lp->t_base);
354: tp->t_rp = rp;
355: }
356: if (op==AAND || op==AOR || op==AXOR || op==ASSIGN) {
357: mask = ((MASK)01<<lp->t_width) - 1;
358: mask = mask << lp->t_base;
359: bmop = AND;
360: if (op == AAND) {
361: mask = ~mask;
362: bmop = OR;
363: }
364: /* rp set above */
365: rp = leftnode(bmop, rp, rp->t_type);
366: fixtoptype(rp);
367: if (rp->t_type != rp->t_lp->t_type)
368: rp->t_lp = leftnode(CONVERT, rp->t_lp, rp->t_type);
369: rp->t_rp = ivalnode((ival_t)mask);
370: tp->t_rp = rp;
371: }
372: if (c != MEFFECT)
373: tp = modefld(tp, lp, c, 0);
374: if (isbyte(lt))
375: lp->t_type = FLD8;
376: else if (isword(lt))
377: lp->t_type = FLD16;
378: else
379: lp->t_type = FLD32;
380: return tp;
381: }
382:
383: /*
384: * Rewrite field extraction.
385: * The argument "tp" is the base of the field.
386: * The argument "fp" is a FIELD node that supplies the width and the base.
387: * The argument "flag" is true to enable the mask off in unsigned field extract.
388: */
389: TREE *
390: modefld(tp, fp, c, flag) register TREE *tp, *fp; int c, flag;
391: {
392: register int n, tt;
393: register MASK mask;
394:
395: if (isbyte(tt = tp->t_type) || isword(tt)) {
396: /* Byte and word fields. Make the top a computational type. */
397: tp = leftnode(CONVERT, tp, tt);
398: fixtoptype(tp);
399: tt = tp->t_type;
400: }
401: if (c == MFLOW) {
402: /* In a flow context, the field offset is irrelevant. */
403: mask = ((MASK)1 << fp->t_width) - 1;
404: if ((n = fp->t_base) != 0)
405: mask <<= n;
406: tp = leftnode(AND, tp, tt);
407: tp->t_rp = ivalnode((ival_t)mask);
408: return tp;
409: }
410: if (isuns(tt) || fp->t_width==1) {
411: /* Unsigned fields: shift right and mask to extract. */
412: /* Field width 1 is a special case, can be treated like unsigned. */
413: if ((n = fp->t_base) != 0) {
414: tp = leftnode(SHR, tp, tt);
415: tp->t_rp = ivalnode((ival_t)n);
416: }
417: if (flag) {
418: tp = leftnode(AND, tp, tt);
419: tp->t_rp = ivalnode(((ival_t)1 << fp->t_width) - 1);
420: }
421: return tp;
422: }
423: /* Signed fields: shift left and then right to extract and sign extend. */
424: if ((n = 32 - (fp->t_base + fp->t_width)) != 0) {
425: tp = leftnode(SHL, tp, tt);
426: tp->t_rp = ivalnode((ival_t)n);
427: }
428: if ((n = 32 - fp->t_width) != 0) {
429: tp = leftnode(SHR, tp, tt);
430: tp->t_rp = ivalnode((ival_t)n);
431: }
432: return tp;
433: }
434:
435: /*
436: * Check if a tree should have its left and right subtrees swapped.
437: * Do it if it is required.
438: * Sometimes the relational operation must be adjusted.
439: */
440: modswap(tp, ptp) register TREE *tp; TREE *ptp;
441: {
442: register TREE *lp, *rp;
443: FLAG lf, rf;
444:
445: switch (tp->t_op) {
446:
447: case ADD:
448: case MUL:
449: case AND:
450: case OR:
451: case XOR:
452: case EQ:
453: case NE:
454: case GT:
455: case GE:
456: case LT:
457: case LE:
458: case UGT:
459: case UGE:
460: case ULT:
461: case ULE:
462: lp = tp->t_lp;
463: rp = tp->t_rp;
464: lf = lp->t_flag;
465: rf = rp->t_flag;
466: if (lf!=0 || rf!=0) {
467: if ((lf&T_CON) != 0
468: || (rf&T_REG) != 0
469: || (lf!=0 && rf==0))
470: swapit(tp);
471: } else if (lp->t_cost > rp->t_cost)
472: swapit(tp);
473: }
474: }
475:
476: /*
477: * Swap subtrees.
478: * Fix up relational ops.
479: */
480: swapit(tp) register TREE *tp;
481: {
482: register TREE *xp;
483: register op;
484:
485: xp = tp->t_lp;
486: tp->t_lp = tp->t_rp;
487: tp->t_rp = xp;
488: op = tp->t_op;
489: if (isrelop(op))
490: tp->t_op = fliprel[op-EQ];
491: }
492:
493: /*
494: * Convert integer constant val to type t.
495: */
496: lval_t
497: constcvt(t, val) register int t; lval_t val;
498: {
499: if (isbyte(t))
500: val &= 0xFFL;
501: else if (isword(t))
502: val &= 0xFFFFL;
503: if (!isuns(t)) {
504: if (isbyte(t) && (val & 0x80L) != 0)
505: val |= 0xFFFFFF00L;
506: else if (isword(t) && (val & 0x8000L) != 0)
507: val |= 0xFFFF0000L;
508: }
509: return val;
510: }
511:
512: /* end of n1/i386/mtree2.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.