Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20121213160125

Diff

Diff from 1.28 to:

Annotations

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

Annotated File View

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