Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20110627115025

Diff

Diff from 1.17 to:

Annotations

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

Annotated File View

ragge
1.17
1 /*      $Id: local.c,v 1.17 2011/06/27 11:50:25 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
ragge
1.17
38 static void r1arg(NODE *pNODE *q);
ragge
1.1
39
40
ragge
1.17
41 /*      this file contains code which is dependent on the target machine */
ragge
1.1
42
43 NODE *
44 clocal(pNODE *p; {
45
46         /* this is called to do local transformations on
47            an expression tree preparitory to its being
48            written out in intermediate code.
49         */
50
51         /* the major essential job is rewriting the
52            automatic variables and arguments in terms of
53            REG and OREG nodes */
54         /* conversion ops which are not necessary are also clobbered here */
55         /* in addition, any special features (such as rewriting
56            exclusive or) are easily handled here as well */
57
58         register struct symtab *q;
59         register NODE *r;
ragge
1.2
60         register int o;
61         register int mml;
ragge
1.1
62
ragge
1.2
63         switcho = p->n_op ){
ragge
1.1
64
65         case NAME:
ragge
1.2
66                 if((q = p->n_sp) == 0 ) { /* already processed; ignore... */
ragge
1.1
67                         return(p);
68                         }
69                 switchq->sclass ){
70
71                 case AUTO:
72                 case PARAM:
73                         /* fake up a structure reference */
74                         r = blockREGNILNILPTR+STRTY00 );
ragge
1.2
75                         r->n_lval = 0;
76                         r->n_rval = (q->sclass==AUTO?STKREG:ARGREG);
ragge
1.1
77                         p = strefblockSTREFrp000 ) );
78                         break;
79
80                 case STATIC:
81                         ifq->slevel == 0 ) break;
ragge
1.2
82                         p->n_lval = 0;
83                         p->n_rval = -q->soffset;
ragge
1.1
84                         break;
85
86                 case REGISTER:
ragge
1.2
87                         p->n_op = REG;
88                         p->n_lval = 0;
89                         p->n_rval = q->soffset;
ragge
1.1
90                         break;
91
92                         }
93                 break;
94
95         case PCONV:
96                 /* do pointer conversions for char and longs */
ragge
1.2
97                 ml = p->n_left->n_type;
98                 if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->n_left->n_op != ICON ) break;
ragge
1.1
99
100                 /* pointers all have the same representation; the type is inherited */
101
102         inherit:
ragge
1.2
103                 p->n_left->n_type = p->n_type;
104                 p->n_left->n_df = p->n_df;
ragge
1.16
105                 p->n_left->n_ap = p->n_ap;
ragge
1.2
106                 r = p->n_left;
107                 nfree(p);
108                 returnr );
ragge
1.1
109
110         case SCONV:
ragge
1.2
111                 m = (p->n_type == FLOAT || p->n_type == DOUBLE );
112                 ml = (p->n_left->n_type == FLOAT || p->n_left->n_type == DOUBLE );
ragge
1.1
113                 ifm != ml ) break;
114
115                 /* now, look for conversions downwards */
116
ragge
1.2
117                 m = p->n_type;
118                 ml = p->n_left->n_type;
119                 ifp->n_left->n_op == ICON ){ /* simulate the conversion here */
ragge
1.1
120                         CONSZ val;
ragge
1.2
121                         val = p->n_left->n_lval;
ragge
1.1
122                         switchm ){
123                         case CHAR:
ragge
1.2
124                                 p->n_left->n_lval = (charval;
ragge
1.1
125                                 break;
126                         case UCHAR:
ragge
1.2
127                                 p->n_left->n_lval = val & 0XFF;
ragge
1.1
128                                 break;
129                         case USHORT:
ragge
1.2
130                                 p->n_left->n_lval = val & 0XFFFFL;
ragge
1.1
131                                 break;
132                         case SHORT:
ragge
1.2
133                                 p->n_left->n_lval = (short)val;
ragge
1.1
134                                 break;
135                         case UNSIGNED:
ragge
1.2
136                                 p->n_left->n_lval = val & 0xFFFFFFFFL;
ragge
1.1
137                                 break;
138                         case INT:
ragge
1.2
139                                 p->n_left->n_lval = (int)val;
ragge
1.1
140                                 break;
141                                 }
ragge
1.2
142                         p->n_left->n_type = m;
ragge
1.1
143                         }
144                 else {
145                         /* meaningful ones are conversion of int to char, int to short,
146                            and short to char, and unsigned version of them */
147                         ifm==CHAR || m==UCHAR ){
148                                 ifml!=CHAR && ml!= UCHAR ) break;
149                                 }
150                         else ifm==SHORT || m==USHORT ){
151                                 ifml!=CHAR && ml!=UCHAR && ml!=SHORT && ml!=USHORT ) break;
152                                 }
153                         }
154
155                 /* clobber conversion */
ragge
1.2
156                 iftlen(p) == tlen(p->n_left) ) goto inherit;
157                 r = p->n_left;
158                 nfree(p);
159                 returnr );  /* conversion gets clobbered */
ragge
1.1
160
161         case RS:
ragge
1.2
162         case RSEQ:
ragge
1.1
163                 /* convert >> to << with negative shift count */
164                 /* only if type of left operand is not unsigned */
ragge
1.2
165                 ifISUNSIGNED(p->n_left->n_type) ) break;
166                 p->n_right = buildtreeUMINUSp->n_rightNIL );
167                 ifp->n_op == RS ) p->n_op = LS;
168                 else p->n_op = LSEQ;
169                 break;
170
171         case FORCE:
172                 p->n_op = ASSIGN;
173                 p->n_right = p->n_left;
ragge
1.11
174                 p->n_left = block(REGNILNILp->n_type00);
ragge
1.2
175                 p->n_left->n_rval = p->n_left->n_type == BOOL ? 
176                     RETREG(CHAR) : RETREG(p->n_type);
ragge
1.1
177                 break;
178
ragge
1.2
179         case STCALL:
ragge
1.17
180                 /* see if we have been here before */
181                 for (r = p->n_rightr->n_op == CMr = r->n_left)
182                         ;
183                 if (r->n_op == ASSIGN)
184                         break;
185
186                 /* FALLTHROUGH */
187         case USTCALL:
188                 /* Allocate buffer on stack to bounce via */
189                 /* create fake symtab here */
190                 /* first check if we have been here before */
191                 q = getsymtab("77fake"STEMP);
192                 q->stype = BTYPE(p->n_type);
193                 q->sdf = p->n_df;
194                 q->sap = p->n_ap;
195                 q->soffset = NOOFFSET;
196                 q->sclass = AUTO;
197                 oalloc(q, &autooff);
198                 r1arg(pbuildtree(ADDROFnametree(q), 0));
ragge
1.2
199                 break;
200         }
ragge
1.1
201
202         return(p);
ragge
1.2
203 }
ragge
1.1
204
ragge
1.17
205 /*
206  * Add R1 with the dest address as arg to a struct return call.
207  */
208 static void
209 r1arg(NODE *pNODE *q)
210 {
211         NODE *r;
212
213         r = block(REGNILNILPTR|VOID00);
214         regno(r) = R1;
215         r = buildtree(ASSIGNrq);
216         if (p->n_op == USTCALL) {
217                 p->n_op = STCALL;
218                 p->n_right = r;
219         } else if (p->n_right->n_op != CM) {
220                 p->n_right = block(CMrp->n_rightINT00);
221         } else {
222                 for (q = p->n_rightq->n_left->n_op == CMq = q->n_left)
223                         ;
224                 q->n_left = block(CMrq->n_leftINT00);
225         }
226 }
227
gmcgarry
1.4
228 void
229 myp2tree(NODE *p)
230 {
ragge
1.8
231         struct symtab *sp;
ragge
1.5
232
ragge
1.16
233         if (p->n_op != FCON
ragge
1.5
234                 return;
235
ragge
1.8
236         sp = inlalloc(sizeof(struct symtab));
237         sp->sclass = STATIC;
ragge
1.16
238         sp->sap = 0;
ragge
1.8
239         sp->slevel = 1/* fake numeric label */
240         sp->soffset = getlab();
241         sp->sflags = 0;
242         sp->stype = p->n_type;
243         sp->squal = (CON >> TSHIFT);
244
245         defloc(sp);
ragge
1.16
246         inval(0tsize(sp->stypesp->sdfsp->sap), p);
ragge
1.8
247
ragge
1.5
248         p->n_op = NAME;
ragge
1.8
249         p->n_lval = 0;
250         p->n_sp = sp;
ragge
1.5
251
gmcgarry
1.4
252 }
253
ragge
1.3
254 /*
255  * Can we take & of a NAME?
256  */
ragge
1.2
257 int
ragge
1.3
258 andable(NODE *p)
259 {
260
261         if ((p->n_type & ~BTMASK) == FTN)
262                 return 1/* functions are called by name */
263         return 0/* Delay name reference to table, for PIC code generation */
264 }
ragge
1.2
265  
266 int
ragge
1.1
267 cisregt ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
ragge
1.2
268         return(1);      /* all are now */
ragge
1.1
269         }
270
ragge
1.2
271 void
272 spalloc(NODE *tNODE *pOFFSZ off)
273 {
274         cerror("spalloc");
275 }
ragge
1.1
276
277 char *
278 exnamep ) char *p; {
279         /* make a name look like an external name in the local machine */
ragge
1.2
280         /* vad is elf now */
281         if (p == NULL)
282                 return "";
283         returnp );
ragge
1.1
284         }
285
ragge
1.2
286 TWORD
287 ctype(TWORD type ){ /* map types which are not defined on the local machine */
ragge
1.1
288         switchBTYPE(type) ){
289
290         case LONG:
291                 MODTYPE(type,INT);
292                 break;
293
294         case ULONG:
295                 MODTYPE(type,UNSIGNED);
ragge
1.2
296                 break;
297
298         case LDOUBLE:   /* for now */
299                 MODTYPE(type,DOUBLE);
ragge
1.1
300                 }
301         returntype );
302         }
303
ragge
1.2
304 void
305 calldec(NODE *pNODE *q
306 {
307 }
ragge
1.1
308
ragge
1.2
309 void
310 extdec(struct symtab *q)
311 {
312 }
ragge
1.1
313
ragge
1.16
314 /* make a common declaration for id, if reasonable */
ragge
1.2
315 void
ragge
1.16
316 defzero(struct symtab *sp)
ragge
1.2
317 {
ragge
1.16
318         int offal;
319         char *name;
ragge
1.1
320
ragge
1.16
321         if ((name = sp->soname) == NULL)
322                 name = exname(sp->sname);
323         off = tsize(sp->stypesp->sdfsp->sap);
324         SETOFF(off,SZCHAR);
325         off /= SZCHAR;
326         al = talign(sp->stypesp->sap)/SZCHAR;
327
328         if (sp->sclass == STATIC)
329                 printf("\t.local %s\n"name);
330         if (sp->slevel == 0) {
331                 printf("\t.comm %s,0%o,%d\n"nameoffal);
332         } else
333                 printf("\t.comm " LABFMT ",0%o,%d\n"sp->soffsetoffal);
ragge
1.2
334 }
ragge
1.1
335
ragge
1.2
336 /*
337  * print out a constant node, may be associated with a label.
338  * Do not free the node after use.
339  * off is bit offset from the beginning of the aggregate
340  * fsz is the number of bits this is referring to
341  * XXX - floating point constants may be wrong if cross-compiling.
342  */
ragge
1.14
343 int
ragge
1.2
344 ninval(CONSZ offint fszNODE *p)
345 {
346         union { float fdouble dlong double lint i[3]; } u;
347
ragge
1.16
348         switch (p->n_type) {
ragge
1.2
349         case LDOUBLE:
350                 u.i[2] = 0;
351                 u.l = (long double)p->n_dcon;
352                 printf("\t.long\t0x%x,0x%x,0x%x\n"u.i[0], u.i[1], u.i[2]);
353                 break;
354         case DOUBLE:
355                 u.d = (double)p->n_dcon;
356                 printf("\t.long\t0x%x,0x%x\n"u.i[0], u.i[1]);
357                 break;
358         case FLOAT:
359                 u.f = (float)p->n_dcon;
360                 printf("\t.long\t0x%x\n"u.i[0]);
361                 break;
ragge
1.1
362         default:
ragge
1.14
363                 return 0;
ragge
1.1
364         }
ragge
1.14
365         return 1;
ragge
1.1
366
367 }
ragge
1.6
368 /*
369  * Give target the opportunity of handling pragmas.
370  */
371 int
ragge
1.10
372 mypragma(char *str)
ragge
1.6
373 {
ragge
1.10
374         return 0;
375 }
ragge
1.6
376
377 /*
378  * Called when a identifier has been declared, to give target last word.
379  */
380 void
381 fixdef(struct symtab *sp)
382 {
383 }
384
gmcgarry
1.7
385 void
386 pass1_lastchance(struct interpass *ip)
387 {
388 }
FishEye: Open Source License registered to PCC.
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-12-25 06:06 +0100