Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030803171823

Diff

Diff from 1.36 to:

Annotations

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

Annotated File View

ragge
1.36
1 /*      $Id: reader.c,v 1.36 2003/08/03 17:18:23 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.26
66
67 #ifdef PCC_DEBUG
68 static void
69 cktree(NODE *p)
70 {
71         if (p->n_op > MAXOP)
72                 cerror("op %d slipped through"p->n_op);
ragge
1.35
73         if (p->n_op == CBRANCH && !logop(p->n_left->n_op))
74                 cerror("not logop branch");
ragge
1.26
75 }
76 #endif
ragge
1.8
77
ragge
1.17
78 static void
ragge
1.2
79 p2compile(NODE *p)
80 {
ragge
1.15
81 #if !defined(MULTIPASS)
82         extern char *ftitle;
83 #endif
ragge
1.1
84
ragge
1.14
85         if (lflag)
86                 lineid(linenoftitle);
87
ragge
1.1
88         /* generate code for the tree p */
ragge
1.26
89 #ifdef PCC_DEBUG
90         walkf(pcktree);
91         if (e2debug)
92                 fwalk(pe2print0);
93 #endif
ragge
1.25
94
ragge
1.1
95 # ifdef MYREADER
96         MYREADER(p);  /* do your own laundering of the input */
97 # endif
98         nrecur = 0;
ragge
1.25
99         codgen(pFOREFF);
ragge
1.1
100         reclaimpRNULL0 );
101         allchk();
102         /* can't do tcheck here; some stuff (e.g., attributes) may be around from first pass */
103         /* first pass will do it... */
ragge
1.2
104 }
ragge
1.1
105
ragge
1.17
106 static void newblock(int myregint aoff);
107 static void epilogue(int regsint autosint retlab);
108
ragge
1.2
109 void
ragge
1.17
110 pass2_compile(struct interpass *ip)
111 {
112         switch (ip->type) {
113         case IP_NODE:
114                 p2compile(ip->ip_node);
ragge
1.21
115                 tfree(ip->ip_node);
ragge
1.17
116                 break;
117         case IP_PROLOG:
118                 prologue(ip->ip_regsip->ip_auto);
119                 break;
120         case IP_NEWBLK:
121                 newblock(ip->ip_regsip->ip_auto);
122                 break;
123         case IP_EPILOG:
124                 epilogue(ip->ip_regsip->ip_autoip->ip_retl);
ragge
1.18
125                 break;
126         case IP_LOCCTR:
127                 setlocc(ip->ip_locc);
128                 break;
129         case IP_DEFLAB:
130                 deflab(ip->ip_lbl);
131                 break;
132         case IP_DEFNAM:
133                 defname(ip->ip_nameip->ip_vis);
134                 break;
ragge
1.17
135         default:
136                 cerror("pass2_compile %d"ip->type);
137         }
138 }
139
140 static void
ragge
1.16
141 newblock(int myregint aoff)
ragge
1.2
142 {
ragge
1.1
143         static int myftn = -1;
144
ragge
1.30
145         tmpoff = baseoff = aoff;
ragge
1.1
146         maxtreg = myreg;
147         ifmyftn != ftnno ){ /* beginning of function */
148                 maxoff = baseoff;
149                 myftn = ftnno;
150                 maxtemp = 0;
151                 }
152         else {
153                 ifbaseoff > maxoff ) maxoff = baseoff;
154                 /* maxoff at end of ftn is max of autos and temps over all blocks */
155                 }
156         setregs();
ragge
1.2
157 }
ragge
1.1
158
ragge
1.17
159 static void
ragge
1.16
160 epilogue(int regsint autosint retlab)
ragge
1.2
161 {
ragge
1.16
162         SETOFF(maxoffALSTACK);
ragge
1.23
163         templst = NULL;
ragge
1.16
164         eoftn(regsautosretlab);
ragge
1.2
165 }
ragge
1.1
166
ragge
1.2
167 /*
168  * generate the code for p;
169  * order may call codgen recursively
170  * cookie is used to describe the context
171  */
172 void
173 codgen(NODE *pint cookie)
174 {
ragge
1.1
175
ragge
1.8
176         for (;;) {
ragge
1.1
177                 canon(p);  /* creats OREG from * if possible and does sucomp */
178                 stotree = NIL;
ragge
1.30
179 #ifdef PCC_DEBUG
ragge
1.8
180                 if (e2debug) {
181                         printf("store called on:\n");
182                         fwalk(pe2print0);
183                 }
ragge
1.30
184 #endif
ragge
1.1
185                 store(p);
186                 ifstotree==NIL ) break;
187
188                 /* because it's minimal, can do w.o. stores */
189
190                 orderstotreestocook );
ragge
1.2
191         }
ragge
1.1
192         orderpcookie );
ragge
1.2
193 }
ragge
1.1
194
ragge
1.30
195 #ifdef PCC_DEBUG
ragge
1.1
196 char *cnames[] = {
197         "SANY",
198         "SAREG",
199         "STAREG",
200         "SBREG",
201         "STBREG",
202         "SCC",
203         "SNAME",
204         "SCON",
205         "SFLD",
206         "SOREG",
207         "STARNM",
208         "STARREG",
209         "INTEMP",
210         "FORARG",
211         "SWADD",
212         0,
213         };
214
ragge
1.2
215 /*
216  * print a nice-looking description of cookie
217  */
218 void
219 prcook(int cookie)
220 {
ragge
1.1
221         int iflag;
222
223         ifcookie & SPECIAL ){
224                 ifcookie == SZERO ) printf"SZERO" );
225                 else ifcookie == SONE ) printf"SONE" );
226                 else ifcookie == SMONE ) printf"SMONE" );
227                 else printf"SPECIAL+%d"cookie & ~SPECIAL );
228                 return;
229                 }
230
231         flag = 0;
232         fori=0cnames[i]; ++i ){
233                 ifcookie & (1<<i) ){
234                         ifflag ) printf"|" );
235                         ++flag;
236                         printfcnames[i] );
237                         }
238                 }
239
ragge
1.2
240 }
ragge
1.30
241 #endif
ragge
1.1
242
243 int odebug = 0;
244
ragge
1.2
245 void
246 order(NODE *pint cook)
247 {
248         int otym;
ragge
1.1
249         int cookie;
ragge
1.2
250         NODE *p1, *p2;
ragge
1.1
251
ragge
1.8
252         /*
253          * by this time, p should be able to be generated without stores;
254          * the only question is how
255          */
ragge
1.1
256         again:
257
ragge
1.13
258         if (p->n_op == FREE)
ragge
1.19
259                 cerror("order");        /* whole tree was done */
ragge
1.1
260         cookie = cook;
261         rcount();
262         canon(p);
ragge
1.13
263         rallo(pp->n_rall);
ragge
1.1
264
ragge
1.30
265 #ifdef PCC_DEBUG
ragge
1.8
266         if (odebug) {
267                 printf("order(%p, "p);
268                 prcook(cookie);
269                 printf(")\n");
270                 fwalk(pe2print0);
271         }
ragge
1.30
272 #endif
ragge
1.1
273
ragge
1.13
274         o = p->n_op;
ragge
1.1
275         ty = optype(o);
276
277         /* first of all, for most ops, see if it is in the table */
278
279         /* look for ops */
280
ragge
1.13
281         switch (m = p->n_op) {
ragge
1.1
282
283         default:
284                 /* look for op in table */
ragge
1.8
285                 for (;;) {
286                         if ((m = match(pcookie)) == MDONE)
287                                 goto cleanup;
288                         else if (m == MNOPE) {
289                                 if (!(cookie = nextcook(pcookie)))
290                                         goto nomat;
ragge
1.1
291                                 continue;
ragge
1.8
292                         } else
293                                 break;
294                 }
ragge
1.1
295                 break;
296
297         case FORCE:
298         case CBRANCH:
299         case UNARY CALL:
300         case CALL:
301         case UNARY STCALL:
302         case STCALL:
303         case UNARY FORTCALL:
304         case FORTCALL:
305                 /* don't even go near the table... */
306                 ;
307
ragge
1.8
308         }
ragge
1.25
309         /*
ragge
1.8
310          * get here to do rewriting if no match or
311          * fall through from above for hard ops
312          */
ragge
1.1
313
ragge
1.13
314         p1 = p->n_left;
ragge
1.8
315         if (ty == BITYPE)
ragge
1.13
316                 p2 = p->n_right;
ragge
1.8
317         else
318                 p2 = NIL;
ragge
1.1
319         
ragge
1.30
320 #ifdef PCC_DEBUG
ragge
1.8
321         if (odebug) {
322                 printf("order(%p, "p);
323                 prcook(cook);
324                 printf("), cookie ");
325                 prcook(cookie);
326                 printf(", rewrite %s\n"opst[m]);
327         }
ragge
1.30
328 #endif
ragge
1.8
329         switch (m) {
ragge
1.1
330         default:
331                 nomat:
ragge
1.13
332                 cerror"no table entry for op %s"opst[p->n_op] );
ragge
1.1
333
334         case FORCE:
335                 /* recurse, letting the work be done by rallo */
336                 cook = INTAREG|INTBREG;
ragge
1.19
337                 order(p->n_leftcook);
338                 reclaim(pRLEFTcook);
ragge
1.1
339                 goto again;
340
341         case CBRANCH:
ragge
1.36
342                 p1->n_label = p2->n_lval;
343                 codgen(p1FORCC);
344                 reclaim(p1RNULL0);
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 void
633 rcount()
634 /* count recursions */
ragge
1.1
635         if( ++nrecur > NRECUR ){
636                 cerror"expression causes compiler loop: try simplifying" );
637         }
ragge
1.2
638 }
ragge
1.1
639
ragge
1.30
640 #ifdef PCC_DEBUG
ragge
1.2
641 int
ragge
1.8
642 e2print(NODE *pint downint *aint *b)
ragge
1.2
643 {
ragge
1.1
644
645         *a = *b = down+1;
646         whiledown >= 2 ){
647                 printf"\t" );
648                 down -= 2;
649                 }
650         ifdown-- ) printf"    " );
651
652
ragge
1.13
653         printf"%p) %s"popst[p->n_op] );
654         switchp->n_op ) { /* special cases */
ragge
1.1
655
656         case REG:
ragge
1.13
657                 printf" %s"rnames[p->n_rval] );
ragge
1.1
658                 break;
659
ragge
1.23
660         case TEMP:
661                 printf(" %d", (int)p->n_lval);
662                 break;
663
ragge
1.1
664         case ICON:
665         case NAME:
666         case OREG:
667                 printf" " );
668                 adrputp );
669                 break;
670
671         case STCALL:
672         case UNARY STCALL:
673         case STARG:
674         case STASG:
ragge
1.13
675                 printf" size=%d"p->n_stsize );
676                 printf" align=%d"p->n_stalign );
ragge
1.1
677                 break;
678                 }
679
680         printf", " );
ragge
1.33
681         tprintp->n_typep->n_qual);
ragge
1.1
682         printf", " );
ragge
1.13
683         ifp->n_rall == NOPREF ) printf"NOPREF" );
ragge
1.1
684         else {
ragge
1.13
685                 ifp->n_rall & MUSTDO ) printf"MUSTDO " );
ragge
1.1
686                 else printf"PREF " );
ragge
1.13
687                 printf"%s"rnames[p->n_rall&~MUSTDO]);
ragge
1.1
688                 }
ragge
1.13
689         printf", SU= %d\n"p->n_su );
ragge
1.2
690         return 0;
691 }
ragge
1.30
692 #endif
ragge
1.1
693
694 #ifndef FIELDOPS
ragge
1.7
695 /*
696  * do this if there is no special hardware support for fields
697  */
698 static int
699 ffld(NODE *pint downint *down1int *down2 )
700 {
701         /*
702          * look for fields that are not in an lvalue context,
703          * and rewrite them...
704          */
705         NODE *shp;
706         int sovty;
ragge
1.1
707
ragge
1.13
708         *down1 =  asgopp->n_op );
ragge
1.1
709         *down2 = 0;
710
ragge
1.13
711         if( !down && p->n_op == FLD ){ /* rewrite the node */
ragge
1.1
712
ragge
1.7
713                 if( !rewfld(p) ) return 0;
ragge
1.1
714
ragge
1.13
715                 ty = (szty(p->n_type) == 2)? LONGINT;
716                 v = p->n_rval;
ragge
1.1
717                 s = UPKFSZ(v);
718 # ifdef RTOLBYTES
719                 o = UPKFOFF(v);  /* amount to shift */
720 # else
ragge
1.13
721                 o = szty(p->n_type)*SZINT - s - UPKFOFF(v);  /* amount to shift */
ragge
1.1
722 #endif
723
724                 /* make & mask part */
725
ragge
1.13
726                 p->n_left->n_type = ty;
ragge
1.1
727
ragge
1.13
728                 p->n_op = AND;
729                 p->n_right = talloc();
730                 p->n_right->n_op = ICON;
731                 p->n_right->n_rall = NOPREF;
732                 p->n_right->n_type = ty;
733                 p->n_right->n_lval = 1;
734                 p->n_right->n_rval = 0;
735                 p->n_right->n_name = "";
736                 p->n_right->n_lval <<= s;
737                 p->n_right->n_lval--;
ragge
1.1
738
739                 /* now, if a shift is needed, do it */
740
741                 ifo != 0 ){
742                         shp = talloc();
ragge
1.13
743                         shp->n_op = RS;
744                         shp->n_rall = NOPREF;
745                         shp->n_type = ty;
746                         shp->n_left = p->n_left;
747                         shp->n_right = talloc();
748                         shp->n_right->n_op = ICON;
749                         shp->n_right->n_rall = NOPREF;
750                         shp->n_right->n_type = ty;
751                         shp->n_right->n_rval = 0;
752                         shp->n_right->n_lval = o;  /* amount to shift */
753                         shp->n_right->n_name = "";
754                         p->n_left = shp;
ragge
1.1
755                         /* whew! */
756                 }
757         }
ragge
1.7
758         return 0;
759 }
ragge
1.1
760 #endif
761
ragge
1.23
762 /*
763  * change left TEMPs into OREGs
764  * look for situations where we can turn * into OREG
765  */
ragge
1.2
766 void
767 oreg2(NODE *p)
768 {
ragge
1.1
769
770         NODE *q;
ragge
1.2
771         int r;
772         char *cp;
773         NODE *ql, *qr;
ragge
1.1
774         CONSZ temp;
ragge
1.23
775
776         /*
777          * the size of a TEMP is on multiples of the reg size.
778          */
779         if (p->n_op == TEMP) {
780                 struct templst *w = templst;
781                 p->n_op = OREG;
782                 p->n_rval = FPREG;
783                 while (w != NULL) {
784                         if (w->tempnr == p->n_lval)
785                                 break;
786                         w = w->next;
787                 }
788                 if (w == NULL) {
789                         w = tmpalloc(sizeof(struct templst));
790                         w->tempnr = p->n_lval;
791                         w->tempoff = BITOOR(freetemp(szty(p->n_type)));
792                         w->next = templst;
793                         templst = w;
794                 }
795                 p->n_lval = w->tempoff;
796                 p->n_name = "";
797                 return;
798         }
ragge
1.1
799
ragge
1.13
800         if (p->n_op == UNARY MUL) {
801                 q = p->n_left;
802                 if (q->n_op == REG) {
803                         temp = q->n_lval;
804                         r = q->n_rval;
805                         cp = q->n_name;
ragge
1.1
806                         goto ormake;
ragge
1.12
807                 }
ragge
1.1
808
ragge
1.13
809                 if (q->n_op != PLUS && q->n_op != MINUS)
ragge
1.12
810                         return;
ragge
1.13
811                 ql = q->n_left;
812                 qr = q->n_right;
ragge
1.1
813
814 #ifdef R2REGS
815
816                 /* look for doubly indexed expressions */
817
ragge
1.13
818                 ifq->n_op == PLUS) {
ragge
1.7
819                         int i;
ragge
1.1
820                         if( (r=base(ql))>=0 && (i=offset(qrtlen(p)))>=0) {
821                                 makeor2(pqlri);
822                                 return;
ragge
1.12
823                         } else if((r=base(qr))>=0 && (i=offset(qltlen(p)))>=0) {
ragge
1.1
824                                 makeor2(pqrri);
825                                 return;
826                         }
ragge
1.12
827                 }
ragge
1.1
828
829
830 #endif
831
ragge
1.13
832                 if( (q->n_op==PLUS || q->n_op==MINUS) && qr->n_op == ICON &&
833                                 ql->n_op==REG && szty(qr->n_type)==1) {
834                         temp = qr->n_lval;
835                         ifq->n_op == MINUS ) temp = -temp;
836                         r = ql->n_rval;
837                         temp += ql->n_lval;
838                         cp = qr->n_name;
839                         if( *cp && ( q->n_op == MINUS || *ql->n_name ) ) return;
840                         if( !*cp ) cp = ql->n_name;
ragge
1.1
841
842                         ormake:
ragge
1.13
843                         ifnotoffp->n_typertempcp ) ) return;
844                         p->n_op = OREG;
845                         p->n_rval = r;
846                         p->n_lval = temp;
847                         p->n_name = cp;
ragge
1.1
848                         tfree(q);
849                         return;
850                 }
851         }
ragge
1.12
852 }
ragge
1.1
853
ragge
1.2
854 void
ragge
1.1
855 canon(pNODE *p; {
856         /* put p in canonical form */
857
858 #ifndef FIELDOPS
859         fwalkpffld0 ); /* look for field operators */
860 # endif
861         walkfporeg2 );  /* look for and create OREG nodes */
862 #ifdef MYCANON
863         MYCANON(p);  /* your own canonicalization routine(s) */
864 #endif
865         walkfpsucomp );  /* do the Sethi-Ullman computation */
866
ragge
1.2
867 }
ragge
1.1
868
FishEye: Open Source License registered to PCC.
Your maintenance has expired. You can renew your license at http://www.atlassian.com/fisheye/renew
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-09-02 03:59 +0200