Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030803104938

Diff

Diff from 1.34 to:

Annotations

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

Annotated File View

ragge
1.34
1 /*      $Id: reader.c,v 1.34 2003/08/03 10:49:39 ragge Exp $    */
ragge
1.31
2 /*
3  * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * Redistributions of source code and documentation must retain the above
10  * copyright notice, this list of conditions and the following disclaimer.
11  * Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditionsand the following disclaimer in the
13  * documentation and/or other materials provided with the distribution.
14  * All advertising materials mentioning features or use of this software
15  * must display the following acknowledgement:
16  *      This product includes software developed or owned by Caldera
17  *      International, Inc.
18  * Neither the name of Caldera International, Inc. nor the names of other
19  * contributors may be used to endorse or promote products derived from
20  * this software without specific prior written permission.
21  *
22  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
23  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26  * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
27  * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
31  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
32  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
33  * POSSIBILITY OF SUCH DAMAGE.
34  */
ragge
1.1
35
36 # include "pass2.h"
37
38 /*      some storage declarations */
ragge
1.26
39 /*
40  * TODO: re-invent autoincr()/deltest()
41  */
ragge
1.1
42
43 int nrecur;
44 int lflag;
ragge
1.9
45 int x2debug;
ragge
1.1
46 int udebug = 0;
ragge
1.32
47 int ftnno;
ragge
1.1
48
49 OFFSZ tmpoff;  /* offset for first temporary, in bits for current block */
50 OFFSZ maxoff;  /* maximum temporary offset over all blocks in current ftn, in bits */
51 int maxtreg;
52
53 NODE *stotree;
54 int stocook;
55
56 OFFSZ baseoff = 0;
57 OFFSZ maxtemp = 0;
58
ragge
1.23
59 static struct templst {
60         struct templst *next;
61         int tempnr;
62         int tempoff;
63 } *templst;
64
ragge
1.10
65 int e2print(NODE *pint downint *aint *b);
ragge
1.29
66 void cbranch(NODE *pint false);
ragge
1.26
67
68 #ifdef PCC_DEBUG
69 static void
70 cktree(NODE *p)
71 {
72         if (p->n_op > MAXOP)
73                 cerror("op %d slipped through"p->n_op);
74 }
75 #endif
ragge
1.8
76
ragge
1.17
77 static void
ragge
1.2
78 p2compile(NODE *p)
79 {
ragge
1.15
80 #if !defined(MULTIPASS)
81         extern char *ftitle;
82 #endif
ragge
1.1
83
ragge
1.14
84         if (lflag)
85                 lineid(linenoftitle);
86
ragge
1.1
87         /* generate code for the tree p */
ragge
1.26
88 #ifdef PCC_DEBUG
89         walkf(pcktree);
90         if (e2debug)
91                 fwalk(pe2print0);
92 #endif
ragge
1.25
93
ragge
1.1
94 # ifdef MYREADER
95         MYREADER(p);  /* do your own laundering of the input */
96 # endif
97         nrecur = 0;
ragge
1.25
98         codgen(pFOREFF);
ragge
1.1
99         reclaimpRNULL0 );
100         allchk();
101         /* can't do tcheck here; some stuff (e.g., attributes) may be around from first pass */
102         /* first pass will do it... */
ragge
1.2
103 }
ragge
1.1
104
ragge
1.17
105 static void newblock(int myregint aoff);
106 static void epilogue(int regsint autosint retlab);
107
ragge
1.2
108 void
ragge
1.17
109 pass2_compile(struct interpass *ip)
110 {
111         switch (ip->type) {
112         case IP_NODE:
113                 p2compile(ip->ip_node);
ragge
1.21
114                 tfree(ip->ip_node);
ragge
1.17
115                 break;
116         case IP_PROLOG:
117                 prologue(ip->ip_regsip->ip_auto);
118                 break;
119         case IP_NEWBLK:
120                 newblock(ip->ip_regsip->ip_auto);
121                 break;
122         case IP_EPILOG:
123                 epilogue(ip->ip_regsip->ip_autoip->ip_retl);
ragge
1.18
124                 break;
125         case IP_LOCCTR:
126                 setlocc(ip->ip_locc);
127                 break;
128         case IP_DEFLAB:
129                 deflab(ip->ip_lbl);
130                 break;
131         case IP_DEFNAM:
132                 defname(ip->ip_nameip->ip_vis);
133                 break;
ragge
1.17
134         default:
135                 cerror("pass2_compile %d"ip->type);
136         }
137 }
138
139 static void
ragge
1.16
140 newblock(int myregint aoff)
ragge
1.2
141 {
ragge
1.1
142         static int myftn = -1;
143
ragge
1.30
144         tmpoff = baseoff = aoff;
ragge
1.1
145         maxtreg = myreg;
146         ifmyftn != ftnno ){ /* beginning of function */
147                 maxoff = baseoff;
148                 myftn = ftnno;
149                 maxtemp = 0;
150                 }
151         else {
152                 ifbaseoff > maxoff ) maxoff = baseoff;
153                 /* maxoff at end of ftn is max of autos and temps over all blocks */
154                 }
155         setregs();
ragge
1.2
156 }
ragge
1.1
157
ragge
1.17
158 static void
ragge
1.16
159 epilogue(int regsint autosint retlab)
ragge
1.2
160 {
ragge
1.16
161         SETOFF(maxoffALSTACK);
ragge
1.23
162         templst = NULL;
ragge
1.16
163         eoftn(regsautosretlab);
ragge
1.2
164 }
ragge
1.1
165
ragge
1.2
166 /*
167  * generate the code for p;
168  * order may call codgen recursively
169  * cookie is used to describe the context
170  */
171 void
172 codgen(NODE *pint cookie)
173 {
ragge
1.1
174
ragge
1.8
175         for (;;) {
ragge
1.1
176                 canon(p);  /* creats OREG from * if possible and does sucomp */
177                 stotree = NIL;
ragge
1.30
178 #ifdef PCC_DEBUG
ragge
1.8
179                 if (e2debug) {
180                         printf("store called on:\n");
181                         fwalk(pe2print0);
182                 }
ragge
1.30
183 #endif
ragge
1.1
184                 store(p);
185                 ifstotree==NIL ) break;
186
187                 /* because it's minimal, can do w.o. stores */
188
189                 orderstotreestocook );
ragge
1.2
190         }
ragge
1.1
191         orderpcookie );
ragge
1.2
192 }
ragge
1.1
193
ragge
1.30
194 #ifdef PCC_DEBUG
ragge
1.1
195 char *cnames[] = {
196         "SANY",
197         "SAREG",
198         "STAREG",
199         "SBREG",
200         "STBREG",
201         "SCC",
202         "SNAME",
203         "SCON",
204         "SFLD",
205         "SOREG",
206         "STARNM",
207         "STARREG",
208         "INTEMP",
209         "FORARG",
210         "SWADD",
211         0,
212         };
213
ragge
1.2
214 /*
215  * print a nice-looking description of cookie
216  */
217 void
218 prcook(int cookie)
219 {
ragge
1.1
220         int iflag;
221
222         ifcookie & SPECIAL ){
223                 ifcookie == SZERO ) printf"SZERO" );
224                 else ifcookie == SONE ) printf"SONE" );
225                 else ifcookie == SMONE ) printf"SMONE" );
226                 else printf"SPECIAL+%d"cookie & ~SPECIAL );
227                 return;
228                 }
229
230         flag = 0;
231         fori=0cnames[i]; ++i ){
232                 ifcookie & (1<<i) ){
233                         ifflag ) printf"|" );
234                         ++flag;
235                         printfcnames[i] );
236                         }
237                 }
238
ragge
1.2
239 }
ragge
1.30
240 #endif
ragge
1.1
241
242 int odebug = 0;
243
ragge
1.2
244 void
245 order(NODE *pint cook)
246 {
247         int otym;
ragge
1.1
248         int cookie;
ragge
1.2
249         NODE *p1, *p2;
ragge
1.1
250
ragge
1.8
251         /*
252          * by this time, p should be able to be generated without stores;
253          * the only question is how
254          */
ragge
1.1
255         again:
256
ragge
1.13
257         if (p->n_op == FREE)
ragge
1.19
258                 cerror("order");        /* whole tree was done */
ragge
1.1
259         cookie = cook;
260         rcount();
261         canon(p);
ragge
1.13
262         rallo(pp->n_rall);
ragge
1.1
263
ragge
1.30
264 #ifdef PCC_DEBUG
ragge
1.8
265         if (odebug) {
266                 printf("order(%p, "p);
267                 prcook(cookie);
268                 printf(")\n");
269                 fwalk(pe2print0);
270         }
ragge
1.30
271 #endif
ragge
1.1
272
ragge
1.13
273         o = p->n_op;
ragge
1.1
274         ty = optype(o);
275
276         /* first of all, for most ops, see if it is in the table */
277
278         /* look for ops */
279
ragge
1.13
280         switch (m = p->n_op) {
ragge
1.1
281
282         default:
283                 /* look for op in table */
ragge
1.8
284                 for (;;) {
285                         if ((m = match(pcookie)) == MDONE)
286                                 goto cleanup;
287                         else if (m == MNOPE) {
288                                 if (!(cookie = nextcook(pcookie)))
289                                         goto nomat;
ragge
1.1
290                                 continue;
ragge
1.8
291                         } else
292                                 break;
293                 }
ragge
1.1
294                 break;
295
296         case FORCE:
297         case CBRANCH:
298         case UNARY CALL:
299         case CALL:
300         case UNARY STCALL:
301         case STCALL:
302         case UNARY FORTCALL:
303         case FORTCALL:
304                 /* don't even go near the table... */
305                 ;
306
ragge
1.8
307         }
ragge
1.25
308         /*
ragge
1.8
309          * get here to do rewriting if no match or
310          * fall through from above for hard ops
311          */
ragge
1.1
312
ragge
1.13
313         p1 = p->n_left;
ragge
1.8
314         if (ty == BITYPE)
ragge
1.13
315                 p2 = p->n_right;
ragge
1.8
316         else
317                 p2 = NIL;
ragge
1.1
318         
ragge
1.30
319 #ifdef PCC_DEBUG
ragge
1.8
320         if (odebug) {
321                 printf("order(%p, "p);
322                 prcook(cook);
323                 printf("), cookie ");
324                 prcook(cookie);
325                 printf(", rewrite %s\n"opst[m]);
326         }
ragge
1.30
327 #endif
ragge
1.8
328         switch (m) {
ragge
1.1
329         default:
330                 nomat:
ragge
1.13
331                 cerror"no table entry for op %s"opst[p->n_op] );
ragge
1.1
332
333         case FORCE:
334                 /* recurse, letting the work be done by rallo */
335                 cook = INTAREG|INTBREG;
ragge
1.19
336                 order(p->n_leftcook);
337                 reclaim(pRLEFTcook);
ragge
1.1
338                 goto again;
339
340         case CBRANCH:
ragge
1.13
341                 o = p2->n_lval;
ragge
1.29
342                 cbranchp1o );
ragge
1.19
343                 nfree(p2);
344                 nfree(p);
ragge
1.1
345                 return;
346
347         case FLD:       /* fields of funny type */
ragge
1.13
348                 if ( p1->n_op == UNARY MUL ){
349                         offstarp1->n_left );
ragge
1.1
350                         goto again;
351                         }
352
353         case UNARY MINUS:
ragge
1.30
354                 orderp1INBREG|INAREG);
ragge
1.1
355                 goto again;
356
357         case NAME:
358                 /* all leaves end up here ... */
359                 ifo == REG ) goto nomat;
360                 orderpINTAREG|INTBREG );
361                 goto again;
362
363         case INIT:
ragge
1.12
364                 uerror("init: illegal initialization");
ragge
1.1
365                 return;
366
367         case UNARY FORTCALL:
ragge
1.13
368                 p->n_right = NIL;
ragge
1.1
369         case FORTCALL:
ragge
1.13
370                 o = p->n_op = UNARY FORTCALL;
ragge
1.1
371                 ifgenfcallpcookie ) ) goto nomat;
372                 goto cleanup;
373
374         case UNARY CALL:
ragge
1.13
375                 p->n_right = NIL;
ragge
1.1
376         case CALL:
ragge
1.13
377                 o = p->n_op = UNARY CALL;
ragge
1.1
378                 ifgencallpcookie ) ) goto nomat;
379                 goto cleanup;
380
381         case UNARY STCALL:
ragge
1.13
382                 p->n_right = NIL;
ragge
1.1
383         case STCALL:
ragge
1.13
384                 o = p->n_op = UNARY STCALL;
ragge
1.1
385                 ifgenscallpcookie ) ) goto nomat;
386                 goto cleanup;
387
388                 /* if arguments are passed in register, care must be taken that reclaim
ragge
1.2
389                  * not throw away the register which now has the result... */
ragge
1.1
390
391         case UNARY MUL:
392                 ifcook == FOREFF ){
393                         /* do nothing */
ragge
1.13
394                         orderp->n_leftFOREFF );
ragge
1.19
395                         nfree(p);
ragge
1.1
396                         return;
ragge
1.19
397                 }
ragge
1.30
398                 offstarp->n_left );
399 #if 0
400                 canon(p);
401                 ifcanaddr(p) && cook != INTEMP )
402                         goto cleanup;
ragge
1.1
403 #endif
404                 goto again;
405
406         case INCR:  /* INCR and DECR */
407                 ifsetincr(p) ) goto again;
408
409                 /* x++ becomes (x += 1) -1; */
410
411                 ifcook & FOREFF ){  /* result not needed so inc or dec and be done with it */
412                         /* x++ => x += 1 */
ragge
1.13
413                         p->n_op = (p->n_op==INCR)?ASG PLUS:ASG MINUS;
ragge
1.1
414                         goto again;
415                         }
416
417                 p1 = tcopy(p);
ragge
1.13
418                 reclaimp->n_leftRNULL0 );
419                 p->n_left = p1;
420                 p1->n_op = (p->n_op==INCR)?ASG PLUS:ASG MINUS;
421                 p->n_op = (p->n_op==INCR)?MINUS:PLUS;
ragge
1.1
422                 goto again;
423
424         case STASG:
425                 ifsetstrp ) ) goto again;
426                 goto nomat;
427
428         case ASG PLUS:  /* and other assignment ops */
429                 ifsetasop(p) ) goto again;
430
431                 /* there are assumed to be no side effects in LHS */
432
433                 p2 = tcopy(p);
ragge
1.13
434                 p->n_op = ASSIGN;
435                 reclaimp->n_rightRNULL0 );
436                 p->n_right = p2;
ragge
1.1
437                 canon(p);
ragge
1.13
438                 rallopp->n_rall );
ragge
1.1
439
ragge
1.30
440 #ifdef PCC_DEBUG
ragge
1.8
441                 ifodebug ) fwalkpe2print0 );
ragge
1.30
442 #endif
ragge
1.1
443
ragge
1.13
444                 orderp2->n_leftINTBREG|INTAREG );
ragge
1.1
445                 orderp2INTBREG|INTAREG );
446                 goto again;
447
448         case ASSIGN:
ragge
1.8
449                 if (setasg(p))
450                         goto again;
ragge
1.1
451                 goto nomat;
452
453
454         case BITYPE:
455                 ifsetbinp ) ) goto again;
456                 /* try to replace binary ops by =ops */
457                 switch(o){
458
459                 case PLUS:
460                 case MINUS:
461                 case MUL:
462                 case DIV:
463                 case MOD:
464                 case AND:
465                 case OR:
466                 case ER:
467                 case LS:
468                 case RS:
ragge
1.13
469                         p->n_op = ASG o;
ragge
1.1
470                         goto again;
471                         }
472                 goto nomat;
473
474                 }
475
476         cleanup:
477
478         /* if it is not yet in the right state, put it there */
479
480         ifcook & FOREFF ){
481                 reclaimpRNULL0 );
482                 return;
483                 }
484
ragge
1.13
485         ifp->n_op==FREE ) return;
ragge
1.1
486
487         iftshapepcook ) ) return;
488
489         if( (m=match(p,cook) ) == MDONE ) return;
490
491         /* we are in bad shape, try one last chance */
ragge
1.8
492         if (lastchance(pcook))
493                 goto again;
ragge
1.1
494
495         goto nomat;
ragge
1.8
496 }
ragge
1.1
497
498 int callflag;
499 int fregs;
500
ragge
1.2
501 void
502 storep ) NODE *p; {
ragge
1.1
503
504         /* find a subtree of p which should be stored */
505
ragge
1.2
506         int oty;
ragge
1.1
507
ragge
1.13
508         o = p->n_op;
ragge
1.1
509         ty = optype(o);
510
511         ifty == LTYPE ) return;
512
513         switcho ){
514
515         case UNARY CALL:
516         case UNARY FORTCALL:
517         case UNARY STCALL:
518                 ++callflag;
519                 break;
520
521         case UNARY MUL:
ragge
1.13
522                 if (asgop(p->n_left->n_op))
523                         stoasg(p->n_leftUNARY MUL);
ragge
1.1
524                 break;
525
526         case CALL:
527         case FORTCALL:
528         case STCALL:
ragge
1.13
529                 storep->n_left );
530                 stoargp->n_righto );
ragge
1.1
531                 ++callflag;
532                 return;
533
534         case CBRANCH:   /* to prevent complicated expressions on the LHS from being stored */
ragge
1.13
535                 constorep->n_left );
ragge
1.1
536                 return;
537
538                 }
539
ragge
1.11
540         if (ty == UTYPE) {
ragge
1.13
541                 store(p->n_left);
ragge
1.1
542                 return;
ragge
1.11
543         }
ragge
1.1
544
ragge
1.13
545         if (asgop(p->n_right->n_op))
546                 stoasg(p->n_righto);
ragge
1.1
547
ragge
1.13
548         ifp->n_su>fregs ){ /* must store */
ragge
1.1
549                 mkadrsp );  /* set up stotree and stocook to subtree
550                                  that must be stored */
551                 }
552
ragge
1.13
553         storep->n_right );
554         storep->n_left );
ragge
1.1
555         }
556
ragge
1.2
557 /*
558  * store conditional expressions
559  * the point is, avoid storing expressions in conditional
560  * conditional context, since the evaluation order is predetermined
561  */
562 void
563 constore(NODE *p)
564 {
ragge
1.1
565         storep );
ragge
1.2
566 }
ragge
1.1
567
ragge
1.2
568 /* mark off calls below the current node */
569 void
570 markcall(NODE *p)
571 {
ragge
1.1
572
573         again:
ragge
1.13
574         switchp->n_op ){
ragge
1.1
575
576         case UNARY CALL:
577         case UNARY STCALL:
578         case UNARY FORTCALL:
579         case CALL:
580         case STCALL:
581         case FORTCALL:
582                 ++callflag;
583                 return;
584
585                 }
586
ragge
1.13
587         switchoptypep->n_op ) ){
ragge
1.1
588
589         case BITYPE:
ragge
1.13
590                 markcallp->n_right );
ragge
1.1
591         case UTYPE:
ragge
1.13
592                 p = p->n_left;
ragge
1.1
593                 /* eliminate recursion (aren't I clever...) */
594                 goto again;
595         case LTYPE:
596                 return;
597                 }
598
ragge
1.2
599 }
ragge
1.1
600
ragge
1.2
601 void
602 stoarg(NODE *pint calltype)
603 {
ragge
1.1
604         /* arrange to store the args */
ragge
1.13
605         ifp->n_op == CM ){
606                 stoargp->n_leftcalltype );
607                 p = p->n_right ;
ragge
1.1
608                 }
609         ifcalltype == CALL ){
610                 STOARG(p);
611                 }
612         else ifcalltype == STCALL ){
613                 STOSTARG(p);
614                 }
615         else {
616                 STOFARG(p);
617                 }
618         callflag = 0;
619         store(p);
ragge
1.30
620 #ifdef NO_NESTCALLS
ragge
1.1
621         ifcallflag ){ /* prevent two calls from being active at once  */
622                 SETSTO(p,INTEMP);
623                 store(p); /* do again to preserve bottom up nature....  */
ragge
1.2
624         }
ragge
1.1
625 #endif
ragge
1.2
626 }
ragge
1.1
627
628 int negrel[] = { NEEQGTGELTLEUGTUGEULTULE } ;  /* negatives of relationals */
629
ragge
1.2
630 /*
631  * evaluate p for truth value, and branch to true or false
632  * accordingly: label <0 means fall through
633  */
634
635 void
ragge
1.29
636 cbranch(NODE *pint false)
ragge
1.2
637 {
ragge
1.29
638         switch (p->n_op) {
ragge
1.1
639
640         case ULE:
641         case ULT:
642         case UGE:
643         case UGT:
644         case EQ:
645         case NE:
646         case LE:
647         case LT:
648         case GE:
649         case GT:
ragge
1.29
650                 p->n_label = false;
651                 codgen(pFORCC);
652                 reclaim(pRNULL0);
ragge
1.1
653                 return;
654
655         case ICON:
ragge
1.29
656                 if (p->n_type != FLOAT && p->n_type != DOUBLE) {
ragge
1.34
657                         if ((p->n_lval != 0) || (p->n_name[0] != 0))
ragge
1.29
658                                 cbgen(0false'I');
ragge
1.19
659                         nfree(p);
ragge
1.1
660                         return;
ragge
1.19
661                 }
ragge
1.1
662                 /* fall through to default with other strange constants */
663
664         default:
665                 /* get condition codes */
ragge
1.29
666                 codgen(pFORCC);
ragge
1.34
667                 cbgen(NEfalse'I');
ragge
1.29
668                 reclaim(pRNULL0);
ragge
1.1
669                 return;
670
671         }
ragge
1.29
672 }
ragge
1.1
673
ragge
1.2
674 void
675 rcount()
676 /* count recursions */
ragge
1.1
677         if( ++nrecur > NRECUR ){
678                 cerror"expression causes compiler loop: try simplifying" );
679         }
ragge
1.2
680 }
ragge
1.1
681
ragge
1.30
682 #ifdef PCC_DEBUG
ragge
1.2
683 int
ragge
1.8
684 e2print(NODE *pint downint *aint *b)
ragge
1.2
685 {
ragge
1.1
686
687         *a = *b = down+1;
688         whiledown >= 2 ){
689                 printf"\t" );
690                 down -= 2;
691                 }
692         ifdown-- ) printf"    " );
693
694
ragge
1.13
695         printf"%p) %s"popst[p->n_op] );
696         switchp->n_op ) { /* special cases */
ragge
1.1
697
698         case REG:
ragge
1.13
699                 printf" %s"rnames[p->n_rval] );
ragge
1.1
700                 break;
701
ragge
1.23
702         case TEMP:
703                 printf(" %d", (int)p->n_lval);
704                 break;
705
ragge
1.1
706         case ICON:
707         case NAME:
708         case OREG:
709                 printf" " );
710                 adrputp );
711                 break;
712
713         case STCALL:
714         case UNARY STCALL:
715         case STARG:
716         case STASG:
ragge
1.13
717                 printf" size=%d"p->n_stsize );
718                 printf" align=%d"p->n_stalign );
ragge
1.1
719                 break;
720                 }
721
722         printf", " );
ragge
1.33
723         tprintp->n_typep->n_qual);
ragge
1.1
724         printf", " );
ragge
1.13
725         ifp->n_rall == NOPREF ) printf"NOPREF" );
ragge
1.1
726         else {
ragge
1.13
727                 ifp->n_rall & MUSTDO ) printf"MUSTDO " );
ragge
1.1
728                 else printf"PREF " );
ragge
1.13
729                 printf"%s"rnames[p->n_rall&~MUSTDO]);
ragge
1.1
730                 }
ragge
1.13
731         printf", SU= %d\n"p->n_su );
ragge
1.2
732         return 0;
733 }
ragge
1.30
734 #endif
ragge
1.1
735
736 #ifndef FIELDOPS
ragge
1.7
737 /*
738  * do this if there is no special hardware support for fields
739  */
740 static int
741 ffld(NODE *pint downint *down1int *down2 )
742 {
743         /*
744          * look for fields that are not in an lvalue context,
745          * and rewrite them...
746          */
747         NODE *shp;
748         int sovty;
ragge
1.1
749
ragge
1.13
750         *down1 =  asgopp->n_op );
ragge
1.1
751         *down2 = 0;
752
ragge
1.13
753         if( !down && p->n_op == FLD ){ /* rewrite the node */
ragge
1.1
754
ragge
1.7
755                 if( !rewfld(p) ) return 0;
ragge
1.1
756
ragge
1.13
757                 ty = (szty(p->n_type) == 2)? LONGINT;
758                 v = p->n_rval;
ragge
1.1
759                 s = UPKFSZ(v);
760 # ifdef RTOLBYTES
761                 o = UPKFOFF(v);  /* amount to shift */
762 # else
ragge
1.13
763                 o = szty(p->n_type)*SZINT - s - UPKFOFF(v);  /* amount to shift */
ragge
1.1
764 #endif
765
766                 /* make & mask part */
767
ragge
1.13
768                 p->n_left->n_type = ty;
ragge
1.1
769
ragge
1.13
770                 p->n_op = AND;
771                 p->n_right = talloc();
772                 p->n_right->n_op = ICON;
773                 p->n_right->n_rall = NOPREF;
774                 p->n_right->n_type = ty;
775                 p->n_right->n_lval = 1;
776                 p->n_right->n_rval = 0;
777                 p->n_right->n_name = "";
778                 p->n_right->n_lval <<= s;
779                 p->n_right->n_lval--;
ragge
1.1
780
781                 /* now, if a shift is needed, do it */
782
783                 ifo != 0 ){
784                         shp = talloc();
ragge
1.13
785                         shp->n_op = RS;
786                         shp->n_rall = NOPREF;
787                         shp->n_type = ty;
788                         shp->n_left = p->n_left;
789                         shp->n_right = talloc();
790                         shp->n_right->n_op = ICON;
791                         shp->n_right->n_rall = NOPREF;
792                         shp->n_right->n_type = ty;
793                         shp->n_right->n_rval = 0;
794                         shp->n_right->n_lval = o;  /* amount to shift */
795                         shp->n_right->n_name = "";
796                         p->n_left = shp;
ragge
1.1
797                         /* whew! */
798                 }
799         }
ragge
1.7
800         return 0;
801 }
ragge
1.1
802 #endif
803
ragge
1.23
804 /*
805  * change left TEMPs into OREGs
806  * look for situations where we can turn * into OREG
807  */
ragge
1.2
808 void
809 oreg2(NODE *p)
810 {
ragge
1.1
811
812         NODE *q;
ragge
1.2
813         int r;
814         char *cp;
815         NODE *ql, *qr;
ragge
1.1
816         CONSZ temp;
ragge
1.23
817
818         /*
819          * the size of a TEMP is on multiples of the reg size.
820          */
821         if (p->n_op == TEMP) {
822                 struct templst *w = templst;
823                 p->n_op = OREG;
824                 p->n_rval = FPREG;
825                 while (w != NULL) {
826                         if (w->tempnr == p->n_lval)
827                                 break;
828                         w = w->next;
829                 }
830                 if (w == NULL) {
831                         w = tmpalloc(sizeof(struct templst));
832                         w->tempnr = p->n_lval;
833                         w->tempoff = BITOOR(freetemp(szty(p->n_type)));
834                         w->next = templst;
835                         templst = w;
836                 }
837                 p->n_lval = w->tempoff;
838                 p->n_name = "";
839                 return;
840         }
ragge
1.1
841
ragge
1.13
842         if (p->n_op == UNARY MUL) {
843                 q = p->n_left;
844                 if (q->n_op == REG) {
845                         temp = q->n_lval;
846                         r = q->n_rval;
847                         cp = q->n_name;
ragge
1.1
848                         goto ormake;
ragge
1.12
849                 }
ragge
1.1
850
ragge
1.13
851                 if (q->n_op != PLUS && q->n_op != MINUS)
ragge
1.12
852                         return;
ragge
1.13
853                 ql = q->n_left;
854                 qr = q->n_right;
ragge
1.1
855
856 #ifdef R2REGS
857
858                 /* look for doubly indexed expressions */
859
ragge
1.13
860                 ifq->n_op == PLUS) {
ragge
1.7
861                         int i;
ragge
1.1
862                         if( (r=base(ql))>=0 && (i=offset(qrtlen(p)))>=0) {
863                                 makeor2(pqlri);
864                                 return;
ragge
1.12
865                         } else if((r=base(qr))>=0 && (i=offset(qltlen(p)))>=0) {
ragge
1.1
866                                 makeor2(pqrri);
867                                 return;
868                         }
ragge
1.12
869                 }
ragge
1.1
870
871
872 #endif
873
ragge
1.13
874                 if( (q->n_op==PLUS || q->n_op==MINUS) && qr->n_op == ICON &&
875                                 ql->n_op==REG && szty(qr->n_type)==1) {
876                         temp = qr->n_lval;
877                         ifq->n_op == MINUS ) temp = -temp;
878                         r = ql->n_rval;
879                         temp += ql->n_lval;
880                         cp = qr->n_name;
881                         if( *cp && ( q->n_op == MINUS || *ql->n_name ) ) return;
882                         if( !*cp ) cp = ql->n_name;
ragge
1.1
883
884                         ormake:
ragge
1.13
885                         ifnotoffp->n_typertempcp ) ) return;
886                         p->n_op = OREG;
887                         p->n_rval = r;
888                         p->n_lval = temp;
889                         p->n_name = cp;
ragge
1.1
890                         tfree(q);
891                         return;
892                 }
893         }
ragge
1.12
894 }
ragge
1.1
895
ragge
1.2
896 void
ragge
1.1
897 canon(pNODE *p; {
898         /* put p in canonical form */
899
900 #ifndef FIELDOPS
901         fwalkpffld0 ); /* look for field operators */
902 # endif
903         walkfporeg2 );  /* look for and create OREG nodes */
904 #ifdef MYCANON
905         MYCANON(p);  /* your own canonicalization routine(s) */
906 #endif
907         walkfpsucomp );  /* do the Sethi-Ullman computation */
908
ragge
1.2
909 }
ragge
1.1
910
FishEye: Open Source License registered to PCC.
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-12-22 10:10 +0100