Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030807104255

Diff

Diff from 1.4 to:

Annotations

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

Annotated File View

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