Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20110702151159

Diff

Diff from 1.19 to:

Annotations

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

Annotated File View

ragge
1.19
1 /*      $Id: local.c,v 1.19 2011/07/02 15:11:59 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;
ragge
1.19
61         register int ml;
ragge
1.1
62
ragge
1.18
63
64 #ifdef PCC_DEBUG
65         if (xdebug) {
66                 printf("clocal(%p)\n"p);
67                 if (xdebug>1)
68                         fwalk(peprint0);
69         }
70 #endif
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
ragge
1.18
80                 case REGISTER:
ragge
1.1
81                 case AUTO:
82                 case PARAM:
83                         /* fake up a structure reference */
84                         r = blockREGNILNILPTR+STRTY00 );
ragge
1.2
85                         r->n_lval = 0;
ragge
1.18
86                         r->n_rval = (q->sclass==PARAM?ARGREG:STKREG);
ragge
1.1
87                         p = strefblockSTREFrp000 ) );
88                         break;
ragge
1.18
89                 }
ragge
1.1
90                 break;
91
92         case PCONV:
93                 /* do pointer conversions for char and longs */
ragge
1.2
94                 ml = p->n_left->n_type;
95                 if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->n_left->n_op != ICON ) break;
ragge
1.1
96
97                 /* pointers all have the same representation; the type is inherited */
98
ragge
1.2
99                 p->n_left->n_type = p->n_type;
100                 p->n_left->n_df = p->n_df;
ragge
1.16
101                 p->n_left->n_ap = p->n_ap;
ragge
1.2
102                 r = p->n_left;
103                 nfree(p);
ragge
1.19
104                 p = r;
105                 break;
ragge
1.1
106
107         case RS:
ragge
1.2
108         case RSEQ:
ragge
1.1
109                 /* convert >> to << with negative shift count */
110                 /* only if type of left operand is not unsigned */
ragge
1.2
111                 ifISUNSIGNED(p->n_left->n_type) ) break;
112                 p->n_right = buildtreeUMINUSp->n_rightNIL );
113                 ifp->n_op == RS ) p->n_op = LS;
114                 else p->n_op = LSEQ;
115                 break;
116
117         case FORCE:
118                 p->n_op = ASSIGN;
119                 p->n_right = p->n_left;
ragge
1.11
120                 p->n_left = block(REGNILNILp->n_type00);
ragge
1.2
121                 p->n_left->n_rval = p->n_left->n_type == BOOL ? 
122                     RETREG(CHAR) : RETREG(p->n_type);
ragge
1.1
123                 break;
124
ragge
1.19
125         case SCONV:
126                 if (p->n_type == INT && p->n_left->n_type == UNSIGNED) {
127                         r = p->n_left;
128                         nfree(p);
129                         p = r;
130                 }
131                 break;
132
ragge
1.2
133         case STCALL:
ragge
1.17
134                 /* see if we have been here before */
135                 for (r = p->n_rightr->n_op == CMr = r->n_left)
136                         ;
137                 if (r->n_op == ASSIGN)
138                         break;
139
140                 /* FALLTHROUGH */
141         case USTCALL:
142                 /* Allocate buffer on stack to bounce via */
143                 /* create fake symtab here */
144                 q = getsymtab("77fake"STEMP);
145                 q->stype = BTYPE(p->n_type);
146                 q->sdf = p->n_df;
147                 q->sap = p->n_ap;
148                 q->soffset = NOOFFSET;
149                 q->sclass = AUTO;
150                 oalloc(q, &autooff);
151                 r1arg(pbuildtree(ADDROFnametree(q), 0));
ragge
1.2
152                 break;
153         }
ragge
1.19
154 #ifdef PCC_DEBUG
155         if (xdebug) {
156                 printf("clocal end(%p)\n"p);
157                 if (xdebug>1)
158                         fwalk(peprint0);
159         }
160 #endif
ragge
1.1
161
162         return(p);
ragge
1.2
163 }
ragge
1.1
164
ragge
1.17
165 /*
166  * Add R1 with the dest address as arg to a struct return call.
167  */
168 static void
169 r1arg(NODE *pNODE *q)
170 {
171         NODE *r;
172
173         r = block(REGNILNILPTR|VOID00);
174         regno(r) = R1;
175         r = buildtree(ASSIGNrq);
176         if (p->n_op == USTCALL) {
177                 p->n_op = STCALL;
178                 p->n_right = r;
179         } else if (p->n_right->n_op != CM) {
180                 p->n_right = block(CMrp->n_rightINT00);
181         } else {
182                 for (q = p->n_rightq->n_left->n_op == CMq = q->n_left)
183                         ;
184                 q->n_left = block(CMrq->n_leftINT00);
185         }
186 }
187
gmcgarry
1.4
188 void
189 myp2tree(NODE *p)
190 {
ragge
1.8
191         struct symtab *sp;
ragge
1.5
192
ragge
1.16
193         if (p->n_op != FCON
ragge
1.5
194                 return;
195
ragge
1.8
196         sp = inlalloc(sizeof(struct symtab));
197         sp->sclass = STATIC;
ragge
1.16
198         sp->sap = 0;
ragge
1.8
199         sp->slevel = 1/* fake numeric label */
200         sp->soffset = getlab();
201         sp->sflags = 0;
202         sp->stype = p->n_type;
203         sp->squal = (CON >> TSHIFT);
204
205         defloc(sp);
ragge
1.16
206         inval(0tsize(sp->stypesp->sdfsp->sap), p);
ragge
1.8
207
ragge
1.5
208         p->n_op = NAME;
ragge
1.8
209         p->n_lval = 0;
210         p->n_sp = sp;
ragge
1.5
211
gmcgarry
1.4
212 }
213
ragge
1.3
214 /*
215  * Can we take & of a NAME?
216  */
ragge
1.2
217 int
ragge
1.3
218 andable(NODE *p)
219 {
220
221         if ((p->n_type & ~BTMASK) == FTN)
222                 return 1/* functions are called by name */
223         return 0/* Delay name reference to table, for PIC code generation */
224 }
ragge
1.2
225  
226 int
ragge
1.1
227 cisregt ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
ragge
1.2
228         return(1);      /* all are now */
ragge
1.1
229         }
230
ragge
1.2
231 void
232 spalloc(NODE *tNODE *pOFFSZ off)
233 {
234         cerror("spalloc");
235 }
ragge
1.1
236
237 char *
238 exnamep ) char *p; {
239         /* make a name look like an external name in the local machine */
ragge
1.2
240         /* vad is elf now */
241         if (p == NULL)
242                 return "";
243         returnp );
ragge
1.1
244         }
245
ragge
1.2
246 TWORD
247 ctype(TWORD type ){ /* map types which are not defined on the local machine */
ragge
1.1
248         switchBTYPE(type) ){
249
250         case LONG:
251                 MODTYPE(type,INT);
252                 break;
253
254         case ULONG:
255                 MODTYPE(type,UNSIGNED);
ragge
1.2
256                 break;
257
258         case LDOUBLE:   /* for now */
259                 MODTYPE(type,DOUBLE);
ragge
1.1
260                 }
261         returntype );
262         }
263
ragge
1.2
264 void
265 calldec(NODE *pNODE *q
266 {
267 }
ragge
1.1
268
ragge
1.2
269 void
270 extdec(struct symtab *q)
271 {
272 }
ragge
1.1
273
ragge
1.16
274 /* make a common declaration for id, if reasonable */
ragge
1.2
275 void
ragge
1.16
276 defzero(struct symtab *sp)
ragge
1.2
277 {
ragge
1.16
278         int offal;
279         char *name;
ragge
1.1
280
ragge
1.16
281         if ((name = sp->soname) == NULL)
282                 name = exname(sp->sname);
283         off = tsize(sp->stypesp->sdfsp->sap);
284         SETOFF(off,SZCHAR);
285         off /= SZCHAR;
286         al = talign(sp->stypesp->sap)/SZCHAR;
287
288         if (sp->sclass == STATIC)
289                 printf("\t.local %s\n"name);
290         if (sp->slevel == 0) {
291                 printf("\t.comm %s,0%o,%d\n"nameoffal);
292         } else
293                 printf("\t.comm " LABFMT ",0%o,%d\n"sp->soffsetoffal);
ragge
1.2
294 }
ragge
1.1
295
ragge
1.2
296 /*
297  * print out a constant node, may be associated with a label.
298  * Do not free the node after use.
299  * off is bit offset from the beginning of the aggregate
300  * fsz is the number of bits this is referring to
301  * XXX - floating point constants may be wrong if cross-compiling.
302  */
ragge
1.14
303 int
ragge
1.2
304 ninval(CONSZ offint fszNODE *p)
305 {
306         union { float fdouble dlong double lint i[3]; } u;
307
ragge
1.16
308         switch (p->n_type) {
ragge
1.2
309         case LDOUBLE:
310                 u.i[2] = 0;
311                 u.l = (long double)p->n_dcon;
312                 printf("\t.long\t0x%x,0x%x,0x%x\n"u.i[0], u.i[1], u.i[2]);
313                 break;
314         case DOUBLE:
315                 u.d = (double)p->n_dcon;
316                 printf("\t.long\t0x%x,0x%x\n"u.i[0], u.i[1]);
317                 break;
318         case FLOAT:
319                 u.f = (float)p->n_dcon;
320                 printf("\t.long\t0x%x\n"u.i[0]);
321                 break;
ragge
1.1
322         default:
ragge
1.14
323                 return 0;
ragge
1.1
324         }
ragge
1.14
325         return 1;
ragge
1.1
326
327 }
ragge
1.6
328 /*
329  * Give target the opportunity of handling pragmas.
330  */
331 int
ragge
1.10
332 mypragma(char *str)
ragge
1.6
333 {
ragge
1.10
334         return 0;
335 }
ragge
1.6
336
337 /*
338  * Called when a identifier has been declared, to give target last word.
339  */
340 void
341 fixdef(struct symtab *sp)
342 {
343 }
344
gmcgarry
1.7
345 void
346 pass1_lastchance(struct interpass *ip)
347 {
348 }
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-21 11:45 +0100