Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030806200848

Diff

Diff from 1.2 to:

Annotations

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

Annotated File View

ragge
1.2
1 /*      $Id: local.c,v 1.2 2003/08/06 20:08:48 ragge Exp $      */
ragge
1.1
2 /*
3  * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29
30 # include "pass1.h"
31
32 /*      this file contains code which is dependent on the target machine */
33
34 NODE *
35 clocal(NODE *p)
36 {
37         /* this is called to do local transformations on
38            an expression tree preparitory to its being
39            written out in intermediate code.
40         */
41
42         /* the major essential job is rewriting the
43            automatic variables and arguments in terms of
44            REG and OREG nodes */
45         /* conversion ops which are not necessary are also clobbered here */
46         /* in addition, any special features (such as rewriting
47            exclusive or) are easily handled here as well */
48
49         register struct symtab *q;
ragge
1.2
50         register NODE *r, *l;
ragge
1.1
51         register int o;
52         register int mml;
53
54         switcho = p->n_op ){
55
56         case NAME:
57                 if ((q = p->n_sp) == NULL)
58                         return p/* Nothing to care about */
59
60                 switch (q->sclass) {
61
62                 case PARAM:
63                 case AUTO:
64                         /* fake up a structure reference */
65                         r = block(REGNILNILPTR+STRTY00);
66                         r->n_lval = 0;
67                         r->n_rval = FPREG;
68                         p = stref(block(STREFrp000));
69                         break;
70
71                 case STATIC:
72                         if (q->slevel == 0)
73                                 break;
74                         p->n_lval = 0;
75                         p->n_sp = q;
76                         if ((q->sflags & SLABEL) == 0)
77                                 cerror("STATIC");
78                         break;
79
80                 case REGISTER:
81                         p->n_op = REG;
82                         p->n_lval = 0;
83                         p->n_rval = q->soffset;
84                         break;
85
86                         }
87                 break;
88
89         case PCONV:
ragge
1.2
90                 ml = p->n_left->n_type;
ragge
1.1
91                 l = p->n_left;
92                 if ((ml == CHAR || ml == UCHAR || ml == SHORT || ml == USHORT)
93                     && l->n_op != ICON)
94                         break;
95                 l->n_type = p->n_type;
96                 l->n_qual = p->n_qual;
97                 l->n_df = p->n_df;
98                 l->n_sue = p->n_sue;
99                 nfree(p);
100                 p = l;
101                 break;
102
103         case SCONV:
104                 l = p->n_left;
105
106                 if (o == ICON) {
107                         CONSZ val = l->n_lval;
108
109                         switch (m) {
110                         case CHAR:
111                                 l->n_lval = (char)val;
112                                 break;
113                         case UCHAR:
114                                 l->n_lval = val & 0377;
115                                 break;
116                         case USHORT:
117                                 l->n_lval = (short)val;
118                                 break;
119                         case SHORT:
120                                 l->n_lval = val & 0177777;
121                                 break;
122                         case UNSIGNED:
123                                 l->n_lval = val & 0xffffffff;
124                                 break;
125                         case ENUMTY:
126                         case MOETY:
127                         case INT:
128                                 l->n_lval = (int)val;
129                                 break;
130                         case LONGLONG:
131                                 l->n_lval = (long long)val;
132                         case ULONGLONG:
133                                 l->n_lval = val;
134                                 break;
135                         case VOID:
136                                 break;
137                         case DOUBLE:
138                         case FLOAT:
139                                 l->n_op = FCON;
140                                 l->n_dcon = val;
141                                 break;
142                         default:
143                                 cerror("unknown type %d"m);
144                         }
145                         l->n_type = m;
146                         nfree(p);
147                         return l;
148                 }
149                 break;
150
151         case PMCONV:
152         case PVCONV:
153                 ifp->n_right->n_op != ICON ) cerror"bad conversion"0);
154                 nfree(p);
155                 return(buildtree(o==PMCONV?MUL:DIVp->n_leftp->n_right));
156
157         }
158
159         return(p);
160 }
161
162 void
163 myp2tree(NODE *p)
164 {
165 }
166
167 /*ARGSUSED*/
168 int
169 andable(NODE *p)
170 {
171         return(1);  /* all names can have & taken on them */
172 }
173
174 /*
175  * at the end of the arguments of a ftn, set the automatic offset
176  */
177 void
178 cendarg()
179 {
180         autooff = AUTOINIT;
181 }
182
183 /*
184  * is an automatic variable of type t OK for a register variable
185  * Everything is trusted to be in register here.
186  */
187 int
188 cisreg(TWORD t)
189 {
190         return(1);
191 }
192
193 /*
194  * return a node, for structure references, which is suitable for
195  * being added to a pointer of type t, in order to be off bits offset
196  * into a structure
197  * t, d, and s are the type, dimension offset, and sizeoffset
198  * For pdp10, return the type-specific index number which calculation
199  * is based on its size. For example, short a[3] would return 3.
200  * Be careful about only handling first-level pointers, the following
201  * indirections must be fullword.
202  */
203 NODE *
204 offcon(OFFSZ offTWORD tunion dimfun *dstruct suedef *sue)
205 {
206         register NODE *p;
207
208         if (xdebug)
209                 printf("offcon: OFFSZ %lld type %x dim %p siz %d\n",
210                     offtdsue->suesize);
211
212         p = bcon(0);
213         p->n_lval = off/SZCHAR/* Default */
214         return(p);
215 }
216
217 /*
218  * Allocate off bits on the stack.  p is a tree that when evaluated
219  * is the multiply count for off, t is a NAME node where to write
220  * the allocated address.
221  */
222 void
223 spalloc(NODE *tNODE *pOFFSZ off)
224 {
225         NODE *sp;
226
227         if ((off % SZINT) == 0)
228                 p =  buildtree(MULpbcon(off/SZINT));
229         else if ((off % SZSHORT) == 0) {
230                 p = buildtree(MULpbcon(off/SZSHORT));
231                 p = buildtree(PLUSpbcon(1));
232                 p = buildtree(RSpbcon(1));
233         } else if ((off % SZCHAR) == 0) {
234                 p = buildtree(MULpbcon(off/SZCHAR));
235                 p = buildtree(PLUSpbcon(3));
236                 p = buildtree(RSpbcon(2));
237         } else
238                 cerror("roundsp");
239
240         /* save the address of sp */
241         sp = block(REGNILNILPTR+INTt->n_dft->n_sue);
242         sp->n_lval = 0;
243         sp->n_rval = STKREG;
244         t->n_type = sp->n_type;
245         ecomp(buildtree(ASSIGNtsp)); /* Emit! */
246
247         /* add the size to sp */
248         sp = block(REGNILNILp->n_type00);
249         sp->n_lval = 0;
250         sp->n_rval = STKREG;
251         ecomp(buildtree(PLUSEQspp));
252 }
253
254 static int inwd;        /* current bit offsed in word */
255 static CONSZ word;      /* word being built from fields */
256
257 /*
258  * Generate initialization code for assigning a constant c
259  * to a field of width sz
260  * we assume that the proper alignment has been obtained
261  * inoff is updated to have the proper final value
262  * we also assume sz  < SZINT
263  */
264 void
265 incode(NODE *pint sz)
266 {
267         inoff += sz;
268         if ((sz + inwd) > SZINT)
269                 cerror("incode: field > int");
270
271         word |= ((unsigned)(p->n_lval<<(32-sz))) >> (32-sz-inwd);
272
273         inwd += sz;
274         if (inoff % SZINT == 0) {
275                 printf("        .long 0%llo\n"word);
276                 word = inwd = 0;
277         }
278         tfree(p);
279 }
280
281 /* output code to initialize space of size sz to the value d */
282 /* the proper alignment has been obtained */
283 /* inoff is updated to have the proper final value */
284 /* on the target machine, write it out in octal! */
285 void
286 fincode(NODE *pint sz)
287 {
288         double d = p->n_dcon;
289
290         if(!nerrors)
291                 printf("        %s      0%c%.20e\n",
292                     sz == SZDOUBLE ? ".double" : ".float",
293                 sz == SZDOUBLE ? 'd' : 'f'd);
294         inoff += sz;
295 }
296
297 void
298 cinit(NODE *pint sz)
299 {
300         NODE *l;
301
302         /*
303          * as a favor (?) to people who want to write
304          *     int i = 9600/134.5;
305          * we will, under the proper circumstances, do
306          * a coercion here.
307          */
308         switch (p->n_type) {
309         case INT:
310         case UNSIGNED:
311                 l = p->n_left;
312                 if (l->n_op != SCONV || l->n_left->n_op != FCON)
313                         break;
314                 nfree(l);
315                 l = l->n_left;
316                 l->n_lval = (long)(l->n_dcon);
317                 l->n_sp = NULL;
318                 l->n_op = ICON;
319                 l->n_type = INT;
320                 p->n_left = l;
321                 break;
322         }
323         /* arrange for the initialization of p into a space of size sz */
324         /* the proper alignment has been opbtained */
325         /* inoff is updated to have the proper final value */
326         ecodep );
327         inoff += sz;
328 }
329
330 /*
331  * define n bits of zeros in a vfd
332  */
333 void
334 vfdzero(int n)
335 {
336         inoff += n;
337         inwd += n;
338         if (inoff%ALINT ==0) {
339                 printf("        .long 0%llo\n"word);
340                 word = inwd = 0;
341         }
342 }
343
344 /* make a name look like an external name in the local machine */
345 char *
346 exname(char *p)
347 {
348         if (p == NULL)
349                 return "";
350         return p;
351 }
352
353 /*
354  * map types which are not defined on the local machine
355  */
356 int
357 ctype(TWORD type)
358 {
359         switch (BTYPE(type)) {
360         case LONG:
361                 MODTYPE(type,INT);
362                 break;
363
364         case ULONG:
365                 MODTYPE(type,UNSIGNED);
366         }
367         return (type);
368 }
369
370 /* curid is a variable which is defined but
371  * is not initialized (and not a function );
372  * This routine returns the stroage class for an uninitialized declaration
373  */
374 int
375 noinit()
376 {
377         return(EXTERN);
378 }
379
380 /* make a common declaration for id, if reasonable */
381 void
382 commdec(struct symtab *q)
383 {
384         int off;
385
386         off = tsize(q->stypeq->sdfq->ssue);
387         off = (off+(SZINT-1))/SZINT;
388         printf("        .comm %s,0%o\n"exname(q->sname), off);
389 }
390
391 /* make a local common declaration for id, if reasonable */
392 void
393 lcommdec(struct symtab *q)
394 {
395         int off;
396
397         off = tsize(q->stypeq->sdfq->ssue);
398         off = (off+(SZINT-1))/SZINT;
399         if (q->slevel == 0)
400                 printf("        .lcomm %s,0%o\n"exname(q->sname), off);
401         else
402                 printf("        .lcomm " LABFMT ",0%o\n"q->soffsetoff);
403 }
404
405 /*
406  * Debugger code - ignore.
407  */
408 void
409 prcstab(int a)
410 {
411 }
412
413 void
414 pfstab(char *a)
415 {
416 }
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-10-30 20:00 +0100