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/local.c

Annotated File View

ragge
1.1
1 /*      $Id: local.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 "mfile1"
37
38 /*      this file contains code which is dependent on the target machine */
39
40 NODE *
41 castpt ) register NODE *pTWORD t; {
42         /* cast node p to type t */
43
44         p = buildtreeCASTblockNAMENILNILt0, (int)t ), p );
45         p->left->op = FREE;
46         p->op = FREE;
47         returnp->right );
48         }
49
50 NODE *
51 clocal(pNODE *p; {
52
53         /* this is called to do local transformations on
54            an expression tree preparitory to its being
55            written out in intermediate code.
56         */
57
58         /* the major essential job is rewriting the
59            automatic variables and arguments in terms of
60            REG and OREG nodes */
61         /* conversion ops which are not necessary are also clobbered here */
62         /* in addition, any special features (such as rewriting
63            exclusive or) are easily handled here as well */
64
65         register struct symtab *q;
66         register NODE *r;
67         register o;
68         register mml;
69
70         switcho = p->op ){
71
72         case NAME:
73                 ifp->rval < 0 ) { /* already processed; ignore... */
74                         return(p);
75                         }
76                 q = &stab[p->rval];
77                 switchq->sclass ){
78
79                 case AUTO:
80                 case PARAM:
81                         /* fake up a structure reference */
82                         r = blockREGNILNILPTR+STRTY00 );
83                         r->lval = 0;
84                         r->rval = (q->sclass==AUTO?STKREG:ARGREG);
85                         p = strefblockSTREFrp000 ) );
86                         break;
87
88                 case ULABEL:
89                 case LABEL:
90                 case STATIC:
91                         ifq->slevel == 0 ) break;
92                         p->lval = 0;
93                         p->rval = -q->offset;
94                         break;
95
96                 case REGISTER:
97                         p->op = REG;
98                         p->lval = 0;
99                         p->rval = q->offset;
100                         break;
101
102                         }
103                 break;
104
105         case PCONV:
106                 /* do pointer conversions for char and longs */
107                 ml = p->left->type;
108                 if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->left->op != ICON ) break;
109
110                 /* pointers all have the same representation; the type is inherited */
111
112         inherit:
113                 p->left->type = p->type;
114                 p->left->cdim = p->cdim;
115                 p->left->csiz = p->csiz;
116                 p->op = FREE;
117                 returnp->left );
118
119         case SCONV:
120                 m = (p->type == FLOAT || p->type == DOUBLE );
121                 ml = (p->left->type == FLOAT || p->left->type == DOUBLE );
122                 ifm != ml ) break;
123
124                 /* now, look for conversions downwards */
125
126                 m = p->type;
127                 ml = p->left->type;
128                 ifp->left->op == ICON ){ /* simulate the conversion here */
129                         CONSZ val;
130                         val = p->left->lval;
131                         switchm ){
132                         case CHAR:
133                                 p->left->lval = (charval;
134                                 break;
135                         case UCHAR:
136                                 p->left->lval = val & 0XFF;
137                                 break;
138                         case USHORT:
139                                 p->left->lval = val & 0XFFFFL;
140                                 break;
141                         case SHORT:
142                                 p->left->lval = (short)val;
143                                 break;
144                         case UNSIGNED:
145                                 p->left->lval = val & 0xFFFFFFFFL;
146                                 break;
147                         case INT:
148                                 p->left->lval = (int)val;
149                                 break;
150                                 }
151                         p->left->type = m;
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 */
165                 iftlen(p) == tlen(p->left) ) goto inherit;
166                 p->op = FREE;
167                 returnp->left );  /* conversion gets clobbered */
168
169         case PVCONV:
170         case PMCONV:
171                 ifp->right->op != ICON ) cerror"bad conversion"0);
172                 p->op = FREE;
173                 returnbuildtreeo==PMCONV?MUL:DIVp->leftp->right ) );
174
175         case RS:
176         case ASG RS:
177                 /* convert >> to << with negative shift count */
178                 /* only if type of left operand is not unsigned */
179                 ifISUNSIGNED(p->left->type) ) break;
180                 p->right = buildtreeUNARY MINUSp->rightNIL );
181                 ifp->op == RS ) p->op = LS;
182                 else p->op = ASG LS;
183                 break;
184
185                 }
186
187         return(p);
188         }
189
190 andablep ) NODE *p; {
191         return(1);  /* all names can have & taken on them */
192         }
193
194 cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
195         autooff = AUTOINIT;
196         }
197
198 cisregt ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
199
200         ift==INT || t==UNSIGNED || t==LONG || t==ULONG        /* tbl */
201                 || t==CHAR || t==UCHAR || t==SHORT || t==USHORT /* tbl */
202                 || ISPTR(t)) return(1);                 /* tbl */
203         return(0);
204         }
205
206 NODE *
207 offconofftds ) OFFSZ offTWORD t; {
208
209         /* return a node, for structure references, which is suitable for
210            being added to a pointer of type t, in order to be off bits offset
211            into a structure */
212
213         register NODE *p;
214
215         /* t, d, and s are the type, dimension offset, and sizeoffset */
216         /* in general they  are necessary for offcon, but not on H'well */
217
218         p = bcon(0);
219         p->lval = off/SZCHAR;
220         return(p);
221
222         }
223
224
225 incodepsz ) register NODE *p; {
226
227         /* generate initialization code for assigning a constant c
228                 to a field of width sz */
229         /* we assume that the proper alignment has been obtained */
230         /* inoff is updated to have the proper final value */
231         /* we also assume sz  < SZINT */
232
233         inoff += sz;
234         if (sz>SZSHORT
235                 printf("        .long   %d:%d\n"szp->lval);
236         else if (sz>SZCHAR)
237                 printf("        .word   %d:%d\n"szp->lval);
238         else
239                 printf("        .byte   %d:%d\n"szp->lval);
240         }
241
242 fincodedsz ) double d; {
243         /* output code to initialize space of size sz to the value d */
244         /* the proper alignment has been obtained */
245         /* inoff is updated to have the proper final value */
246         /* on the target machine, write it out in octal! */
247
248
249         printf("        %s      0%c%.20e\n"sz == SZDOUBLE ? ".double" : ".float",
250                 sz == SZDOUBLE ? 'd' : 'f'd);
251         inoff += sz;
252         }
253
254 cinitpsz ) NODE *p; {
255         /* arrange for the initialization of p into a space of
256         size sz */
257         /* the proper alignment has been opbtained */
258         /* inoff is updated to have the proper final value */
259         ecodep );
260         inoff += sz;
261         }
262
263 vfdzeron ){ /* define n bits of zeros in a vfd */
264         register i;
265
266         ifn <= 0 ) return;
267
268         inoff += n;
269         i = n;
270         while (i>=SZCHAR) {
271                 printf("        .byte   0\n");
272                 i -= SZCHAR;
273         }
274         if (iprintf(" .byte   %d:0\n"i);
275         }
276
277
278 char *
279 exnamep ) char *p; {
280         /* make a name look like an external name in the local machine */
281
282         static char text[NCHNAM+1];
283
284         register i;
285
286         text[0] = '_';
287         fori=1; *p&&i<NCHNAM; ++i ){
288                 text[i] = *p++;
289                 }
290
291         text[i] = '\0';
292         text[NCHNAM] = '\0';  /* truncate */
293
294         returntext );
295         }
296
297 ctypetype ){ /* map types which are not defined on the local machine */
298         switchBTYPE(type) ){
299
300         case LONG:
301                 MODTYPE(type,INT);
302                 break;
303
304         case ULONG:
305                 MODTYPE(type,UNSIGNED);
306                 }
307         returntype );
308         }
309
310 noinitt ) { /* curid is a variable which is defined but
311         is not initialized (and not a function );
312         This routine returns the stroage class for an uninitialized declaration */
313
314         return(EXTERN);
315
316         }
317
318 commdecid ){ /* make a common declaration for id, if reasonable */
319         register struct symtab *q;
320         OFFSZ offtsize();
321
322         q = &stab[id];
323         printf"       .comm   %s,"exnameq->sname ) );
324         off = tsizeq->stypeq->dimoffq->sizoff );
325         printfCONFMToff/SZCHAR );
326         printf"\n" );
327         }
328
329 isitlongcbce ){ /* is lastcon to be long or short */
330         /* cb is the first character of the representation, ce the last */
331
332         ifce == 'l' || ce == 'L' ||
333                 lastcon >= (1L << (SZINT-1) ) ) return (1);
334         return(0);
335         }
336
337
338 isitfloats ) char *s; {
339         double atof();
340         dcon = atof(s);
341         returnFCON );
342         }
343
344 ecodep ) NODE *p; {
345
346         /* walk the tree and write out the nodes.. */
347
348         ifnerrors ) return;
349         p2treep );
350         p2compilep );
351         }
352         
353 #include "a.out.h"
354 int ddebug;
355 int gdebug;
356
357
358 outstab(p)
359 struct symtab *p; {
360         register TWORD ptype;
361         register char *pname;
362         register char pclass;
363         register int poffset;
364
365         if (!gdebugreturn;
366
367         ptype = p->stype;
368         pname = p->sname;
369         pclass = p->sclass;
370         poffset = p->offset;
371
372         if (ISFTN(ptype)) {
373                 return;
374         }
375         
376         switch (pclass) {
377         
378         case AUTO:
379                 pstab(pnameN_LSYM);
380                 printf("0,%d,%d\n"ptype, (-poffset)/SZCHAR);
381                 poffs(p);
382                 return;
383         
384         case EXTDEF:
385         case EXTERN:
386                 pstab(pnameN_GSYM);
387                 printf("0,%d,0\n"ptype);
388                 poffs(p);
389                 return;
390                         
391         case STATIC:
392                 pstab(pnameN_STSYM);
393                 if (p->slevel > 1) {
394                         printf("0,%d,L%d\n"ptypepoffset);
395                 } else {
396                         printf("0,%d,%s\n"ptypeexname(pname));
397                 }
398                 poffs(p);
399                 return;
400         
401         case REGISTER:
402                 pstab(pnameN_RSYM);
403                 printf("0,%d,%d\n"ptypepoffset);
404                 poffs(p);
405                 return;
406         
407         case MOS:
408         case MOU:
409                 pstab(pnameN_SSYM);
410                 printf("0,%d,%d\n"ptypepoffset/SZCHAR);
411                 poffs(p);
412                 return;
413         
414         case PARAM:
415                 /* parameter stab entries are processed in dclargs() */
416                 return;
417         
418         default:
419                 if (ddebugprintf("    No .stab for %.8s\n"pname);
420         }
421 }
422
423 pstab(nametype)
424 char *name;
425 int type; {
426         register int i;
427         register char c;
428         if (!gdebugreturn;
429         printf("        .stab   ");
430         for(i=0i<8i++) 
431                 if (c = name[i]) printf("'%c,"c);
432                 else printf("0,");
433         printf("0%o,"type);
434 }
435
436 poffs(p)
437 register struct symtab *p; {
438         int s;
439         if (!gdebugreturn;
440         if ((s = dimtab[p->sizoff]/SZCHAR) > 1) {
441                 pstab(p->snameN_LENG);
442                 printf("1,0,%d\n"s);
443         }
444 }
445
446 char NULLNAME[8];
447 int  labelno;
448 int  fdefflag;
449
450 psline() {
451         static int lastlineno;
452         register char *cp, *cq;
453         register int i;
454         
455         if (!gdebugreturn;
456
457         cq = ititle;
458         cp = ftitle;
459
460         while ( *cq ) if ( *cp++ != *cq++ ) goto neq;
461         if ( *cp == '\0' ) goto eq;
462         
463 neq:    for (i=0i<100i++)
464                 ititle[i] = '\0';
465         cp = ftitle;
466         cq = ititle;
467         while ( *cp )  
468                 *cq++ = *cp++;
469         *cq = '\0';
470         *--cq = '\0';
471         for ( cp = ititle+1; *(cp-1); cp += 8 ) {
472                 pstab(cpN_SOL);
473                 if (gdebugprintf("0,0,LL%d\n"labelno);
474                 }
475         *cq = '"';
476         printf("LL%d:\n"labelno++);
477
478 eq:     if (lineno == lastlinenoreturn;
479         lastlineno = lineno;
480
481         if (fdefflag) {
482                 pstab(NULLNAMEN_SLINE);
483                 printf("0,%d,LL%d\n"linenolabelno);
484                 printf("LL%d:\n"labelno++);
485                 }
486         }
487         
488 plcstab(level) {
489         if (!gdebugreturn;
490         pstab(NULLNAMEN_LBRAC);
491         printf("0,%d,LL%d\n"levellabelno);
492         printf("LL%d:\n"labelno++);
493         }
494         
495 prcstab(level) {
496         if (!gdebugreturn;
497         pstab(NULLNAMEN_RBRAC);
498         printf("0,%d,LL%d\n"levellabelno);
499         printf("LL%d:\n"labelno++);
500         }
501         
502 pfstab(sname
503 char *sname; {
504         if (!gdebugreturn;
505         pstab(snameN_FUN);
506         printf("0,%d,_%.7s\n"linenosname);
507 }
508
509 #ifndef ONEPASS
510 tlen(pNODE *p
511 {
512         switch(p->type) {
513                 case CHAR:
514                 case UCHAR:
515                         return(1);
516                         
517                 case SHORT:
518                 case USHORT:
519                         return(2);
520                         
521                 case DOUBLE:
522                         return(8);
523                         
524                 default:
525                         return(4);
526                 }
527         }
528 #endif
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 09:01 +0200