Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20151113113846

Diff

Diff from 1.31 to:

Annotations

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

Annotated File View

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