Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20050917075840

Diff

Diff from 1.34 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/mip/match.c

Annotated File View

ragge
1.34
1 /*      $Id: match.c,v 1.34 2005/09/17 07:58:40 ragge Exp $   */
2 /*
3  * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
ragge
1.13
29 /*
30  * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
31  *
32  * Redistribution and use in source and binary forms, with or without
33  * modification, are permitted provided that the following conditions
34  * are met:
35  *
36  * Redistributions of source code and documentation must retain the above
37  * copyright notice, this list of conditions and the following disclaimer.
38  * Redistributions in binary form must reproduce the above copyright
39  * notice, this list of conditionsand the following disclaimer in the
40  * documentation and/or other materials provided with the distribution.
41  * All advertising materials mentioning features or use of this software
42  * must display the following acknowledgement:
43  *      This product includes software developed or owned by Caldera
44  *      International, Inc.
45  * Neither the name of Caldera International, Inc. nor the names of other
46  * contributors may be used to endorse or promote products derived from
47  * this software without specific prior written permission.
48  *
49  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
50  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
51  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
52  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
53  * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
54  * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57  * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
58  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
59  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
60  * POSSIBILITY OF SUCH DAMAGE.
61  */
ragge
1.1
62
63 # include "pass2.h"
64
ragge
1.6
65 int e2print(NODE *pint downint *aint *b);
ragge
1.13
66 void prttype(int t);
ragge
1.1
67
68 int fldszfldshf;
69
ragge
1.9
70 int s2debug = 0;
ragge
1.1
71
ragge
1.34
72 extern char *ltyp[], *rtyp[];
73
ragge
1.2
74 /*
75  * return true if shape is appropriate for the node p
76  * side effect for SFLD is to set up fldsz, etc
77  */
78 int
79 tshape(NODE *pint shape)
80 {
81         int omask;
ragge
1.1
82
ragge
1.10
83         o = p->n_op;
ragge
1.1
84
ragge
1.13
85 #ifdef PCC_DEBUG
ragge
1.23
86         if (s2debug)
87                 printf("tshape(%p, %s) op = %s\n"pprcook(shape), opst[o]);
ragge
1.13
88 #endif
ragge
1.1
89
ragge
1.28
90         if (shape & SPECIAL) {
ragge
1.1
91
ragge
1.28
92                 switch (shape) {
ragge
1.1
93                 case SZERO:
94                 case SONE:
95                 case SMONE:
96                 case SSCON:
97                 case SCCON:
ragge
1.28
98                         if (o != ICON || p->n_name[0])
99                                 return SRNOPE;
100                         if (p->n_lval == 0 && shape == SZERO)
101                                 return SRDIR;
102                         if (p->n_lval == 1 && shape == SONE)
103                                 return SRDIR;
104                         if (p->n_lval == -1 && shape == SMONE)
105                                 return SRDIR;
106                         if (p->n_lval > -257 && p->n_lval < 256 &&
107                             shape == SCCON)
108                                 return SRDIR;
109                         if (p->n_lval > -32769 && p->n_lval < 32768 &&
110                             shape == SSCON)
111                                 return SRDIR;
112                         return SRNOPE;
ragge
1.1
113
114                 case SSOREG:    /* non-indexed OREG */
ragge
1.28
115                         if (o == OREG && !R2TEST(p->n_rval))
116                                 return SRDIR;
117                         return SRNOPE;
ragge
1.1
118
119                 default:
ragge
1.28
120                         return (special(pshape));
ragge
1.1
121                 }
ragge
1.28
122         }
ragge
1.1
123
ragge
1.28
124         if (shape & SANY)
125                 return SRDIR;
ragge
1.1
126
ragge
1.28
127         if ((shape&INTEMP) && shtemp(p))
128                 return SRDIR;
ragge
1.1
129
ragge
1.28
130         if ((shape&SWADD) && (o==NAME||o==OREG))
131                 if (BYTEOFF(p->n_lval))
132                         return SRNOPE;
ragge
1.1
133
ragge
1.28
134         switch (o) {
ragge
1.1
135
136         case NAME:
ragge
1.28
137                 if (shape & SNAME)
138                         return SRDIR;
139                 break;
140
ragge
1.1
141         case ICON:
ragge
1.28
142                 if (shape & SCON)
143                         return SRDIR;
144                 break;
ragge
1.1
145
146         case FLD:
ragge
1.28
147                 if (shape & SFLD) {
ragge
1.29
148                         int sh;
149
150                         if ((sh = flshape(p->n_left)) == SRNOPE)
151                                 return sh;
ragge
1.1
152                         /* it is a FIELD shape; make side-effects */
ragge
1.29
153                         /* XXX - this will not work for multi-matches */
ragge
1.10
154                         o = p->n_rval;
ragge
1.1
155                         fldsz = UPKFSZ(o);
156 # ifdef RTOLBYTES
157                         fldshf = UPKFOFF(o);
158 # else
159                         fldshf = SZINT - fldsz - UPKFOFF(o);
160 # endif
ragge
1.29
161                         return sh;
ragge
1.28
162                 }
163                 break;
ragge
1.1
164
165         case CCODES:
ragge
1.28
166                 if (shape & SCC)
167                         return SRDIR;
168                 break;
ragge
1.1
169
ragge
1.32
170         case TEMP/* temporaries are handled as registers */
ragge
1.34
171 #if 0
172                 mask = PCLASS(p);
ragge
1.32
173                 if (shape & mask)
ragge
1.33
174                         return SRREG/* let register allocator coalesce */
ragge
1.34
175 #endif
ragge
1.32
176                 break;
177
ragge
1.1
178         case REG:
ragge
1.34
179                 mask = PCLASS(p);
ragge
1.28
180                 if (shape & mask)
181                         return SRDIR;
182                 break;
ragge
1.1
183
184         case OREG:
ragge
1.28
185                 if (shape & SOREG)
186                         return SRDIR;
187                 break;
ragge
1.1
188
ragge
1.22
189         case UMUL:
ragge
1.28
190                 if (shumul(p->n_left) & shape)
191                         return SROREG;  /* Call offstar to do an OREG */
192                 break;
ragge
1.1
193
ragge
1.28
194         }
ragge
1.34
195 #ifdef SNH_REG
196         if (shape & PCLASS(p))
197                 return SRREG;   /* Can put in register */
198 #else
199         if (shape & (SAREG|SBREG))
ragge
1.28
200                 return SRREG;   /* Can put in register */
ragge
1.34
201 #endif
ragge
1.1
202
ragge
1.28
203         return SRNOPE;
204 }
ragge
1.1
205
ragge
1.2
206 /*
207  * does the type t match tword
208  */
209 int
210 ttype(TWORD tint tword)
211 {
212         if (tword & TANY)
213                 return(1);
ragge
1.1
214
ragge
1.13
215 #ifdef PCC_DEBUG
ragge
1.5
216         if (t2debug)
217                 printf("ttype(%o, %o)\n"ttword);
ragge
1.13
218 #endif
ragge
1.31
219         if (ISPTR(t) && ISFTN(DECREF(t)) && (tword & TFTN)) {
220                 /* For funny function pointers */
221                 return 1;
222         }
ragge
1.5
223         if (ISPTR(t) && (tword&TPTRTO)) {
ragge
1.1
224                 do {
225                         t = DECREF(t);
ragge
1.5
226                 } while (ISARY(t));
ragge
1.1
227                         /* arrays that are left are usually only
ragge
1.5
228                          * in structure references...
229                          */
230                 return (ttype(ttword&(~TPTRTO)));
231         }
232         if (t != BTYPE(t))
233                 return (tword & TPOINT); /* TPOINT means not simple! */
234         if (tword & TPTRTO)
235                 return(0);
ragge
1.1
236
ragge
1.5
237         switch (t) {
ragge
1.1
238         case CHAR:
239                 returntword & TCHAR );
240         case SHORT:
241                 returntword & TSHORT );
242         case STRTY:
243         case UNIONTY:
244                 returntword & TSTRUCT );
245         case INT:
246                 returntword & TINT );
247         case UNSIGNED:
248                 returntword & TUNSIGNED );
249         case USHORT:
250                 returntword & TUSHORT );
251         case UCHAR:
252                 returntword & TUCHAR );
253         case ULONG:
254                 returntword & TULONG );
255         case LONG:
256                 returntword & TLONG );
ragge
1.3
257         case LONGLONG:
258                 returntword & TLONGLONG );
259         case ULONGLONG:
260                 returntword & TULONGLONG );
ragge
1.1
261         case FLOAT:
262                 returntword & TFLOAT );
263         case DOUBLE:
264                 returntword & TDOUBLE );
ragge
1.30
265         case LDOUBLE:
266                 returntword & TLDOUBLE );
ragge
1.3
267         }
ragge
1.1
268
269         return(0);
ragge
1.5
270 }
ragge
1.1
271
ragge
1.2
272 /*
273  * generate code by interpreting table entry
274  */
275 void
276 expand(NODE *pint cookiechar *cp)
277 {
ragge
1.1
278         CONSZ val;
279
280         for( ; *cp; ++cp ){
281                 switch( *cp ){
282
283                 default:
284                         PUTCHAR( *cp );
285                         continue;  /* this is the usual case... */
286
287                 case 'Z':  /* special machine dependent operations */
288                         zzzcodep, *++cp );
289                         continue;
290
291                 case 'F':  /* this line deleted if FOREFF is active */
292                         ifcookie & FOREFF ) while( *++cp != '\n' ) ; /* VOID */
293                         continue;
294
295                 case 'S':  /* field size */
296                         printf"%d"fldsz );
297                         continue;
298
299                 case 'H':  /* field shift */
300                         printf"%d"fldshf );
301                         continue;
302
303                 case 'M':  /* field mask */
304                 case 'N':  /* complement of field mask */
305                         val = 1;
306                         val <<= fldsz;
307                         --val;
308                         val <<= fldshf;
309                         adrcon( *cp=='M' ? val : ~val );
310                         continue;
311
312                 case 'L':  /* output special label field */
ragge
1.11
313                         if (*++cp == 'C')
314                                 printf(LABFMTp->n_label);
315                         else
316                                 printf(LABFMT, (int)getlr(p,*cp)->n_lval);
ragge
1.1
317                         continue;
318
319                 case 'O':  /* opcode string */
ragge
1.10
320                         hopcode( *++cpp->n_op );
ragge
1.1
321                         continue;
322
323                 case 'B':  /* byte offset in word */
ragge
1.10
324                         val = getlr(p,*++cp)->n_lval;
ragge
1.1
325                         val = BYTEOFF(val);
326                         printfCONFMTval );
327                         continue;
328
329                 case 'C'/* for constant value only */
ragge
1.27
330                         conput(stdoutgetlrp, *++cp ) );
ragge
1.1
331                         continue;
332
333                 case 'I'/* in instruction */
334                         insputgetlrp, *++cp ) );
335                         continue;
336
337                 case 'A'/* address of */
ragge
1.24
338                         adrput(stdoutgetlrp, *++cp ) );
ragge
1.1
339                         continue;
340
341                 case 'U'/* for upper half of address, only */
ragge
1.15
342                         upput(getlr(p, *++cp), SZLONG);
ragge
1.1
343                         continue;
344
345                         }
346
347                 }
348
349         }
ragge
1.26
350
351 NODE resc[4];
ragge
1.1
352
353 NODE *
ragge
1.2
354 getlr(NODE *pint c)
355 {
ragge
1.25
356         NODE *q;
ragge
1.1
357
358         /* return the pointer to the left or right side of p, or p itself,
359            depending on the optype of p */
360
ragge
1.2
361         switch (c) {
ragge
1.1
362
363         case '1':
364         case '2':
365         case '3':
ragge
1.25
366                 c -= '1';
367                 q = &resc[c];
368                 q->n_op = REG;
369                 q->n_type = p->n_type/* ???? */
370                 q->n_rval = p->n_rall/* Should be assigned by genregs() */
371                 q->n_rval += szty(q->n_type) * c;
372                 return q;
ragge
1.1
373
374         case 'L':
ragge
1.10
375                 returnoptypep->n_op ) == LTYPE ? p : p->n_left );
ragge
1.1
376
377         case 'R':
ragge
1.10
378                 returnoptypep->n_op ) != BITYPE ? p : p->n_right );
ragge
1.1
379
ragge
1.2
380         }
ragge
1.1
381         cerror"bad getlr: %c"c );
382         /* NOTREACHED */
ragge
1.2
383         return NULL;
384 }
ragge
1.7
385
386 static char *tarr[] = {
387         "CHAR""SHORT""INT""LONG""FLOAT""DOUBLE""POINT""UCHAR",
388         "USHORT""UINT""ULONG""PTRTO""ANY""STRUCT""LONGLONG",
389         "ULONGLONG",
390 };
391
392 void
393 prttype(int t)
394 {
395         int igone = 0;
396
397         for (i = 0i < 16i++)
398                 if ((t >> i) & 1) {
399                         if (goneputchar('|');
400                         gone++;
401                         printf("%s"tarr[i]);
402                 }
403 }
ragge
1.34
404
405
406 static int shltab[] = { 00LOREGLREG };
407 static int shrtab[] = { 00ROREGRREG };
408
409 /*
410  * Find the best ops for a given tree. 
411  * Different instruction sequences are graded as:
412         add2 reg,reg     = 0
413         add2 mem,reg     = 1
414         add3 mem,reg,reg = 2
415         add3 reg,mem,reg = 2
416         add3 mem,mem,reg = 3
417         move mem,reg ; add2 mem,reg     = 4
418         move mem,reg ; add3 mem,reg,reg = 5
419         move mem,reg ; move mem,reg ; add2 reg,reg = 6
420         move mem,reg ; move mem,reg ; add3 reg,reg,reg = 7
421  * The instruction with the lowest grading is emitted.
422  */
423 int
424 findops(NODE *pint cookie)
425 {
426         extern int *qtable[];
427         struct optab *q;
428         int ishlshrtltris3;
429         NODE *l, *r;
430         int *ixp;
431         int rv = -1mtchno = 10;
432
433 if (f2debugprintf("findops tree:\n");
434 if (f2debugfwalk(pe2print0);
435
436         ixp = qtable[p->n_op];
437         for (i = 0ixp[i] >= 0i++) {
438                 q = &table[ixp[i]];
439
440 if (f2debugprintf("findop: ixp %d\n"ixp[i]);
441                 l = getlr(p'L');
442                 r = getlr(p'R');
443                 if (ttype(l->n_typeq->ltype) == 0 ||
444                     ttype(r->n_typeq->rtype) == 0)
445                         continue/* Types must be correct */
446
447 if (f2debugprintf("findop got types\n");
448                 if ((shl = tshape(lq->lshape)) == SRNOPE)
449                         continue/* useless */
450 if (f2debugprintf("findop lshape %d\n"shl);
451 if (f2debugfwalk(le2print0);
452                 if ((shr = tshape(rq->rshape)) == SRNOPE)
453                         continue/* useless */
454 if (f2debugprintf("findop rshape %d\n"shr);
455 if (f2debugfwalk(re2print0);
456                 if (q->needs & REWRITE)
457                         break;  /* Done here */
458
459                 tl = tr = 1;  /* XXX remove later */
460                 is3 = ((q->rewrite & (RLEFT|RRIGHT)) == 0);
461
462                 if (shl == SRDIR && shr== SRDIR ) {
463                         int got = 10;
464                         /*
465                          * Both shapes matches direct. If one of them is
466                          * in a temp register and there is a corresponding
467                          * 2-op instruction, be very happy. If not, but
468                          * there is a 3-op instruction that ends in a reg,
469                          * be quite happy. If neither, cannot do anything.
470                          */
471                         if (tl && (q->rewrite & RLEFT)) {
472                                 got = 1;
473                         } else if (tr && (q->rewrite & RRIGHT)) {
474                                 got = 1;
475                         } else if ((q->rewrite & (RLEFT|RRIGHT)) == 0) {
476                                 got = 3;
477                         }
478                         if (got < mtchno) {
479                                 mtchno = got;
480                                 rv = MKIDX(ixp[i], 0);
481                         }
482                         if (got != 10)
483                                 continue;
484                 }
485 if (f2debugprintf("second\n");
486                 if (shr == SRDIR) {
487                         /*
488                          * Right shape matched. If left node can be put into
489                          * a temporary register, and the current op matches,
490                          * be happy.
491                          */
492                         if (q->rewrite & RLEFT) {
493                                 if (4 < mtchno) {
494                                         mtchno = 4;
495                                         rv = MKIDX(ixp[i], LREG);
496                                 }
497                                 continue/* Can't do anything else */
498                         } else if (is3) {
499                                 if (5 < mtchno) {
500                                         mtchno = 5;
501                                         rv = MKIDX(ixp[i], shltab[shl]);
502                                 }
503                                 continue/* Can't do anything else */
504                         }
505                 }
506 if (f2debugprintf("third\n");
507                 if (shl == SRDIR) {
508                         /*
509                          * Left shape matched. If right node can be put into
510                          * a temporary register, and the current op matches,
511                          * be happy.
512                          */
513                         if (q->rewrite & RRIGHT) {
514                                 if (4 < mtchno) {
515                                         mtchno = 4;
516                                         rv = MKIDX(ixp[i], RREG);
517                                 }
518                                 continue/* Can't do anything */
519                         } else if (is3) {
520                                 if (5 < mtchno) {
521                                         mtchno = 5;
522                                         rv = MKIDX(ixp[i], shrtab[shr]);
523                                 }
524                                 continue/* Can't do anything */
525                         }
526                 }
527                 /*
528                  * Neither of the shapes matched. Put both args in 
529                  * regs and be done with it.
530                  */
531                 if (is3) {
532                         if (7 < mtchno) {
533                                 mtchno = 7;
534                                 rv = MKIDX(ixp[i], shltab[shl]|shrtab[shr]);
535                         }
536                 } else {
537                         if (6 < mtchno) {
538                                 mtchno = 6;
539                                 if (q->rewrite & RLEFT)
540                                         rv = MKIDX(ixp[i], shrtab[shr]|LREG);
541                                 else
542                                         rv = MKIDX(ixp[i], shltab[shl]|RREG);
543                         }
544                 }
545         }
546 #ifdef PCC_DEBUG
547         if (f2debug) {
548                 if (rv == -1)
549                         printf("findops failed\n");
550                 else
551                         printf("findops entry %d(%s %s)\n",
552                             TBLIDX(rv), ltyp[rv & LMASK], rtyp[(rv&RMASK)>>2]);
553         }
554 #endif
555         return rv;
556 }
557
558 /*
559  * Find the best relation op for matching the two trees it has.
560  * This is a sub-version of the function findops() above.
561  * The instruction with the lowest grading is emitted.
562  *
563  * Level assignment for priority:
564  *      left    right   prio
565  *      -       -       -
566  *      direct  direct  1
567  *      direct  OREG    2       # make oreg
568  *      OREG    direct  2       # make oreg
569  *      OREG    OREG    2       # make both oreg
570  *      direct  REG     3       # put in reg
571  *      OREG    REG     3       # put in reg, make oreg
572  *      REG     direct  3       # put in reg
573  *      REG     OREG    3       # put in reg, make oreg
574  *      REG     REG     4       # put both in reg
575  */
576 int
577 relops(NODE *p)
578 {
579         extern int *qtable[];
580         struct optab *q;
581         int ishlshr;
582         NODE *l, *r;
583         int *ixp;
584         int rv = -1mtchno = 10;
585
586 if (f2debugprintf("relops tree:\n");
587 if (f2debugfwalk(pe2print0);
588
589         ixp = qtable[p->n_op];
590         for (i = 0ixp[i] >= 0i++) {
591                 q = &table[ixp[i]];
592
593 if (f2debugprintf("relops: ixp %d\n"ixp[i]);
594                 l = getlr(p'L');
595                 r = getlr(p'R');
596                 if (ttype(l->n_typeq->ltype) == 0 ||
597                     ttype(r->n_typeq->rtype) == 0)
598                         continue/* Types must be correct */
599
600 if (f2debugprintf("relops got types\n");
601                 shl = tshape(lq->lshape);
602                 if (shl == 0)
603                         continue/* useless */
604 if (f2debugprintf("relops lshape %d\n"shl);
605 if (f2debugfwalk(le2print0);
606                 shr = tshape(rq->rshape);
607                 if (shr == 0)
608                         continue/* useless */
609 if (f2debugprintf("relops rshape %d\n"shr);
610 if (f2debugfwalk(re2print0);
611                 if (q->needs & REWRITE)
612                         break;  /* Done here */
613
614                 if (shl+shr < mtchno) {
615                         mtchno = shl+shr;
616                         rv = MKIDX(ixp[i], shltab[shl]|shrtab[shr]);
617                 }
618         }
619 #ifdef PCC_DEBUG
620         if (f2debug) {
621                 if (rv == -1)
622                         printf("relops failed\n");
623                 else
624                         printf("relops entry %d(%s %s)\n",
625                             TBLIDX(rv), ltyp[rv & LMASK], rtyp[(rv&RMASK)>>2]);
626         }
627 #endif
628         return rv;
629 }
630
631 /*
632  * Find a matching assign op.
633  *
634  * Level assignment for priority:
635  *      left    right   prio
636  *      -       -       -
637  *      direct  direct  1
638  *      direct  REG     2
639  *      direct  OREG    3
640  *      OREG    direct  4
641  *      OREG    REG     5
642  *      OREG    OREG    6
643  */
644 int
645 findasg(NODE *pint cookie)
646 {
647         extern int *qtable[];
648         struct optab *q;
649         int ishlshrlvl = 10;
650         NODE *l, *r;
651         int *ixp;
652         int rv = -1;
653
654 #ifdef PCC_DEBUG
655         if (f2debug) {
656                 printf("findasg tree: %s\n"prcook(cookie));
657                 fwalk(pe2print0);
658         }
659 #endif
660
661         ixp = qtable[p->n_op];
662         for (i = 0ixp[i] >= 0i++) {
663                 q = &table[ixp[i]];
664
665 if (f2debugprintf("asgop: ixp %d\n"ixp[i]);
666                 l = getlr(p'L');
667                 r = getlr(p'R');
668                 if (ttype(l->n_typeq->ltype) == 0 ||
669                     ttype(r->n_typeq->rtype) == 0)
670                         continue/* Types must be correct */
671
672                 if ((cookie & (INTAREG|INTBREG)) &&
673                     (q->rewrite & (RLEFT|RRIGHT)) == 0)
674                         continue/* must get a result somehere */
675
676 if (f2debugprintf("asgop got types\n");
677                 if ((shl = tshape(lq->lshape)) == SRNOPE)
678                         continue;
679
680                 if (p->n_left->n_op == TEMP)
681                         shl = SRDIR;
682                 else if (shl == SRREG)
683                         continue;
684
685 if (f2debugprintf("asgop lshape %d\n"shl);
686 if (f2debugfwalk(le2print0);
687
688                 if ((shr = tshape(rq->rshape)) == SRNOPE)
689                         continue/* useless */
690
691 if (f2debugprintf("asgop rshape %d\n"shr);
692 if (f2debugfwalk(re2print0);
693                 if (q->needs & REWRITE)
694                         break;  /* Done here */
695
696                 if (lvl <= (shl + shr))
697                         continue;
698                 lvl = shl + shr;
699                 
700                 rv = MKIDX(ixp[i], shltab[shl]|shrtab[shr]);
701         }
702 #ifdef PCC_DEBUG
703         if (f2debug) {
704                 if (rv == -1)
705                         printf("findasg failed\n");
706                 else
707                         printf("findasg entry %d(%s %s)\n",
708                             TBLIDX(rv), ltyp[rv & LMASK], rtyp[(rv&RMASK)>>2]);
709         }
710 #endif
711         return rv;
712 }
713
714 /*
715  * Find an ASSIGN node that puts the value into a register.
716  */
717 int
718 findleaf(NODE *pint cookie)
719 {
720         extern int *qtable[];
721         struct optab *q;
722         int ishl;
723         int *ixp;
724         int rv = -1;
725
726 #ifdef PCC_DEBUG
727         if (f2debug) {
728                 printf("findleaf tree: %s\n"prcook(cookie));
729                 fwalk(pe2print0);
730         }
731 #endif
732
733         ixp = qtable[p->n_op];
734         for (i = 0ixp[i] >= 0i++) {
735                 q = &table[ixp[i]];
736
737 if (f2debugprintf("findleaf: ixp %d\n"ixp[i]);
738                 if (ttype(p->n_typeq->rtype) == 0)
739                         continue/* Type must be correct */
740
741 if (f2debugprintf("findleaf got types\n");
742                 if ((shl = tshape(pq->rshape)) != SRDIR && p->n_op != TEMP)
743                         continue/* shape must match */
744
745                 if ((q->visit & cookie) == 0)
746                         continue/* wrong registers */
747
748 if (f2debugprintf("findleaf got shapes %d\n"shl);
749
750                 if (q->needs & REWRITE)
751                         break;  /* Done here */
752
753                 rv = MKIDX(ixp[i], 0);
754                 break;
755         }
756         if (f2debug) { 
757                 if (rv == -1)
758                         printf("findleaf failed\n");
759                 else
760                         printf("findleaf entry %d(%s %s)\n",
761                             TBLIDX(rv), ltyp[rv & LMASK], rtyp[(rv&RMASK)>>2]);
762         }
763         return rv;
764 }
765
766 /*
767  * Find a UNARY op that satisfy the needs.
768  * For now, the destination is always a register.
769  * Both source and dest types must match, but only source (left)
770  * shape is of interest.
771  */
772 int
773 finduni(NODE *pint cookie)
774 {
775         extern int *qtable[];
776         struct optab *q;
777         NODE *l, *r;
778         int ishlnum = 4;
779         int *ixp;
780         int rv = -1;
781
782 #ifdef PCC_DEBUG
783         if (f2debug) {
784                 printf("finduni tree: %s\n"prcook(cookie));
785                 fwalk(pe2print0);
786         }
787 #endif
788
789         l = getlr(p'L');
790         r = getlr(p'R');
791         ixp = qtable[p->n_op];
792         for (i = 0ixp[i] >= 0i++) {
793                 q = &table[ixp[i]];
794
795 if (f2debugprintf("finduni: ixp %d\n"ixp[i]);
796                 if (ttype(l->n_typeq->ltype) == 0)
797                         continue/* Type must be correct */
798
799 if (f2debugprintf("finduni got left type\n");
800                 if (ttype(r->n_typeq->rtype) == 0)
801                         continue/* Type must be correct */
802
803 if (f2debugprintf("finduni got types\n");
804                 if ((shl = tshape(lq->lshape)) == SRNOPE)
805                         continue/* shape must match */
806
807 if (f2debugprintf("finduni got shapes %d\n"shl);
808
809                 if ((cookie & q->visit) == 0)   /* check correct return value */
810                         continue;               /* XXX - should check needs */
811
812 if (f2debugprintf("finduni got cookie\n");
813                 if (q->needs & REWRITE)
814                         break;  /* Done here */
815
816                 if (shl >= num)
817                         continue;
818                 num = shl;
819                 rv = MKIDX(ixp[i], shltab[shl]);
820                 if ((q->lshape & (SBREG)) && !(q->lshape & (SAREG)))
821                         rv |= LBREG;
822                 if (shl == SRDIR)
823                         break;
824         }
825 #ifdef PCC_DEBUG
826         if (f2debug) { 
827                 if (rv == -1)
828                         printf("finduni failed\n");
829                 else
830                         printf("finduni entry %d(%s %s)\n",
831                             TBLIDX(rv), ltyp[rv & LMASK], rtyp[(rv&RMASK)>>2]);
832         }
833 #endif
834         return rv;
835 }
FishEye: Open Source License registered to PCC.
Your maintenance has expired. You can renew your license at http://www.atlassian.com/fisheye/renew
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-09-02 11:08 +0200