Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20110407185015

Diff

Diff from 1.11 to:

Annotations

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

Annotated File View

ragge
1.11
1 /*      $Id: local.c,v 1.11 2011/04/07 18:50:16 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:
ragge
1.2
16  *      This product includes software developed or owned by Caldera
ragge
1.1
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
ragge
1.2
26  * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
ragge
1.1
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 "pass1.h"
ragge
1.1
37
38 /*      this file contains code which is dependent on the target machine */
39
ragge
1.2
40 #if 0
ragge
1.1
41 NODE *
42 castpt ) register NODE *pTWORD t; {
43         /* cast node p to type t */
44
45         p = buildtreeCASTblockNAMENILNILt0, (int)t ), p );
46         p->left->op = FREE;
47         p->op = FREE;
48         returnp->right );
49         }
ragge
1.2
50 #endif
ragge
1.1
51
52 NODE *
53 clocal(pNODE *p; {
54
55         /* this is called to do local transformations on
56            an expression tree preparitory to its being
57            written out in intermediate code.
58         */
59
60         /* the major essential job is rewriting the
61            automatic variables and arguments in terms of
62            REG and OREG nodes */
63         /* conversion ops which are not necessary are also clobbered here */
64         /* in addition, any special features (such as rewriting
65            exclusive or) are easily handled here as well */
66
67         register struct symtab *q;
68         register NODE *r;
ragge
1.2
69         register int o;
70         register int mml;
ragge
1.1
71
ragge
1.2
72         switcho = p->n_op ){
ragge
1.1
73
74         case NAME:
ragge
1.2
75                 if((q = p->n_sp) == 0 ) { /* already processed; ignore... */
ragge
1.1
76                         return(p);
77                         }
78                 switchq->sclass ){
79
80                 case AUTO:
81                 case PARAM:
82                         /* fake up a structure reference */
83                         r = blockREGNILNILPTR+STRTY00 );
ragge
1.2
84                         r->n_lval = 0;
85                         r->n_rval = (q->sclass==AUTO?STKREG:ARGREG);
ragge
1.1
86                         p = strefblockSTREFrp000 ) );
87                         break;
88
89                 case STATIC:
90                         ifq->slevel == 0 ) break;
ragge
1.2
91                         p->n_lval = 0;
92                         p->n_rval = -q->soffset;
ragge
1.1
93                         break;
94
95                 case REGISTER:
ragge
1.2
96                         p->n_op = REG;
97                         p->n_lval = 0;
98                         p->n_rval = q->soffset;
ragge
1.1
99                         break;
100
101                         }
102                 break;
103
104         case PCONV:
105                 /* do pointer conversions for char and longs */
ragge
1.2
106                 ml = p->n_left->n_type;
107                 if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->n_left->n_op != ICON ) break;
ragge
1.1
108
109                 /* pointers all have the same representation; the type is inherited */
110
111         inherit:
ragge
1.2
112                 p->n_left->n_type = p->n_type;
113                 p->n_left->n_df = p->n_df;
114                 p->n_left->n_sue = p->n_sue;
115                 r = p->n_left;
116                 nfree(p);
117                 returnr );
ragge
1.1
118
119         case SCONV:
ragge
1.2
120                 m = (p->n_type == FLOAT || p->n_type == DOUBLE );
121                 ml = (p->n_left->n_type == FLOAT || p->n_left->n_type == DOUBLE );
ragge
1.1
122                 ifm != ml ) break;
123
124                 /* now, look for conversions downwards */
125
ragge
1.2
126                 m = p->n_type;
127                 ml = p->n_left->n_type;
128                 ifp->n_left->n_op == ICON ){ /* simulate the conversion here */
ragge
1.1
129                         CONSZ val;
ragge
1.2
130                         val = p->n_left->n_lval;
ragge
1.1
131                         switchm ){
132                         case CHAR:
ragge
1.2
133                                 p->n_left->n_lval = (charval;
ragge
1.1
134                                 break;
135                         case UCHAR:
ragge
1.2
136                                 p->n_left->n_lval = val & 0XFF;
ragge
1.1
137                                 break;
138                         case USHORT:
ragge
1.2
139                                 p->n_left->n_lval = val & 0XFFFFL;
ragge
1.1
140                                 break;
141                         case SHORT:
ragge
1.2
142                                 p->n_left->n_lval = (short)val;
ragge
1.1
143                                 break;
144                         case UNSIGNED:
ragge
1.2
145                                 p->n_left->n_lval = val & 0xFFFFFFFFL;
ragge
1.1
146                                 break;
147                         case INT:
ragge
1.2
148                                 p->n_left->n_lval = (int)val;
ragge
1.1
149                                 break;
150                                 }
ragge
1.2
151                         p->n_left->n_type = m;
ragge
1.1
152                         }
153                 else {
154                         /* meaningful ones are conversion of int to char, int to short,
155                            and short to char, and unsigned version of them */
156                         ifm==CHAR || m==UCHAR ){
157                                 ifml!=CHAR && ml!= UCHAR ) break;
158                                 }
159                         else ifm==SHORT || m==USHORT ){
160                                 ifml!=CHAR && ml!=UCHAR && ml!=SHORT && ml!=USHORT ) break;
161                                 }
162                         }
163
164                 /* clobber conversion */
ragge
1.2
165                 iftlen(p) == tlen(p->n_left) ) goto inherit;
166                 r = p->n_left;
167                 nfree(p);
168                 returnr );  /* conversion gets clobbered */
ragge
1.1
169
170         case PVCONV:
171         case PMCONV:
ragge
1.2
172                 ifp->n_right->n_op != ICON ) cerror"bad conversion"0);
173                 r = buildtreeo==PMCONV?MUL:DIVp->n_leftp->n_right);
174                 nfree(p);
175                 return r;
ragge
1.1
176
177         case RS:
ragge
1.2
178         case RSEQ:
ragge
1.1
179                 /* convert >> to << with negative shift count */
180                 /* only if type of left operand is not unsigned */
ragge
1.2
181                 ifISUNSIGNED(p->n_left->n_type) ) break;
182                 p->n_right = buildtreeUMINUSp->n_rightNIL );
183                 ifp->n_op == RS ) p->n_op = LS;
184                 else p->n_op = LSEQ;
185                 break;
186
187         case FORCE:
188                 p->n_op = ASSIGN;
189                 p->n_right = p->n_left;
ragge
1.11
190                 p->n_left = block(REGNILNILp->n_type00);
ragge
1.2
191                 p->n_left->n_rval = p->n_left->n_type == BOOL ? 
192                     RETREG(CHAR) : RETREG(p->n_type);
ragge
1.1
193                 break;
194
ragge
1.2
195         case STCALL:
196         case CALL:
197                 /* Fix function call arguments. On vax, just add funarg */
198                 for (r = p->n_rightr->n_op == CMr = r->n_left) {
199                         if (r->n_right->n_op != STARG &&
200                             r->n_right->n_op != FUNARG)
201                                 r->n_right = block(FUNARGr->n_rightNIL
202                                     r->n_right->n_typer->n_right->n_df,
203                                     r->n_right->n_sue);
204                 }
205                 if (r->n_op != STARG && r->n_op != FUNARG) {
206                         NODE *l = talloc();
207                         *l = *r;
208                         r->n_op = FUNARGr->n_left = lr->n_type = l->n_type;
ragge
1.1
209                 }
ragge
1.2
210                 break;
211         }
ragge
1.1
212
213         return(p);
ragge
1.2
214 }
ragge
1.1
215
gmcgarry
1.4
216 void
217 myp2tree(NODE *p)
218 {
ragge
1.8
219         struct symtab *sp;
ragge
1.5
220         int o = p->n_opi;
221
222         if (o != FCON
223                 return;
224
ragge
1.8
225         sp = inlalloc(sizeof(struct symtab));
226         sp->sclass = STATIC;
ragge
1.11
227         sp->ssue = 0;
ragge
1.8
228         sp->slevel = 1/* fake numeric label */
229         sp->soffset = getlab();
230         sp->sflags = 0;
231         sp->stype = p->n_type;
232         sp->squal = (CON >> TSHIFT);
233
234         defloc(sp);
235         ninval(0sp->ssue->suesizep);
236
ragge
1.5
237         p->n_op = NAME;
ragge
1.8
238         p->n_lval = 0;
239         p->n_sp = sp;
ragge
1.5
240
gmcgarry
1.4
241 }
242
ragge
1.3
243 /*
244  * Can we take & of a NAME?
245  */
ragge
1.2
246 int
ragge
1.3
247 andable(NODE *p)
248 {
249
250         if ((p->n_type & ~BTMASK) == FTN)
251                 return 1/* functions are called by name */
252         return 0/* Delay name reference to table, for PIC code generation */
253 }
ragge
1.2
254  
255 void
ragge
1.1
256 cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
257         autooff = AUTOINIT;
258         }
259
ragge
1.2
260 int
ragge
1.1
261 cisregt ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
ragge
1.2
262         return(1);      /* all are now */
ragge
1.1
263         }
264
265 NODE *
ragge
1.2
266 offcon(OFFSZ offTWORD tunion dimfun *dstruct suedef *sue)
267 {
ragge
1.1
268
269         /* return a node, for structure references, which is suitable for
270            being added to a pointer of type t, in order to be off bits offset
271            into a structure */
272
273         register NODE *p;
274
275         /* t, d, and s are the type, dimension offset, and sizeoffset */
276         /* in general they  are necessary for offcon, but not on H'well */
277
278         p = bcon(0);
ragge
1.2
279         p->n_lval = off/SZCHAR;
ragge
1.1
280         return(p);
281
282         }
283
ragge
1.2
284 void
285 spalloc(NODE *tNODE *pOFFSZ off)
286 {
287         cerror("spalloc");
288 }
ragge
1.1
289
ragge
1.2
290 static int inbitsinval;
ragge
1.1
291
ragge
1.2
292 /*
293  * set fsz bits in sequence to zero.
294  */
295 void
296 zbits(OFFSZ offint fsz)
297 {
298         int m;
ragge
1.1
299
ragge
1.2
300         if (idebug)
301                 printf("zbits off %lld, fsz %d inbits %d\n"offfszinbits);
302         if ((m = (inbits % SZCHAR))) {
303                 m = SZCHAR - m;
304                 if (fsz < m) {
305                         inbits += fsz;
306                         return;
307                 } else {
308                         fsz -= m;
309                         printf("\t.byte %d\n"inval);
310                         inval = inbits = 0;
311                 }
ragge
1.1
312         }
ragge
1.2
313         if (fsz >= SZCHAR) {
314                 printf("\t.space %d\n"fsz/SZCHAR);
315                 fsz -= (fsz/SZCHAR) * SZCHAR;
316         }
317         if (fsz) {
318                 inval = 0;
319                 inbits = fsz;
ragge
1.1
320         }
ragge
1.2
321 }
ragge
1.1
322
ragge
1.2
323 /*
324  * Initialize a bitfield.
325  */
326 void
327 infld(CONSZ offint fszCONSZ val)
328 {
329         if (idebug)
330                 printf("infld off %lld, fsz %d, val %lld inbits %d\n",
331                     offfszvalinbits);
332         val &= ((CONSZ)1 << fsz)-1;
333         while (fsz + inbits >= SZCHAR) {
334                 inval |= (val << inbits);
335                 printf("\t.byte %d\n"inval & 255);
336                 fsz -= (SZCHAR - inbits);
337                 val >>= (SZCHAR - inbits);
338                 inval = inbits = 0;
339         }
340         if (fsz) {
341                 inval |= (val << inbits);
342                 inbits += fsz;
ragge
1.1
343         }
ragge
1.2
344 }
ragge
1.1
345
346
347 char *
348 exnamep ) char *p; {
349         /* make a name look like an external name in the local machine */
ragge
1.2
350         /* vad is elf now */
351         if (p == NULL)
352                 return "";
353         returnp );
ragge
1.1
354         }
355
ragge
1.2
356 TWORD
357 ctype(TWORD type ){ /* map types which are not defined on the local machine */
ragge
1.1
358         switchBTYPE(type) ){
359
360         case LONG:
361                 MODTYPE(type,INT);
362                 break;
363
364         case ULONG:
365                 MODTYPE(type,UNSIGNED);
ragge
1.2
366                 break;
367
368         case LDOUBLE:   /* for now */
369                 MODTYPE(type,DOUBLE);
ragge
1.1
370                 }
371         returntype );
372         }
373
ragge
1.2
374 void
375 calldec(NODE *pNODE *q
376 {
377 }
ragge
1.1
378
ragge
1.2
379 void
380 extdec(struct symtab *q)
381 {
382 }
ragge
1.1
383
ragge
1.2
384 void
385 commdecstruct symtab *q ){ /* make a common declaration for id, if reasonable */
386         OFFSZ off;
ragge
1.1
387
ragge
1.9
388         printf"       .comm   %s,"q->soname ? q->soname : exnameq->sname ) );
ragge
1.2
389         off = tsizeq->stypeq->sdfq->ssue );
ragge
1.1
390         printfCONFMToff/SZCHAR );
391         printf"\n" );
392         }
393
ragge
1.2
394 /* make a local common declaration for id, if reasonable */
395 void
396 lcommdec(struct symtab *q)
397 {
398         int off;
ragge
1.1
399
ragge
1.2
400         off = tsize(q->stypeq->sdfq->ssue);
401         off = (off+(SZCHAR-1))/SZCHAR;
402         if (q->slevel == 0)
ragge
1.9
403                 printf("        .lcomm %s,0%o\n"q->soname ? q->soname : exname(q->sname), off);
ragge
1.2
404         else
405                 printf("        .lcomm " LABFMT ",0%o\n"q->soffsetoff);
406 }
ragge
1.1
407
408
ragge
1.2
409 static char *loctbl[] = { "text""data""section .rodata""section .rodata" };
ragge
1.1
410
ragge
1.2
411 void
412 setloc1(int locc)
413 {
414         if (locc == lastloc)
415                 return;
416         lastloc = locc;
417         printf("        .%s\n"loctbl[locc]);
418 }
ragge
1.1
419
ragge
1.2
420 /*
421  * print out a constant node, may be associated with a label.
422  * Do not free the node after use.
423  * off is bit offset from the beginning of the aggregate
424  * fsz is the number of bits this is referring to
425  * XXX - floating point constants may be wrong if cross-compiling.
426  */
427 void
428 ninval(CONSZ offint fszNODE *p)
429 {
430         union { float fdouble dlong double lint i[3]; } u;
431         struct symtab *q;
432         TWORD t;
433
434         t = p->n_type;
435         if (t > BTMASK)
436                 t = INT/* pointer */
437
438         if (p->n_op != ICON && p->n_op != FCON)
439                 cerror("ninval: init node not constant");
440
441         if (p->n_op == ICON && p->n_sp != NULL && DEUNSIGN(t) != INT)
442                 uerror("element not constant");
443
444         switch (t) {
445         case LONGLONG:
446         case ULONGLONG:
447                 printf("\t.long 0x%x", (int)p->n_lval);
448                 printf("\t.long 0x%x", (int)(p->n_lval >> 32));
449                 break;
450         case INT:
451         case UNSIGNED:
452                 printf("\t.long 0x%x", (int)p->n_lval);
453                 if ((q = p->n_sp) != NULL) {
ragge
1.8
454                         if ((q->sclass == STATIC && q->slevel > 0)) {
ragge
1.2
455                                 printf("+" LABFMTq->soffset);
456                         } else
ragge
1.9
457                                 printf("+%s"q->soname ? q->soname : exname(q->sname));
ragge
1.1
458                 }
ragge
1.2
459                 printf("\n");
460                 break;
461         case SHORT:
462         case USHORT:
463                 printf("\t.short 0x%x\n", (int)p->n_lval & 0xffff);
464                 break;
465         case BOOL:
466                 if (p->n_lval > 1)
467                         p->n_lval = p->n_lval != 0;
468                 /* FALLTHROUGH */
469         case CHAR:
470         case UCHAR:
471                 printf("\t.byte %d\n", (int)p->n_lval & 0xff);
472                 break;
473         case LDOUBLE:
474                 u.i[2] = 0;
475                 u.l = (long double)p->n_dcon;
476                 printf("\t.long\t0x%x,0x%x,0x%x\n"u.i[0], u.i[1], u.i[2]);
477                 break;
478         case DOUBLE:
479                 u.d = (double)p->n_dcon;
480                 printf("\t.long\t0x%x,0x%x\n"u.i[0], u.i[1]);
481                 break;
482         case FLOAT:
483                 u.f = (float)p->n_dcon;
484                 printf("\t.long\t0x%x\n"u.i[0]);
485                 break;
ragge
1.1
486         default:
ragge
1.2
487                 cerror("ninval");
ragge
1.1
488         }
489
490 }
ragge
1.6
491 /*
492  * Give target the opportunity of handling pragmas.
493  */
494 int
ragge
1.10
495 mypragma(char *str)
ragge
1.6
496 {
ragge
1.10
497         return 0;
498 }
ragge
1.6
499
500 /*
501  * Called when a identifier has been declared, to give target last word.
502  */
503 void
504 fixdef(struct symtab *sp)
505 {
506 }
507
gmcgarry
1.7
508 void
509 pass1_lastchance(struct interpass *ip)
510 {
511 }
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-01 10:17 +0200