Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030803150037

Diff

Diff from 1.35 to:

Annotations

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

Annotated File View

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