Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20060618101745

Diff

Diff from 1.1 to:

Annotations

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

Annotated File View

ragge
1.1
1 /*      $Id: order.c,v 1.1 2006/06/18 10:17:45 ragge Exp $      */
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
36 # include "mfile2"
37
38 int maxargs = { -1 };
39
40 stoasgpo ) register NODE *p; {
41         /* should the assignment op p be stored,
42            given that it lies as the right operand of o
43            (or the left, if o==UNARY MUL) */
44 /*
45         if( p->op == INCR || p->op == DECR ) return;
46         if( o==UNARY MUL && p->left->op == REG && !isbreg(p->left->rval) ) SETSTO(p,INAREG);
47  */
48         }
49
50 deltestp ) register NODE *p; {
51         /* should we delay the INCR or DECR operation p */
52         p = p->left;
53         returnp->op == REG || p->op == NAME || p->op == OREG );
54         }
55
56 autoincrp ) NODE *p; {
57         register NODE *q = p->left, *r;
58
59         ifq->op == INCR && (r=q->left)->op == REG &&
60             ISPTR(q->type) && p->type == DECREF(q->type) &&
61             tlen(p) == q->right->lval ) return(1);
62
63         return(0);
64         }
65
66 mkadrs(pregister NODE *p; {
67         register o;
68
69         o = p->op;
70
71         ifasgop(o) ){
72                 ifp->left->su >= p->right->su ){
73                         ifp->left->op == UNARY MUL ){
74                                 SETSTOp->left->leftINTEMP );
75                                 }
76                         else ifp->left->op == FLD && p->left->left->op == UNARY MUL ){
77                                 SETSTOp->left->left->leftINTEMP );
78                                 }
79                         else { /* should be only structure assignment */
80                                 SETSTOp->leftINTEMP );
81                                 }
82                         }
83                 else SETSTOp->rightINTEMP );
84                 }
85         else {
86                 ifp->left->su > p->right->su ){
87                         SETSTOp->leftINTEMP );
88                         }
89                 else {
90                         SETSTOp->rightINTEMP );
91                         }
92                 }
93         }
94
95 notofftroffcpCONSZ offchar *cp; {
96         /* is it legal to make an OREG or NAME entry which has an
97         /* offset of off, (from a register of r), if the
98         /* resulting thing had type t */
99
100 /*      if( r == R0 ) return( 1 );  /* NO */
101         return(0);  /* YES */
102         }
103
104 # define max(x,y) ((x)<(y)?(y):(x))
105
106 sucompp ) register NODE *p; {
107
108         /* set the su field in the node to the sethi-ullman
109            number, or local equivalent */
110
111         register otysulsurr;
112
113         o = p->op;
114         ty = optypeo );
115         p->su = sztyp->type );   /* 2 for float or double, else 1 */;
116
117         ifty == LTYPE ){
118                 ifo == OREG ){
119                         r = p->rval;
120                         /* oreg cost is (worst case) 1 + number of temp registers used */
121                         ifR2TEST(r) ){
122                                 ifR2UPK1(r)!=100 && istreg(R2UPK1(r)) ) ++p->su;
123                                 ifistreg(R2UPK2(r)) ) ++p->su;
124                                 }
125                         else {
126                                 ifistregr ) ) ++p->su;
127                                 }
128                         }
129                 ifp->su == szty(p->type) &&
130                    (p->op!=REG || !istreg(p->rval)) &&
131                    (p->type==INT || p->type==UNSIGNED || p->type==DOUBLE) )
132                         p->su = 0;
133                 return;
134                 }
135
136         else ifty == UTYPE ){
137                 switcho ) {
138                 case UNARY CALL:
139                 case UNARY STCALL:
140                         p->su = fregs;  /* all regs needed */
141                         return;
142
143                 default:
144                         p->su =  p->left->su + (sztyp->type ) > 1 ? 2 : 0) ;
145                         return;
146                         }
147                 }
148
149
150         /* If rhs needs n, lhs needs m, regular su computation */
151
152         sul = p->left->su;
153         sur = p->right->su;
154
155         ifo == ASSIGN ){
156                 /* computed by doing right, then left (if not in mem), then doing it */
157                 p->su = max(sur,sul+1);
158                 return;
159                 }
160
161         ifo == CALL || o == STCALL ){
162                 /* in effect, takes all free registers */
163                 p->su = fregs;
164                 return;
165                 }
166
167         ifo == STASG ){
168                 /* right, then left */
169                 p->su = maxmax1+sulsur), fregs );
170                 return;
171                 }
172
173         ifasgop(o) ){
174                 /* computed by doing right, doing left address, doing left, op, and store */
175                 p->su = max(sur,sul+2);
176 /*
177                 if( o==ASG MUL || o==ASG DIV || o==ASG MOD) p->su = max(p->su,fregs);
178  */
179                 return;
180                 }
181
182         switcho ){
183         case ANDAND:
184         case OROR:
185         case QUEST:
186         case COLON:
187         case COMOP:
188                 p->su = maxmax(sul,sur), 1);
189                 return;
190
191         case PLUS:
192         case OR:
193         case ER:
194                 /* commutative ops; put harder on left */
195                 ifp->right->su > p->left->su && !istnode(p->left) ){
196                         register NODE *temp;
197                         temp = p->left;
198                         p->left = p->right;
199                         p->right = temp;
200                         }
201                 break;
202                 }
203
204         /* binary op, computed by left, then right, then do op */
205         p->su = max(sul,szty(p->right->type)+sur);
206 /*
207         if( o==MUL||o==DIV||o==MOD) p->su = max(p->su,fregs);
208  */
209
210         }
211
212 int radebug = 0;
213
214 rallopdown ) NODE *p; {
215         /* do register allocation */
216         register otypedown1down2ty;
217
218         ifradebug ) printf"rallo( %o, %d )\n"pdown );
219
220         down2 = NOPREF;
221         p->rall = down;
222         down1 = ( down &= ~MUSTDO );
223
224         ty = optypeo = p->op );
225         type = p->type;
226
227
228         iftype == DOUBLE || type == FLOAT ){
229                 ifo == FORCE ) down1 = R0|MUSTDO;
230                 }
231         else switcho ) {
232         case ASSIGN:    
233                 down1 = NOPREF;
234                 down2 = down;
235                 break;
236
237 /*
238         case MUL:
239         case DIV:
240         case MOD:
241                 down1 = R3|MUSTDO;
242                 down2 = R5|MUSTDO;
243                 break;
244
245         case ASG MUL:
246         case ASG DIV:
247         case ASG MOD:
248                 p->left->rall = down1 = R3|MUSTDO;
249                 if( p->left->op == UNARY MUL ){
250                         rallo( p->left->left, R4|MUSTDO );
251                         }
252                 else if( p->left->op == FLD  && p->left->left->op == UNARY MUL ){
253                         rallo( p->left->left->left, R4|MUSTDO );
254                         }
255                 else rallo( p->left, R3|MUSTDO );
256                 rallo( p->right, R5|MUSTDO );
257                 return;
258  */
259
260         case CALL:
261         case STASG:
262         case EQ:
263         case NE:
264         case GT:
265         case GE:
266         case LT:
267         case LE:
268         case NOT:
269         case ANDAND:
270         case OROR:
271                 down1 = NOPREF;
272                 break;
273
274         case FORCE:     
275                 down1 = R0|MUSTDO;
276                 break;
277
278                 }
279
280         ifty != LTYPE ) rallop->leftdown1 );
281         ifty == BITYPE ) rallop->rightdown2 );
282
283         }
284
285 offstarp ) register NODE *p; {
286         ifp->op == PLUS ) {
287                 ifp->left->su == fregs ) {
288                         orderp->leftINTAREG|INAREG );
289                         return;
290                 } else ifp->right->su == fregs ) {
291                         orderp->rightINTAREG|INAREG );
292                         return;
293                 }
294                 ifp->left->op==LS && 
295                   (p->left->left->op!=REG || tlen(p->left->left)!=sizeof(int) ) ) {
296                         orderp->left->leftINTAREG|INAREG );
297                         return;
298                 }
299                 ifp->right->op==LS &&
300                   (p->right->left->op!=REG || tlen(p->right->left)!=sizeof(int) ) ) {
301                         orderp->right->leftINTAREG|INAREG );
302                         return;
303                 }
304                 ifp->type == (PTR|CHAR) || p->type == (PTR|UCHAR) ) {
305                         ifp->left->op!=REG || tlen(p->left)!=sizeof(int) ) {
306                                 orderp->leftINTAREG|INAREG );
307                                 return;
308                         }
309                         else ifp->right->op!=REG || tlen(p->right)!=sizeof(int) ) {
310                                 order(p->rightINTAREG|INAREG);
311                                 return;
312                         }
313                 }
314         }
315         ifp->op == PLUS || p->op == MINUS ){
316                 ifp->right->op == ICON ){
317                         p = p->left;
318                         orderp , INTAREG|INAREG);
319                         return;
320                         }
321                 }
322
323         ifp->op == UNARY MUL && !canaddr(p) ) {
324                 offstarp->left );
325                 return;
326         }
327
328         orderpINTAREG|INAREG );
329         }
330
331 setincrp ) NODE *p; {
332         return0 );  /* for the moment, don't bother */
333         }
334
335 setbinp ) register NODE *p; {
336         register rort;
337
338         rt = p->right->type;
339         ro = p->right->op;
340
341         ifcanaddrp->left ) && !canaddrp->right ) ) { /* address rhs */
342                 ifro == UNARY MUL ) {
343                         offstarp->right->left );
344                         return(1);
345                 } else {
346                         orderp->rightINAREG|INTAREG|SOREG );
347                         return(1);
348                 }
349         }
350         if( !istnodep->left) ) { /* try putting LHS into a reg */
351 /*              order( p->left, logop(p->op)?(INAREG|INBREG|INTAREG|INTBREG|SOREG):(INTAREG|INTBREG|SOREG) );*/
352                 orderp->leftINAREG|INTAREG|INBREG|INTBREG|SOREG );
353                 return(1);
354                 }
355         else ifro == UNARY MUL && rt != CHAR && rt != UCHAR ){
356                 offstarp->right->left );
357                 return(1);
358                 }
359         else ifrt == CHAR || rt == UCHAR || rt == SHORT || rt == USHORT || (ro != REG &&
360                         ro != NAME && ro != OREG && ro != ICON ) ){
361                 orderp->rightINAREG|INBREG );
362                 return(1);
363                 }
364 /*
365         else if( logop(p->op) && rt==USHORT ){  /* must get rhs into register */
366 /*
367                 order( p->right, INAREG );
368                 return( 1 );
369                 }
370  */
371         return(0);
372         }
373
374 setstrp ) register NODE *p; { /* structure assignment */
375         ifp->right->op != REG ){
376                 orderp->rightINTAREG );
377                 return(1);
378                 }
379         p = p->left;
380         ifp->op != NAME && p->op != OREG ){
381                 ifp->op != UNARY MUL ) cerror"bad setstr" );
382                 orderp->leftINTAREG );
383                 return1 );
384                 }
385         return0 );
386         }
387
388 setasgp ) register NODE *p; {
389         /* setup for assignment operator */
390
391         if( !canaddr(p->right) ) {
392                 ifp->right->op == UNARY MUL )
393                         offstar(p->right->left);
394                 else
395                         orderp->rightINAREG|INBREG|SOREG );
396                 return(1);
397                 }
398         ifp->left->op == UNARY MUL ) {
399                 offstarp->left->left );
400                 return(1);
401                 }
402         ifp->left->op == FLD && p->left->left->op == UNARY MUL ){
403                 offstarp->left->left->left );
404                 return(1);
405                 }
406 /* FLD patch */
407         ifp->left->op == FLD && !(p->right->type==INT || p->right->type==UNSIGNED)) {
408                 orderp->rightINAREG);
409                 return(1);
410                 }
411 /* end of FLD patch */
412         return(0);
413         }
414
415 setasopp ) register NODE *p; {
416         /* setup for =ops */
417         register rtro;
418
419         rt = p->right->type;
420         ro = p->right->op;
421
422         ifro == UNARY MUL && rt != CHAR ){
423                 offstarp->right->left );
424                 return(1);
425                 }
426         if( ( rt == CHAR || rt == SHORT || rt == UCHAR || rt == USHORT ||
427                         ( ro != REG && ro != ICON && ro != NAME && ro != OREG ) ) ){
428                 orderp->rightINAREG|INBREG );
429                 return(1);
430                 }
431 /*
432         if( (p->op == ASG LS || p->op == ASG RS) && ro != ICON && ro != REG ){
433                 order( p->right, INAREG );
434                 return(1);
435                 }
436  */
437
438
439         p = p->left;
440         ifp->op == FLD ) p = p->left;
441
442         switchp->op ){
443
444         case REG:
445         case ICON:
446         case NAME:
447         case OREG:
448                 return(0);
449
450         case UNARY MUL:
451                 ifp->left->op==OREG )
452                         return(0);
453                 else
454                         offstarp->left );
455                 return(1);
456
457                 }
458         cerror"illegal setasop" );
459         }
460
461 int crslab = 9999;  /* Honeywell */
462
463 getlab(){
464         returncrslab-- );
465         }
466
467 deflabl ){
468         printf"L%d:\n"l );
469         }
470
471 genargspptemp ) register NODE *p, *ptemp; {
472         register NODE *pasg;
473         register align;
474         register size;
475         register TWORD type;
476
477         /* generate code for the arguments */
478
479         /*  first, do the arguments on the right */
480         whilep->op == CM ){
481                 genargsp->rightptemp );
482                 p->op = FREE;
483                 p = p->left;
484                 }
485
486         ifp->op == STARG ){ /* structure valued argument */
487
488                 size = p->stsize;
489                 align = p->stalign;
490
491  /*             ptemp->lval = (ptemp->lval/align)*align;  /* SETOFF for negative numbers */
492                 ptemp->lval = 0;        /* all moves to (sp) */
493
494                 p->op = STASG;
495                 p->right = p->left;
496                 p->left = tcopyptemp );
497
498                 /* the following line is done only with the knowledge
499                 that it will be undone by the STASG node, with the
500                 offset (lval) field retained */
501
502                 ifp->right->op == OREG ) p->right->op = REG;  /* only for temporaries */
503
504                 orderpFORARG );
505                 ptemp->lval += size;
506                 return;
507                 }
508
509         /* ordinary case */
510
511         orderpFORARG );
512         }
513
514 argsizep ) register NODE *p; {
515         register t;
516         t = 0;
517         ifp->op == CM ){
518                 t = argsizep->left );
519                 p = p->right;
520                 }
521         ifp->type == DOUBLE || p->type == FLOAT ){
522                 SETOFFt4 );
523                 returnt+8 );
524                 }
525         else ifp->op == STARG ){
526                 SETOFFt4 );  /* alignment */
527                 returnt + ((p->stsize+3)/4)*4 );  /* size */
528                 }
529         else {
530                 SETOFFt4 );
531                 returnt+4 );
532                 }
533         }
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 13:41 +0200