Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20110628093331

Diff

Diff from 1.6 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/arch/vax/order.c

Annotated File View

ragge
1.6
1 /*      $Id: order.c,v 1.6 2011/06/28 09:33:31 ragge Exp $      */
ragge
1.1
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  */
35
ragge
1.2
36 # include "pass2.h"
37
38 int canaddr(NODE *);
ragge
1.1
39
40 int maxargs = { -1 };
41
ragge
1.2
42 #if 0
ragge
1.1
43 stoasgpo ) register NODE *p; {
44         /* should the assignment op p be stored,
45            given that it lies as the right operand of o
46            (or the left, if o==UNARY MUL) */
47 /*
48         if( p->op == INCR || p->op == DECR ) return;
49         if( o==UNARY MUL && p->left->op == REG && !isbreg(p->left->rval) ) SETSTO(p,INAREG);
50  */
51         }
52
ragge
1.2
53 int
ragge
1.1
54 deltestp ) register NODE *p; {
55         /* should we delay the INCR or DECR operation p */
ragge
1.2
56         p = p->n_left;
57         returnp->n_op == REG || p->n_op == NAME || p->n_op == OREG );
ragge
1.1
58         }
59
60 autoincrp ) NODE *p; {
61         register NODE *q = p->left, *r;
62
63         ifq->op == INCR && (r=q->left)->op == REG &&
64             ISPTR(q->type) && p->type == DECREF(q->type) &&
65             tlen(p) == q->right->lval ) return(1);
66
67         return(0);
68         }
69
70 mkadrs(pregister NODE *p; {
71         register o;
72
73         o = p->op;
74
75         ifasgop(o) ){
76                 ifp->left->su >= p->right->su ){
77                         ifp->left->op == UNARY MUL ){
78                                 SETSTOp->left->leftINTEMP );
79                                 }
80                         else ifp->left->op == FLD && p->left->left->op == UNARY MUL ){
81                                 SETSTOp->left->left->leftINTEMP );
82                                 }
83                         else { /* should be only structure assignment */
84                                 SETSTOp->leftINTEMP );
85                                 }
86                         }
87                 else SETSTOp->rightINTEMP );
88                 }
89         else {
90                 ifp->left->su > p->right->su ){
91                         SETSTOp->leftINTEMP );
92                         }
93                 else {
94                         SETSTOp->rightINTEMP );
95                         }
96                 }
97         }
ragge
1.2
98 #endif
ragge
1.1
99
ragge
1.2
100 int
101 notoff(TWORD tint rCONSZ offchar *cp)
102 {
ragge
1.1
103         /* is it legal to make an OREG or NAME entry which has an
ragge
1.2
104          * offset of off, (from a register of r), if the
105          * resulting thing had type t */
ragge
1.1
106
ragge
1.2
107 /*      if( r == R0 ) return( 1 );  / * NO */
ragge
1.1
108         return(0);  /* YES */
109         }
110
111 # define max(x,y) ((x)<(y)?(y):(x))
112
ragge
1.2
113 #if 0
ragge
1.1
114 sucompp ) register NODE *p; {
115
116         /* set the su field in the node to the sethi-ullman
117            number, or local equivalent */
118
119         register otysulsurr;
120
121         o = p->op;
122         ty = optypeo );
123         p->su = sztyp->type );   /* 2 for float or double, else 1 */;
124
125         ifty == LTYPE ){
126                 ifo == OREG ){
127                         r = p->rval;
128                         /* oreg cost is (worst case) 1 + number of temp registers used */
129                         ifR2TEST(r) ){
130                                 ifR2UPK1(r)!=100 && istreg(R2UPK1(r)) ) ++p->su;
131                                 ifistreg(R2UPK2(r)) ) ++p->su;
132                                 }
133                         else {
134                                 ifistregr ) ) ++p->su;
135                                 }
136                         }
137                 ifp->su == szty(p->type) &&
138                    (p->op!=REG || !istreg(p->rval)) &&
139                    (p->type==INT || p->type==UNSIGNED || p->type==DOUBLE) )
140                         p->su = 0;
141                 return;
142                 }
143
144         else ifty == UTYPE ){
145                 switcho ) {
146                 case UNARY CALL:
147                 case UNARY STCALL:
148                         p->su = fregs;  /* all regs needed */
149                         return;
150
151                 default:
152                         p->su =  p->left->su + (sztyp->type ) > 1 ? 2 : 0) ;
153                         return;
154                         }
155                 }
156
157
158         /* If rhs needs n, lhs needs m, regular su computation */
159
160         sul = p->left->su;
161         sur = p->right->su;
162
163         ifo == ASSIGN ){
164                 /* computed by doing right, then left (if not in mem), then doing it */
165                 p->su = max(sur,sul+1);
166                 return;
167                 }
168
169         ifo == CALL || o == STCALL ){
170                 /* in effect, takes all free registers */
171                 p->su = fregs;
172                 return;
173                 }
174
175         ifo == STASG ){
176                 /* right, then left */
177                 p->su = maxmax1+sulsur), fregs );
178                 return;
179                 }
180
181         ifasgop(o) ){
182                 /* computed by doing right, doing left address, doing left, op, and store */
183                 p->su = max(sur,sul+2);
184 /*
185                 if( o==ASG MUL || o==ASG DIV || o==ASG MOD) p->su = max(p->su,fregs);
186  */
187                 return;
188                 }
189
190         switcho ){
191         case ANDAND:
192         case OROR:
193         case QUEST:
194         case COLON:
195         case COMOP:
196                 p->su = maxmax(sul,sur), 1);
197                 return;
198
199         case PLUS:
200         case OR:
201         case ER:
202                 /* commutative ops; put harder on left */
203                 ifp->right->su > p->left->su && !istnode(p->left) ){
204                         register NODE *temp;
205                         temp = p->left;
206                         p->left = p->right;
207                         p->right = temp;
208                         }
209                 break;
210                 }
211
212         /* binary op, computed by left, then right, then do op */
213         p->su = max(sul,szty(p->right->type)+sur);
214 /*
215         if( o==MUL||o==DIV||o==MOD) p->su = max(p->su,fregs);
216  */
217
218         }
219
220 int radebug = 0;
221
222 rallopdown ) NODE *p; {
223         /* do register allocation */
224         register otypedown1down2ty;
225
226         ifradebug ) printf"rallo( %o, %d )\n"pdown );
227
228         down2 = NOPREF;
229         p->rall = down;
230         down1 = ( down &= ~MUSTDO );
231
232         ty = optypeo = p->op );
233         type = p->type;
234
235
236         iftype == DOUBLE || type == FLOAT ){
237                 ifo == FORCE ) down1 = R0|MUSTDO;
238                 }
239         else switcho ) {
240         case ASSIGN:    
241                 down1 = NOPREF;
242                 down2 = down;
243                 break;
244
245 /*
246         case MUL:
247         case DIV:
248         case MOD:
249                 down1 = R3|MUSTDO;
250                 down2 = R5|MUSTDO;
251                 break;
252
253         case ASG MUL:
254         case ASG DIV:
255         case ASG MOD:
256                 p->left->rall = down1 = R3|MUSTDO;
257                 if( p->left->op == UNARY MUL ){
258                         rallo( p->left->left, R4|MUSTDO );
259                         }
260                 else if( p->left->op == FLD  && p->left->left->op == UNARY MUL ){
261                         rallo( p->left->left->left, R4|MUSTDO );
262                         }
263                 else rallo( p->left, R3|MUSTDO );
264                 rallo( p->right, R5|MUSTDO );
265                 return;
266  */
267
268         case CALL:
269         case STASG:
270         case EQ:
271         case NE:
272         case GT:
273         case GE:
274         case LT:
275         case LE:
276         case NOT:
277         case ANDAND:
278         case OROR:
279                 down1 = NOPREF;
280                 break;
281
282         case FORCE:     
283                 down1 = R0|MUSTDO;
284                 break;
285
286                 }
287
288         ifty != LTYPE ) rallop->leftdown1 );
289         ifty == BITYPE ) rallop->rightdown2 );
290
291         }
ragge
1.2
292 #endif
ragge
1.1
293
ragge
1.6
294 /*
295  * Turn a UMUL-referenced node into OREG.
296  * Be careful about register classes, this is a place where classes change.
297  */
298 void
299 offstar(NODE *pint shape)
300 {
301         NODE *r;
302
303         if (x2debug)
304                 printf("offstar(%p)\n"p);
305
306         if (isreg(p))
307                 return/* Is already OREG */
308
309 #if 0 /* notyet */
310         r = p->n_right;
311         ifp->n_op == PLUS || p->n_op == MINUS ){
312                 ifr->n_op == ICON ){
313                         if (isreg(p->n_left) == 0)
314                                 (void)geninsn(p->n_leftINAREG);
315                         /* Converted in ormake() */
316                         return;
317                 }
318                 if (r->n_op == LS && r->n_right->n_op == ICON &&
319                     r->n_right->n_lval == 2 && p->n_op == PLUS) {
320                         if (isreg(p->n_left) == 0)
321                                 (void)geninsn(p->n_leftINAREG);
322                         if (isreg(r->n_left) == 0)
323                                 (void)geninsn(r->n_leftINAREG);
324                         return;
325                 }
326         }
327 #endif
328         (void)geninsn(pINAREG);
329 }
330
331
332 #if 0
ragge
1.2
333 void
334 offstarps ) register NODE *p; {
335         ifp->n_op == PLUS ) {
336                 ifp->n_left->n_su == fregs ) {
337                         orderp->n_leftINAREG );
ragge
1.1
338                         return;
ragge
1.2
339                 } else ifp->n_right->n_su == fregs ) {
340                         orderp->n_rightINAREG );
ragge
1.1
341                         return;
342                 }
ragge
1.2
343                 ifp->n_left->n_op==LS && 
344                   (p->n_left->n_left->n_op!=REG || tlen(p->n_left->n_left)!=sizeof(int) ) ) {
345                         orderp->n_left->n_leftINAREG );
ragge
1.1
346                         return;
347                 }
ragge
1.2
348                 ifp->n_right->n_op==LS &&
349                   (p->n_right->n_left->n_op!=REG || tlen(p->n_right->n_left)!=sizeof(int) ) ) {
350                         orderp->n_right->n_leftINAREG );
ragge
1.1
351                         return;
352                 }
ragge
1.2
353                 ifp->n_type == (PTR|CHAR) || p->n_type == (PTR|UCHAR) ) {
354                         ifp->n_left->n_op!=REG || tlen(p->n_left)!=sizeof(int) ) {
355                                 orderp->n_leftINAREG );
ragge
1.1
356                                 return;
357                         }
ragge
1.2
358                         else ifp->n_right->n_op!=REG || tlen(p->n_right)!=sizeof(int) ) {
359                                 order(p->n_rightINAREG);
ragge
1.1
360                                 return;
361                         }
362                 }
363         }
ragge
1.2
364         ifp->n_op == PLUS || p->n_op == MINUS ){
365                 ifp->n_right->n_op == ICON ){
366                         p = p->n_left;
367                         orderp , INAREG);
ragge
1.1
368                         return;
369                         }
370                 }
371
ragge
1.2
372         ifp->n_op == UMUL && !canaddr(p) ) {
373                 offstarp->n_left0 );
ragge
1.1
374                 return;
375         }
376
ragge
1.2
377         orderpINAREG );
ragge
1.6
378         }
ragge
1.2
379 #endif
ragge
1.1
380
ragge
1.2
381 int
ragge
1.1
382 setbinp ) register NODE *p; {
383
ragge
1.2
384 #if 0
385         register int rort;
386
387         rt = p->n_right->n_type;
388         ro = p->n_right->n_op;
ragge
1.1
389
ragge
1.2
390         ifcanaddrp->n_left ) && !canaddrp->n_right ) ) { /* address rhs */
391                 ifro == UMUL ) {
392                         offstarp->n_right->n_left0 );
ragge
1.1
393                         return(1);
394                 } else {
ragge
1.2
395                         orderp->n_rightINAREG|SOREG );
ragge
1.1
396                         return(1);
397                 }
398         }
ragge
1.2
399         if( !istnodep->n_left) ) { /* try putting LHS into a reg */
400 /*              order( p->n_left, logop(p->n_op)?(INAREG|INBREG|INTAREG|INTBREG|SOREG):(INTAREG|INTBREG|SOREG) );*/
401                 orderp->n_leftINAREG|INTAREG|INBREG|INTBREG|SOREG );
ragge
1.1
402                 return(1);
403                 }
404         else ifro == UNARY MUL && rt != CHAR && rt != UCHAR ){
ragge
1.2
405                 offstarp->n_right->n_left );
ragge
1.1
406                 return(1);
407                 }
408         else ifrt == CHAR || rt == UCHAR || rt == SHORT || rt == USHORT || (ro != REG &&
409                         ro != NAME && ro != OREG && ro != ICON ) ){
ragge
1.2
410                 orderp->n_rightINAREG|INBREG );
ragge
1.1
411                 return(1);
412                 }
413 /*
ragge
1.2
414         else if( logop(p->n_op) && rt==USHORT ){  / * must get rhs into register */
ragge
1.1
415 /*
ragge
1.2
416                 order( p->n_right, INAREG );
ragge
1.1
417                 return( 1 );
418                 }
419  */
ragge
1.2
420 #endif
ragge
1.1
421         return(0);
422         }
423
ragge
1.2
424 #if 0
425 int
ragge
1.1
426 setstrp ) register NODE *p; { /* structure assignment */
427         ifp->right->op != REG ){
428                 orderp->rightINTAREG );
429                 return(1);
430                 }
431         p = p->left;
432         ifp->op != NAME && p->op != OREG ){
433                 ifp->op != UNARY MUL ) cerror"bad setstr" );
434                 orderp->leftINTAREG );
435                 return1 );
436                 }
437         return0 );
438         }
ragge
1.2
439 #endif
440
441 int
442 setasgps ) register NODE *p; {
ragge
1.1
443
ragge
1.2
444 #if 0
ragge
1.1
445         /* setup for assignment operator */
446
ragge
1.2
447         if( !canaddr(p->n_right) ) {
448                 ifp->n_right->n_op == UNARY MUL )
449                         offstar(p->n_right->n_left);
ragge
1.1
450                 else
ragge
1.2
451                         orderp->n_rightINAREG|INBREG|SOREG );
ragge
1.1
452                 return(1);
453                 }
ragge
1.2
454         ifp->n_left->n_op == UMUL ) {
455                 offstarp->n_left->n_left );
ragge
1.1
456                 return(1);
457                 }
458         ifp->left->op == FLD && p->left->left->op == UNARY MUL ){
459                 offstarp->left->left->left );
460                 return(1);
461                 }
462 /* FLD patch */
463         ifp->left->op == FLD && !(p->right->type==INT || p->right->type==UNSIGNED)) {
464                 orderp->rightINAREG);
465                 return(1);
466                 }
467 /* end of FLD patch */
ragge
1.2
468 #endif
ragge
1.1
469         return(0);
470         }
471
ragge
1.2
472 /* setup for unary operator */
473 int
474 setuni(NODE *pint cookie)
475 {
476         return 0;
477 }
478
479
480 #if 0
481 int
ragge
1.1
482 setasopp ) register NODE *p; {
483         /* setup for =ops */
484         register rtro;
485
486         rt = p->right->type;
487         ro = p->right->op;
488
489         ifro == UNARY MUL && rt != CHAR ){
490                 offstarp->right->left );
491                 return(1);
492                 }
493         if( ( rt == CHAR || rt == SHORT || rt == UCHAR || rt == USHORT ||
494                         ( ro != REG && ro != ICON && ro != NAME && ro != OREG ) ) ){
495                 orderp->rightINAREG|INBREG );
496                 return(1);
497                 }
498 /*
499         if( (p->op == ASG LS || p->op == ASG RS) && ro != ICON && ro != REG ){
500                 order( p->right, INAREG );
501                 return(1);
502                 }
503  */
504
505
506         p = p->left;
507         ifp->op == FLD ) p = p->left;
508
509         switchp->op ){
510
511         case REG:
512         case ICON:
513         case NAME:
514         case OREG:
515                 return(0);
516
517         case UNARY MUL:
518                 ifp->left->op==OREG )
519                         return(0);
520                 else
521                         offstarp->left );
522                 return(1);
523
524                 }
525         cerror"illegal setasop" );
526         }
ragge
1.2
527 #endif
ragge
1.1
528
ragge
1.2
529 void
530 deflab(int l)
531 {
532         printf(LABFMT ":\n"l);
533 }
ragge
1.1
534
ragge
1.2
535 #if 0
ragge
1.1
536 genargspptemp ) register NODE *p, *ptemp; {
537         register NODE *pasg;
538         register align;
539         register size;
540         register TWORD type;
541
542         /* generate code for the arguments */
543
544         /*  first, do the arguments on the right */
545         whilep->op == CM ){
546                 genargsp->rightptemp );
547                 p->op = FREE;
548                 p = p->left;
549                 }
550
551         ifp->op == STARG ){ /* structure valued argument */
552
553                 size = p->stsize;
554                 align = p->stalign;
555
ragge
1.2
556  /*             ptemp->lval = (ptemp->lval/align)*align;  / * SETOFF for negative numbers */
ragge
1.1
557                 ptemp->lval = 0;        /* all moves to (sp) */
558
559                 p->op = STASG;
560                 p->right = p->left;
561                 p->left = tcopyptemp );
562
563                 /* the following line is done only with the knowledge
564                 that it will be undone by the STASG node, with the
565                 offset (lval) field retained */
566
567                 ifp->right->op == OREG ) p->right->op = REG;  /* only for temporaries */
568
569                 orderpFORARG );
570                 ptemp->lval += size;
571                 return;
572                 }
573
574         /* ordinary case */
575
576         orderpFORARG );
577         }
578
579 argsizep ) register NODE *p; {
580         register t;
581         t = 0;
582         ifp->op == CM ){
583                 t = argsizep->left );
584                 p = p->right;
585                 }
586         ifp->type == DOUBLE || p->type == FLOAT ){
587                 SETOFFt4 );
588                 returnt+8 );
589                 }
590         else ifp->op == STARG ){
591                 SETOFFt4 );  /* alignment */
592                 returnt + ((p->stsize+3)/4)*4 );  /* size */
593                 }
594         else {
595                 SETOFFt4 );
596                 returnt+4 );
597                 }
598         }
ragge
1.2
599 #endif
600
601 /*
602  * Special handling of some instruction register allocation.
603  */
604 struct rspecial *
605 nspecial(struct optab *q)
606 {
ragge
1.5
607         switch (q->op) {
608         case STARG:
609                 {
ragge
1.6
610                 static struct rspecial s[] = {
611                     { NEVERR0, }, { NEVERR1, }, { NEVERR2, },
612                     { NEVERR3, }, { NEVERR4, }, { NEVERR5 } };
ragge
1.5
613                 return s;
614                 }
615         default:
616                 comperr("nspecial");
617                 return NULL;
618         }
ragge
1.2
619 }
620
621 /*
622  * Set evaluation order of a binary node if it differs from default.
623  */
624 int
625 setorder(NODE *p)
626 {
627         return 0/* nothing differs on vax */
628 }
629
630 /*
631  * Do the actual conversion of offstar-found OREGs into real OREGs.
632  */
633 void
634 myormake(NODE *q)
635 {
636 }
ragge
1.3
637 /*
638  * Set registers "live" at function calls (like arguments in registers).
639  * This is for liveness analysis of registers.
640  */
641 int *
642 livecall(NODE *p)
643 {
644         static int r[1] = { -1 }; /* Terminate with -1 */
645
646         return &r[0];
647 }
648
gmcgarry
1.4
649 /*
650  * Signal whether the instruction is acceptable for this target.
651  */
652 int
653 acceptable(struct optab *op)
654 {
655         return 1;
656 }
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-10-02 10:25 +0200