Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030801131203

Diff

Diff from 1.33 to:

Annotations

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

Annotated File View

ragge
1.33
1 /*      $Id: reader.c,v 1.33 2003/08/01 13:12:04 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_op = negrel[p->n_op - EQ];
651                 p->n_label = false;
652                 codgen(pFORCC);
653                 reclaim(pRNULL0);
ragge
1.1
654                 return;
655
656         case ICON:
ragge
1.29
657                 if (p->n_type != FLOAT && p->n_type != DOUBLE) {
658                         if ((p->n_lval == 0) && (p->n_name[0] == 0))
659                                 cbgen(0false'I');
ragge
1.19
660                         nfree(p);
ragge
1.1
661                         return;
ragge
1.19
662                 }
ragge
1.1
663                 /* fall through to default with other strange constants */
664
665         default:
666                 /* get condition codes */
ragge
1.29
667                 codgen(pFORCC);
668                 cbgen(EQfalse'I');
669                 reclaim(pRNULL0);
ragge
1.1
670                 return;
671
672         }
ragge
1.29
673 }
ragge
1.1
674
ragge
1.2
675 void
676 rcount()
677 /* count recursions */
ragge
1.1
678         if( ++nrecur > NRECUR ){
679                 cerror"expression causes compiler loop: try simplifying" );
680         }
ragge
1.2
681 }
ragge
1.1
682
ragge
1.30
683 #ifdef PCC_DEBUG
ragge
1.2
684 int
ragge
1.8
685 e2print(NODE *pint downint *aint *b)
ragge
1.2
686 {
ragge
1.1
687
688         *a = *b = down+1;
689         whiledown >= 2 ){
690                 printf"\t" );
691                 down -= 2;
692                 }
693         ifdown-- ) printf"    " );
694
695
ragge
1.13
696         printf"%p) %s"popst[p->n_op] );
697         switchp->n_op ) { /* special cases */
ragge
1.1
698
699         case REG:
ragge
1.13
700                 printf" %s"rnames[p->n_rval] );
ragge
1.1
701                 break;
702
ragge
1.23
703         case TEMP:
704                 printf(" %d", (int)p->n_lval);
705                 break;
706
ragge
1.1
707         case ICON:
708         case NAME:
709         case OREG:
710                 printf" " );
711                 adrputp );
712                 break;
713
714         case STCALL:
715         case UNARY STCALL:
716         case STARG:
717         case STASG:
ragge
1.13
718                 printf" size=%d"p->n_stsize );
719                 printf" align=%d"p->n_stalign );
ragge
1.1
720                 break;
721                 }
722
723         printf", " );
ragge
1.33
724         tprintp->n_typep->n_qual);
ragge
1.1
725         printf", " );
ragge
1.13
726         ifp->n_rall == NOPREF ) printf"NOPREF" );
ragge
1.1
727         else {
ragge
1.13
728                 ifp->n_rall & MUSTDO ) printf"MUSTDO " );
ragge
1.1
729                 else printf"PREF " );
ragge
1.13
730                 printf"%s"rnames[p->n_rall&~MUSTDO]);
ragge
1.1
731                 }
ragge
1.13
732         printf", SU= %d\n"p->n_su );
ragge
1.2
733         return 0;
734 }
ragge
1.30
735 #endif
ragge
1.1
736
737 #ifndef FIELDOPS
ragge
1.7
738 /*
739  * do this if there is no special hardware support for fields
740  */
741 static int
742 ffld(NODE *pint downint *down1int *down2 )
743 {
744         /*
745          * look for fields that are not in an lvalue context,
746          * and rewrite them...
747          */
748         NODE *shp;
749         int sovty;
ragge
1.1
750
ragge
1.13
751         *down1 =  asgopp->n_op );
ragge
1.1
752         *down2 = 0;
753
ragge
1.13
754         if( !down && p->n_op == FLD ){ /* rewrite the node */
ragge
1.1
755
ragge
1.7
756                 if( !rewfld(p) ) return 0;
ragge
1.1
757
ragge
1.13
758                 ty = (szty(p->n_type) == 2)? LONGINT;
759                 v = p->n_rval;
ragge
1.1
760                 s = UPKFSZ(v);
761 # ifdef RTOLBYTES
762                 o = UPKFOFF(v);  /* amount to shift */
763 # else
ragge
1.13
764                 o = szty(p->n_type)*SZINT - s - UPKFOFF(v);  /* amount to shift */
ragge
1.1
765 #endif
766
767                 /* make & mask part */
768
ragge
1.13
769                 p->n_left->n_type = ty;
ragge
1.1
770
ragge
1.13
771                 p->n_op = AND;
772                 p->n_right = talloc();
773                 p->n_right->n_op = ICON;
774                 p->n_right->n_rall = NOPREF;
775                 p->n_right->n_type = ty;
776                 p->n_right->n_lval = 1;
777                 p->n_right->n_rval = 0;
778                 p->n_right->n_name = "";
779                 p->n_right->n_lval <<= s;
780                 p->n_right->n_lval--;
ragge
1.1
781
782                 /* now, if a shift is needed, do it */
783
784                 ifo != 0 ){
785                         shp = talloc();
ragge
1.13
786                         shp->n_op = RS;
787                         shp->n_rall = NOPREF;
788                         shp->n_type = ty;
789                         shp->n_left = p->n_left;
790                         shp->n_right = talloc();
791                         shp->n_right->n_op = ICON;
792                         shp->n_right->n_rall = NOPREF;
793                         shp->n_right->n_type = ty;
794                         shp->n_right->n_rval = 0;
795                         shp->n_right->n_lval = o;  /* amount to shift */
796                         shp->n_right->n_name = "";
797                         p->n_left = shp;
ragge
1.1
798                         /* whew! */
799                 }
800         }
ragge
1.7
801         return 0;
802 }
ragge
1.1
803 #endif
804
ragge
1.23
805 /*
806  * change left TEMPs into OREGs
807  * look for situations where we can turn * into OREG
808  */
ragge
1.2
809 void
810 oreg2(NODE *p)
811 {
ragge
1.1
812
813         NODE *q;
ragge
1.2
814         int r;
815         char *cp;
816         NODE *ql, *qr;
ragge
1.1
817         CONSZ temp;
ragge
1.23
818
819         /*
820          * the size of a TEMP is on multiples of the reg size.
821          */
822         if (p->n_op == TEMP) {
823                 struct templst *w = templst;
824                 p->n_op = OREG;
825                 p->n_rval = FPREG;
826                 while (w != NULL) {
827                         if (w->tempnr == p->n_lval)
828                                 break;
829                         w = w->next;
830                 }
831                 if (w == NULL) {
832                         w = tmpalloc(sizeof(struct templst));
833                         w->tempnr = p->n_lval;
834                         w->tempoff = BITOOR(freetemp(szty(p->n_type)));
835                         w->next = templst;
836                         templst = w;
837                 }
838                 p->n_lval = w->tempoff;
839                 p->n_name = "";
840                 return;
841         }
ragge
1.1
842
ragge
1.13
843         if (p->n_op == UNARY MUL) {
844                 q = p->n_left;
845                 if (q->n_op == REG) {
846                         temp = q->n_lval;
847                         r = q->n_rval;
848                         cp = q->n_name;
ragge
1.1
849                         goto ormake;
ragge
1.12
850                 }
ragge
1.1
851
ragge
1.13
852                 if (q->n_op != PLUS && q->n_op != MINUS)
ragge
1.12
853                         return;
ragge
1.13
854                 ql = q->n_left;
855                 qr = q->n_right;
ragge
1.1
856
857 #ifdef R2REGS
858
859                 /* look for doubly indexed expressions */
860
ragge
1.13
861                 ifq->n_op == PLUS) {
ragge
1.7
862                         int i;
ragge
1.1
863                         if( (r=base(ql))>=0 && (i=offset(qrtlen(p)))>=0) {
864                                 makeor2(pqlri);
865                                 return;
ragge
1.12
866                         } else if((r=base(qr))>=0 && (i=offset(qltlen(p)))>=0) {
ragge
1.1
867                                 makeor2(pqrri);
868                                 return;
869                         }
ragge
1.12
870                 }
ragge
1.1
871
872
873 #endif
874
ragge
1.13
875                 if( (q->n_op==PLUS || q->n_op==MINUS) && qr->n_op == ICON &&
876                                 ql->n_op==REG && szty(qr->n_type)==1) {
877                         temp = qr->n_lval;
878                         ifq->n_op == MINUS ) temp = -temp;
879                         r = ql->n_rval;
880                         temp += ql->n_lval;
881                         cp = qr->n_name;
882                         if( *cp && ( q->n_op == MINUS || *ql->n_name ) ) return;
883                         if( !*cp ) cp = ql->n_name;
ragge
1.1
884
885                         ormake:
ragge
1.13
886                         ifnotoffp->n_typertempcp ) ) return;
887                         p->n_op = OREG;
888                         p->n_rval = r;
889                         p->n_lval = temp;
890                         p->n_name = cp;
ragge
1.1
891                         tfree(q);
892                         return;
893                 }
894         }
ragge
1.12
895 }
ragge
1.1
896
ragge
1.2
897 void
ragge
1.1
898 canon(pNODE *p; {
899         /* put p in canonical form */
900
901 #ifndef FIELDOPS
902         fwalkpffld0 ); /* look for field operators */
903 # endif
904         walkfporeg2 );  /* look for and create OREG nodes */
905 #ifdef MYCANON
906         MYCANON(p);  /* your own canonicalization routine(s) */
907 #endif
908         walkfpsucomp );  /* do the Sethi-Ullman computation */
909
ragge
1.2
910 }
ragge
1.1
911
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-01 09:40 +0200