Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030806170932

Diff

Diff from 1.1 to:

Annotations

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

Annotated File View

ragge
1.1
1 /*      $Id: local.c,v 1.1 2003/08/06 17:09:32 ragge Exp $      */
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;
50         register NODE *r, *l, *oop;
51         register int o;
52         register int mml;
53         int siz;
54
55         switcho = p->n_op ){
56
57         case NAME:
58                 if ((q = p->n_sp) == NULL)
59                         return p/* Nothing to care about */
60
61                 switch (q->sclass) {
62
63                 case PARAM:
64                 case AUTO:
65                         /* fake up a structure reference */
66                         r = block(REGNILNILPTR+STRTY00);
67                         r->n_lval = 0;
68                         r->n_rval = FPREG;
69                         p = stref(block(STREFrp000));
70                         break;
71
72                 case STATIC:
73                         if (q->slevel == 0)
74                                 break;
75                         p->n_lval = 0;
76                         p->n_sp = q;
77                         if ((q->sflags & SLABEL) == 0)
78                                 cerror("STATIC");
79                         break;
80
81                 case REGISTER:
82                         p->n_op = REG;
83                         p->n_lval = 0;
84                         p->n_rval = q->soffset;
85                         break;
86
87                         }
88                 break;
89
90         case PCONV:
91                 ml = p->in.left->in.type;
92                 l = p->n_left;
93                 if ((ml == CHAR || ml == UCHAR || ml == SHORT || ml == USHORT)
94                     && l->n_op != ICON)
95                         break;
96                 l->n_type = p->n_type;
97                 l->n_qual = p->n_qual;
98                 l->n_df = p->n_df;
99                 l->n_sue = p->n_sue;
100                 nfree(p);
101                 p = l;
102                 break;
103
104         case SCONV:
105                 l = p->n_left;
106
107                 if (o == ICON) {
108                         CONSZ val = l->n_lval;
109
110                         switch (m) {
111                         case CHAR:
112                                 l->n_lval = (char)val;
113                                 break;
114                         case UCHAR:
115                                 l->n_lval = val & 0377;
116                                 break;
117                         case USHORT:
118                                 l->n_lval = (short)val;
119                                 break;
120                         case SHORT:
121                                 l->n_lval = val & 0177777;
122                                 break;
123                         case UNSIGNED:
124                                 l->n_lval = val & 0xffffffff;
125                                 break;
126                         case ENUMTY:
127                         case MOETY:
128                         case INT:
129                                 l->n_lval = (int)val;
130                                 break;
131                         case LONGLONG:
132                                 l->n_lval = (long long)val;
133                         case ULONGLONG:
134                                 l->n_lval = val;
135                                 break;
136                         case VOID:
137                                 break;
138                         case DOUBLE:
139                         case FLOAT:
140                                 l->n_op = FCON;
141                                 l->n_dcon = val;
142                                 break;
143                         default:
144                                 cerror("unknown type %d"m);
145                         }
146                         l->n_type = m;
147                         nfree(p);
148                         return l;
149                 }
150                 break;
151
152         case PMCONV:
153         case PVCONV:
154                 ifp->n_right->n_op != ICON ) cerror"bad conversion"0);
155                 nfree(p);
156                 return(buildtree(o==PMCONV?MUL:DIVp->n_leftp->n_right));
157
158         }
159
160         return(p);
161 }
162
163 void
164 myp2tree(NODE *p)
165 {
166 }
167
168 /*ARGSUSED*/
169 int
170 andable(NODE *p)
171 {
172         return(1);  /* all names can have & taken on them */
173 }
174
175 /*
176  * at the end of the arguments of a ftn, set the automatic offset
177  */
178 void
179 cendarg()
180 {
181         autooff = AUTOINIT;
182 }
183
184 /*
185  * is an automatic variable of type t OK for a register variable
186  * Everything is trusted to be in register here.
187  */
188 int
189 cisreg(TWORD t)
190 {
191         return(1);
192 }
193
194 /*
195  * return a node, for structure references, which is suitable for
196  * being added to a pointer of type t, in order to be off bits offset
197  * into a structure
198  * t, d, and s are the type, dimension offset, and sizeoffset
199  * For pdp10, return the type-specific index number which calculation
200  * is based on its size. For example, short a[3] would return 3.
201  * Be careful about only handling first-level pointers, the following
202  * indirections must be fullword.
203  */
204 NODE *
205 offcon(OFFSZ offTWORD tunion dimfun *dstruct suedef *sue)
206 {
207         register NODE *p;
208
209         if (xdebug)
210                 printf("offcon: OFFSZ %lld type %x dim %p siz %d\n",
211                     offtdsue->suesize);
212
213         p = bcon(0);
214         p->n_lval = off/SZCHAR/* Default */
215         return(p);
216 }
217
218 /*
219  * Allocate off bits on the stack.  p is a tree that when evaluated
220  * is the multiply count for off, t is a NAME node where to write
221  * the allocated address.
222  */
223 void
224 spalloc(NODE *tNODE *pOFFSZ off)
225 {
226         NODE *sp;
227
228         if ((off % SZINT) == 0)
229                 p =  buildtree(MULpbcon(off/SZINT));
230         else if ((off % SZSHORT) == 0) {
231                 p = buildtree(MULpbcon(off/SZSHORT));
232                 p = buildtree(PLUSpbcon(1));
233                 p = buildtree(RSpbcon(1));
234         } else if ((off % SZCHAR) == 0) {
235                 p = buildtree(MULpbcon(off/SZCHAR));
236                 p = buildtree(PLUSpbcon(3));
237                 p = buildtree(RSpbcon(2));
238         } else
239                 cerror("roundsp");
240
241         /* save the address of sp */
242         sp = block(REGNILNILPTR+INTt->n_dft->n_sue);
243         sp->n_lval = 0;
244         sp->n_rval = STKREG;
245         t->n_type = sp->n_type;
246         ecomp(buildtree(ASSIGNtsp)); /* Emit! */
247
248         /* add the size to sp */
249         sp = block(REGNILNILp->n_type00);
250         sp->n_lval = 0;
251         sp->n_rval = STKREG;
252         ecomp(buildtree(PLUSEQspp));
253 }
254
255 static int inwd;        /* current bit offsed in word */
256 static CONSZ word;      /* word being built from fields */
257
258 /*
259  * Generate initialization code for assigning a constant c
260  * to a field of width sz
261  * we assume that the proper alignment has been obtained
262  * inoff is updated to have the proper final value
263  * we also assume sz  < SZINT
264  */
265 void
266 incode(NODE *pint sz)
267 {
268         inoff += sz;
269         if ((sz + inwd) > SZINT)
270                 cerror("incode: field > int");
271
272         word |= ((unsigned)(p->n_lval<<(32-sz))) >> (32-sz-inwd);
273
274         inwd += sz;
275         if (inoff % SZINT == 0) {
276                 printf("        .long 0%llo\n"word);
277                 word = inwd = 0;
278         }
279         tfree(p);
280 }
281
282 /* output code to initialize space of size sz to the value d */
283 /* the proper alignment has been obtained */
284 /* inoff is updated to have the proper final value */
285 /* on the target machine, write it out in octal! */
286 void
287 fincode(NODE *pint sz)
288 {
289         double d = p->n_dcon;
290
291         if(!nerrors)
292                 printf("        %s      0%c%.20e\n",
293                     sz == SZDOUBLE ? ".double" : ".float",
294                 sz == SZDOUBLE ? 'd' : 'f'd);
295         inoff += sz;
296 }
297
298 void
299 cinit(NODE *pint sz)
300 {
301         NODE *l;
302
303         /*
304          * as a favor (?) to people who want to write
305          *     int i = 9600/134.5;
306          * we will, under the proper circumstances, do
307          * a coercion here.
308          */
309         switch (p->n_type) {
310         case INT:
311         case UNSIGNED:
312                 l = p->n_left;
313                 if (l->n_op != SCONV || l->n_left->n_op != FCON)
314                         break;
315                 nfree(l);
316                 l = l->n_left;
317                 l->n_lval = (long)(l->n_dcon);
318                 l->n_sp = NULL;
319                 l->n_op = ICON;
320                 l->n_type = INT;
321                 p->n_left = l;
322                 break;
323         }
324         /* arrange for the initialization of p into a space of size sz */
325         /* the proper alignment has been opbtained */
326         /* inoff is updated to have the proper final value */
327         ecodep );
328         inoff += sz;
329 }
330
331 /*
332  * define n bits of zeros in a vfd
333  */
334 void
335 vfdzero(int n)
336 {
337         inoff += n;
338         inwd += n;
339         if (inoff%ALINT ==0) {
340                 printf("        .long 0%llo\n"word);
341                 word = inwd = 0;
342         }
343 }
344
345 /* make a name look like an external name in the local machine */
346 char *
347 exname(char *p)
348 {
349         if (p == NULL)
350                 return "";
351         return p;
352 }
353
354 /*
355  * map types which are not defined on the local machine
356  */
357 int
358 ctype(TWORD type)
359 {
360         switch (BTYPE(type)) {
361         case LONG:
362                 MODTYPE(type,INT);
363                 break;
364
365         case ULONG:
366                 MODTYPE(type,UNSIGNED);
367         }
368         return (type);
369 }
370
371 /* curid is a variable which is defined but
372  * is not initialized (and not a function );
373  * This routine returns the stroage class for an uninitialized declaration
374  */
375 int
376 noinit()
377 {
378         return(EXTERN);
379 }
380
381 /* make a common declaration for id, if reasonable */
382 void
383 commdec(struct symtab *q)
384 {
385         int off;
386
387         off = tsize(q->stypeq->sdfq->ssue);
388         off = (off+(SZINT-1))/SZINT;
389         printf("        .comm %s,0%o\n"exname(q->sname), off);
390 }
391
392 /* make a local common declaration for id, if reasonable */
393 void
394 lcommdec(struct symtab *q)
395 {
396         int off;
397
398         off = tsize(q->stypeq->sdfq->ssue);
399         off = (off+(SZINT-1))/SZINT;
400         if (q->slevel == 0)
401                 printf("        .lcomm %s,0%o\n"exname(q->sname), off);
402         else
403                 printf("        .lcomm " LABFMT ",0%o\n"q->soffsetoff);
404 }
405
406 /*
407  * Debugger code - ignore.
408  */
409 void
410 prcstab(int a)
411 {
412 }
413
414 void
415 pfstab(char *a)
416 {
417 }
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-08-23 13:27 +0200