![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sel1.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 sel1.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 |
1.1 root 1: /*
2: * C compiler.
3: * Pattern selection.
4: */
5: #ifdef vax
6: #include "INC$LIB:cc1.h"
7: #else
8: #include "cc1.h"
9: #endif
10:
11: #if !TINY
12: #define consnap(x, p) if (sflag>x) snapf(p)
13: #define consnapv(x, p, v) if (sflag>x) snapf(p, v)
14: #else
15: #define consnap(x, p) /* consnap */
16: #define consnapv(x, p, v) /* consnapv */
17: #endif
18: extern TREE *ripout();
19:
20: /*
21: * This table, indexed by a context name,
22: * returns the appropriate bit set used in the pattern match.
23: */
24: static PATFLAG nflagtab[] = {
25: PEFFECT,
26: PLVALUE,
27: PRVALUE,
28: PFNARG,
29: 0,
30: 0,
31: 0,
32: 0,
33: 0,
34: 0,
35: 0,
36: 0,
37: 0,
38: PEQ,
39: PNE,
40: PGT,
41: PGE,
42: PLE,
43: PLT,
44: PUGT,
45: PUGE,
46: PULE,
47: PULT
48: };
49:
50: /*
51: * This routine is the heart of the code selector.
52: * It looks for a pattern that covers the top level
53: * operation of tree 'tp' and is in conformance with
54: * (or can be pulled into conformance with)
55: * the pattern's shape requirements.
56: */
57: seltree(tp, c, r)
58: TREE *tp;
59: {
60: register TREE *lp, *rp;
61: register PAT *patp;
62: PATX *patxp;
63: TREE *ap;
64: FLAG lflag, rflag, lpflag, rpflag;
65: TYPESET ltype, rtype, ntype;
66: PATFLAG pflag, nflag;
67: PREGSET savbusy, savxreg;
68: int ltemp, rtemp, ntemp, stemp, ptemp;
69: int sgoal;
70: int clash, h;
71: int rreg, op, npat, lindex, rindex;
72: int didstore;
73:
74: /* Confirm that the context is consistent
75: * with the register specified. */
76: if (c == MLVALUE && isrealreg(r)
77: && (pertype[tp->t_type].p_kind®[r].r_lvalue)==0)
78: c = MRVALUE;
79: /* Jump here if the original match was accomplished by coercing a
80: * subtree into addressibility by a store into an auto temp.
81: * The tree has been rewritten and must
82: * be matched again for an earlier ADR|MMX pattern. */
83: rematch:
84: #if !TINY
85: if (sflag > 1) {
86: snapf("seltree(%P, %C, ", tp, c);
87: snapf(c<MFLOW ? "%R" : c<MEQ ? "%d" : "L%d", r);
88: snapf(") %A curbusy=%M, curxreg=%M\n",
89: tp->t_op, curbusy, curxreg);
90: if (sflag > 2)
91: snapf("%W%E%W", "Seltree", tp, NULL);
92: }
93: #endif
94: nflag = nflagtab[c];
95: ntype = pertype[tp->t_type].p_type;
96: if (tp->t_op < MIOBASE)
97: return (0);
98: /* Try for matches with widening conversions deleted.
99: * Shrink type conversions must remain as
100: * they may clear or sign extend the operand. */
101: lp = tp->t_lp;
102: if (iswiden(lp)) {
103: ap = lp->t_lp;
104: if (ap->t_op >= MIOBASE) {
105: tp->t_lp = ap;
106: if (seltree(tp, c, r))
107: return (1);
108: tp->t_lp = lp;
109: }
110: }
111: ltype = pertype[lp->t_type].p_type;
112: if (lp->t_op == FIELD)
113: lp = lp->t_lp;
114: lflag = lp->t_flag;
115: rtype = 0;
116: rflag = 0;
117: if ((op = tp->t_op) != FIELD) {
118: rp = tp->t_rp;
119: if (rp != NULL) {
120: if (iswiden(rp)) {
121: ap = rp->t_lp;
122: if (ap->t_op >= MIOBASE) {
123: tp->t_rp = ap;
124: if (seltree(tp, c, r))
125: return (1);
126: tp->t_rp = rp;
127: }
128: }
129: rtype = pertype[rp->t_type].p_type;
130: rflag = rp->t_flag;
131: }
132: }
133: patxp = &patx[op - MIOBASE];
134: patp = patxp->px_pp - 1;
135: npat = patxp->px_npat;
136: savbusy = curbusy;
137: savxreg = curxreg;
138: /* Main search.
139: * A flying jump to 'again' will try the next pattern.
140: * The 'patp' is predecremented.
141: * Yes, this is a bit ugly. */
142: again:
143: curbusy = savbusy;
144: curxreg = savxreg;
145: tp->t_patp = NULL;
146: if (--npat < 0)
147: return (0);
148: ++patp;
149: consnapv(10, "%I: ", patp);
150: /* Pattern flag: specifies whether this pattern
151: * can satisfy the context specified for this tree
152: * we must have a hit to match. */
153: pflag = 0;
154: if (patp->p_flag != 0)
155: pflag = patcache[patp->p_flag-1];
156: if ((nflag&pflag) == 0) {
157: consnap(10, "pflag\n");
158: goto again;
159: }
160: /* Node type: unless pattern specifies no type
161: * we must have a hit to match. */
162: if (patp->p_ntype != 0
163: && (typecache[patp->p_ntype-1]&ntype) == 0) {
164: consnap(10, "ntype\n");
165: goto again;
166: }
167: /* Left tree type: unless pattern specifies no type
168: * we must have a hit to match. */
169: if (patp->p_ltype != 0
170: && (typecache[patp->p_ltype-1]<ype) == 0) {
171: consnap(10, "ltype\n");
172: goto again;
173: }
174: /* Right tree type: unless pattern specifies no type
175: * we must have a hit to match. */
176: if (patp->p_rtype != 0
177: && (typecache[patp->p_rtype-1]&rtype) == 0) {
178: consnap(10, "rtype\n");
179: goto again;
180: }
181: /* Left tree node type: a mismatch will be coerced
182: * unless the pattern specifies MMX.
183: * bytereg(tp) || ... is dgc's kludge to avoid ADR coercion
184: * of byte oriented operations which actually require a
185: * register, at least so I (rec) think (thinks). */
186: lpflag = 0;
187: if (patp->p_lflag != 0)
188: lpflag = flagcache[patp->p_lflag-1];
189: if (lpflag!=0 && (lpflag&lflag)==0
190: && ((lpflag&T_MMX) != 0
191: || (bytereg(tp) && lflag==0 && (lpflag&T_TREG)==0))) {
192: consnap(10, "lflag\n");
193: goto again;
194: }
195: /* Right tree node type: a mismatch will be coerced
196: * unless the pattern rspecifies MMX. */
197: rpflag = 0;
198: if (patp->p_rflag != 0)
199: rpflag = flagcache[patp->p_rflag-1];
200: if (rpflag!=0 && (rpflag&rflag)==0 && (rpflag&T_MMX)!=0) {
201: consnap(10, "rflag\n");
202: goto again;
203: }
204: /* This pattern is acceptable.
205: * The simplest case of a match requires
206: * only that the pattern pointer be identified.
207: * The rest of the code in this routine is activated
208: * by requests for registers, TREG loads, and node type coercion. */
209: tp->t_patp = patp;
210: tp->t_used = 0;
211: /* The pattern may explicitly specify temp
212: * registers for a subtrees, or the
213: * subtree temp may have to be allocated
214: * before the other subtree is selected. */
215: rtemp = NONE;
216: if ((rpflag&T_TREG) != 0) {
217: rtemp = patp->p_rtemp;
218: if (isrealreg(rtemp)) {
219: if (isbusy(rtemp)) {
220: consnap(10, "rtemp busy\n");
221: goto again;
222: }
223: setused(tp, rtemp);
224: } else if ((lpflag&T_TREG)!=0 && (pflag&P_SRT)==0) {
225: rtemp = rallo(rp, tp->t_used, 0);
226: if (rtemp < 0) {
227: consnap(10, "rtemp allo\n");
228: goto again;
229: }
230: consnapv(15, "rtemp = %R\n", rtemp);
231: setused(tp, rtemp);
232: }
233: }
234: ltemp = NONE;
235: if ((lpflag&T_TREG) != 0) {
236: ltemp = patp->p_ltemp;
237: if (isrealreg(ltemp)) {
238: if (isbusy(ltemp)) {
239: consnap(10, "ltemp busy\n");
240: goto again;
241: }
242: setused(tp, ltemp);
243: } else if ((rpflag&T_TREG)!=0 && (pflag&P_SLT)==0) {
244: ltemp = rallo(lp, tp->t_used, 0);
245: if (ltemp < 0) {
246: consnap(10, "ltemp allo\n");
247: goto again;
248: }
249: consnapv(15, "ltemp = %R\n", ltemp);
250: setused(tp, ltemp);
251: }
252: }
253: /* The pattern may require a node temp register.
254: * If the caller cares, use his preference.
255: * If PAIR, allocate a pair so that the right and left
256: * preferences (usually LOTEMP) will work out right.
257: * The ANY specifier stays around for a while. */
258: ntemp = patp->p_ntemp;
259: if (isrealreg(ntemp)) {
260: if (isbusy(ntemp)) {
261: consnap(10, "ntemp busy\n");
262: goto again;
263: }
264: } else if (ntemp != NONE) {
265: if ((c==MLVALUE || c==MRVALUE) && isrealreg(r)) {
266: ptemp = r;
267: clash = 0;
268: if (ntemp == PAIR) {
269: ptemp = enpair(ptemp);
270: if ((h=lohalf(ptemp))!=r && isbusy(h))
271: ++clash;
272: if ((h=hihalf(ptemp))!=r && isbusy(h))
273: ++clash;
274: }
275: if (!clash && isusable(tp, c, ptemp))
276: ntemp = ptemp;
277: }
278: /* Bind only if we must. */
279: if (!isrealreg(ntemp)) {
280: if (ntemp == PAIR
281: || (ltemp==LOTEMP || ltemp==HITEMP)
282: || (rtemp==LOTEMP || rtemp==HITEMP)) {
283: ntemp = regselect(tp, ntemp, 1);
284: if (ntemp < 0) {
285: consnap(10, "ntemp select\n");
286: goto again;
287: }
288: }
289: }
290: }
291: if (isrealreg(ntemp) && rp!=NULL) {
292: consnapv(15, "ntemp = %R\n", ntemp);
293: setused(tp, ntemp);
294: }
295: /* If the pattern specifies addressible
296: * subtrees and the subtrees are not directly
297: * addressible, then index registers will be
298: * required to hold the offset expression. */
299: lindex = rindex = -1;
300: if (ishlvadr(rpflag) && !isadr(rflag)) {
301: if (!isofs(rflag))
302: cbotch("no rofs");
303: ap = findoffs(rp);
304: if ((rindex = rallo(ap, tp->t_used, 2)) < 0) {
305: consnap(10, "rindex allo\n");
306: goto again;
307: }
308: consnapv(15, "rindex = %R\n", rindex);
309: curxreg |= reg[rindex].r_phys;
310: }
311: if (ishlvadr(lpflag) && !isadr(lflag)) {
312: if (!isofs(lflag))
313: cbotch("no lofs");
314: ap = findoffs(lp);
315: if ((lindex = rallo(ap, tp->t_used, 2)) < 0) {
316: consnap(10, "lindex allo\n");
317: goto again;
318: }
319: consnapv(15, "lindex = %R\n", lindex);
320: curxreg |= reg[lindex].r_phys;
321: }
322: consnap(10, "\n");
323: /* If the pattern specifies T_TREG, then
324: * the subtree must be selected. */
325: if ((rpflag&T_TREG) != 0) {
326: /* In case two TREG's are specified the ltemp
327: * must be identified and setbusy before the rtemp
328: * is loaded or ltemp may be clobbered. */
329:
330: /* Select an rtemp register based on the share flag,
331: * the rtemp preference, and the node preference */
332: if ((pflag&P_SRT) != 0
333: && (rtemp==ANYL || rtemp==ANYR)
334: && isrealreg(r)
335: && isusable(tp, c, r))
336: stemp = r;
337: else
338: stemp = reguse(rtemp, ntemp);
339: /* Select the subcontext depending on the register selected
340: * or the currently specified context */
341: sgoal = subgoal(c, stemp);
342: /* Now load the specified register or preferred type */
343: if (select(rp, sgoal, stemp) == 0)
344: goto again;
345: tp->t_used |= rp->t_used;
346: if ((pflag&P_SRT) != 0) {
347: if ((ntemp==ANYL || ntemp==ANYR)
348: && isusable(tp, c, rp->t_rreg))
349: ntemp = rp->t_rreg;
350: else if (patp->p_ntemp == patp->p_rtemp
351: && ntemp != rp->t_rreg) {
352: consnap(10, "rtemp share\n");
353: goto again;
354: }
355: } else
356: setbusy(rp->t_rreg); /* This is wrong */
357: /* Should be set busy after the ltemp load */
358:
359: /* If ltemp was setbusy above, it should now be freed */
360: }
361: if ((lpflag&T_TREG) != 0) {
362: if ((pflag&P_SLT) != 0
363: && (ltemp==ANYL || ltemp==ANYR)
364: && isrealreg(r)
365: && isusable(tp, c, r))
366: stemp = r;
367: else
368: stemp = reguse(ltemp, ntemp);
369: sgoal = subgoal(c, stemp);
370: if (select(lp, sgoal, stemp) == 0)
371: goto again;
372: tp->t_used |= lp->t_used;
373: if ((pflag&P_SLT) != 0) {
374: if ((ntemp==ANYL || ntemp==ANYR)
375: && isusable(tp, c, lp->t_rreg))
376: ntemp = lp->t_rreg;
377: else if (patp->p_ntemp == patp->p_ltemp
378: && ntemp != lp->t_rreg) {
379: consnap(10, "ltemp share\n");
380: goto again;
381: }
382: } else
383: setbusy(lp->t_rreg);
384: }
385: /* Now bind the node temporary if it hasn't already happened. */
386: if (!isrealreg(ntemp) && ntemp!=NONE) {
387: ntemp = regselect(tp, ntemp, 1);
388: if (ntemp < 0) {
389: consnap(10, "ntemp select\n");
390: goto again;
391: }
392: }
393: tp->t_treg = ntemp;
394: /* Keep temps used in node coercion off target path */
395: if (ntemp!=NONE && rp!=NULL)
396: setused(tp, ntemp);
397: /* Force ltemp and rtemp used */
398: if ((lpflag&T_TREG)==0 && isrealreg(patp->p_ltemp))
399: setused(tp, patp->p_ltemp);
400: if ((rpflag&T_TREG)==0 && isrealreg(patp->p_rtemp))
401: setused(tp, patp->p_rtemp);
402: /* Now coerce the subtrees into rv or lv addressibility
403: * if they do not naturally conform. */
404: didstore = 0;
405: if (selmiss(rpflag, rflag) && isrvadr(rpflag) && !isadr(rflag))
406: selrv(tp, 1, &didstore);
407: if (selmiss(lpflag, lflag) && isrvadr(lpflag) && !isadr(lflag))
408: selrv(tp, 0, &didstore);
409: if (selmiss(rpflag, rflag) && islvadr(rpflag) && !isadr(rflag))
410: sellv(tp, rindex, 1, &didstore);
411: if (selmiss(lpflag, lflag) && islvadr(lpflag) && !isadr(lflag))
412: sellv(tp, lindex, 0, &didstore);
413: /* If coercion generated a stack temp,
414: * then we must search the table again
415: * for a simpler pattern, after cleaning
416: * up any FIXUP's */
417: if (didstore) {
418: tp = ripout(tp, 0);
419: curbusy = savbusy;
420: curxreg = savxreg;
421: consnap(1, "Goto rematch\n");
422: goto rematch;
423: }
424: /* Make node temp used */
425: if (ntemp != NONE)
426: setused(tp, ntemp);
427: /* Compute the result register */
428: if ((rreg = patp->p_result) == TEMP)
429: rreg = ntemp;
430: else if (rreg == LOTEMP)
431: rreg = lohalf(ntemp);
432: else if (rreg == HITEMP)
433: rreg = hihalf(ntemp);
434: tp->t_rreg = rreg;
435: if (rreg != NONE)
436: setused(tp, rreg);
437: curbusy = savbusy;
438: curxreg = savxreg;
439: return (1);
440: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.