Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:otto:20071006131854

Diff

Diff from 1.58 to:

Annotations

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

Annotated File View

otto
1.58
1 /*      $Id: local.c,v 1.58 2007/10/06 13:18:54 otto 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
ragge
1.48
30 #include "pass1.h"
ragge
1.1
31
ragge
1.57
32 /*
33  * Check if a constant is too large for a type.
34  */
35 static int
36 toolarge(TWORD tCONSZ con)
37 {
38         U_CONSZ ucon = con;
39
40         switch (t) {
41         case ULONGLONG:
42         case LONGLONG:
43                 break/* cannot be too large */
44 #define SCHK(i) case i: if (con > MAX_##i || con < MIN_##i) return 1; break
45 #define UCHK(i) case i: if (ucon > MAX_##i) return 1; break
46         SCHK(INT);
47         SCHK(SHORT);
otto
1.58
48         case BOOL:
ragge
1.57
49         SCHK(CHAR);
50         UCHK(UNSIGNED);
51         UCHK(USHORT);
52         UCHK(UCHAR);
53         default:
54                 cerror("toolarge");
55         }
56         return 0;
57 }
58
ragge
1.1
59 /*      this file contains code which is dependent on the target machine */
60
ragge
1.48
61 /* clocal() is called to do local transformations on
62  * an expression tree preparitory to its being
63  * written out in intermediate code.
64  *
65  * the major essential job is rewriting the
66  * automatic variables and arguments in terms of
67  * REG and OREG nodes
68  * conversion ops which are not necessary are also clobbered here
69  * in addition, any special features (such as rewriting
70  * exclusive or) are easily handled here as well
71  */
ragge
1.1
72 NODE *
73 clocal(NODE *p)
74 {
75
76         register struct symtab *q;
ragge
1.2
77         register NODE *r, *l;
ragge
1.1
78         register int o;
ragge
1.40
79         register int m;
ragge
1.19
80         TWORD t;
ragge
1.1
81
ragge
1.54
82 #ifdef PCC_DEBUG
83         if (xdebug) {
84                 printf("clocal: %p\n"p);
85                 fwalk(peprint0);
86         }
87 #endif
ragge
1.1
88         switcho = p->n_op ){
89
90         case NAME:
91                 if ((q = p->n_sp) == NULL)
92                         return p/* Nothing to care about */
93
94                 switch (q->sclass) {
95
96                 case PARAM:
97                 case AUTO:
98                         /* fake up a structure reference */
99                         r = block(REGNILNILPTR+STRTY00);
100                         r->n_lval = 0;
101                         r->n_rval = FPREG;
102                         p = stref(block(STREFrp000));
103                         break;
104
105                 case STATIC:
106                         if (q->slevel == 0)
107                                 break;
108                         p->n_lval = 0;
109                         p->n_sp = q;
110                         break;
111
112                 case REGISTER:
113                         p->n_op = REG;
114                         p->n_lval = 0;
115                         p->n_rval = q->soffset;
116                         break;
117
118                         }
119                 break;
120
ragge
1.39
121         case STCALL:
ragge
1.37
122         case CALL:
123                 /* Fix function call arguments. On x86, just add funarg */
124                 for (r = p->n_rightr->n_op == CMr = r->n_left) {
ragge
1.38
125                         if (r->n_right->n_op != STARG &&
126                             r->n_right->n_op != FUNARG)
ragge
1.37
127                                 r->n_right = block(FUNARGr->n_rightNIL
128                                     r->n_right->n_typer->n_right->n_df,
129                                     r->n_right->n_sue);
130                 }
ragge
1.38
131                 if (r->n_op != STARG && r->n_op != FUNARG) {
ragge
1.37
132                         l = talloc();
133                         *l = *r;
134                         r->n_op = FUNARGr->n_left = lr->n_type = l->n_type;
135                 }
ragge
1.10
136                 break;
ragge
1.37
137                 
ragge
1.8
138         case CBRANCH:
139                 l = p->n_left;
140
141                 /*
142                  * Remove unneccessary conversion ops.
143                  */
ragge
1.10
144                 if (clogop(l->n_op) && l->n_left->n_op == SCONV) {
ragge
1.12
145                         if (coptype(l->n_op) != BITYPE)
146                                 break;
ragge
1.8
147                         if (l->n_right->n_op == ICON) {
148                                 r = l->n_left->n_left;
ragge
1.24
149                                 if (r->n_type >= FLOAT && r->n_type <= LDOUBLE)
150                                         break;
ragge
1.57
151                                 if (toolarge(r->n_typel->n_right->n_lval))
152                                         break;
ragge
1.18
153                                 /* Type must be correct */
ragge
1.19
154                                 t = r->n_type;
ragge
1.8
155                                 nfree(l->n_left);
156                                 l->n_left = r;
ragge
1.19
157                                 l->n_type = t;
158                                 l->n_right->n_type = t;
ragge
1.17
159                         }
ragge
1.8
160                 }
161                 break;
162
ragge
1.1
163         case PCONV:
ragge
1.40
164                 /* Remove redundant PCONV's. Be careful */
ragge
1.1
165                 l = p->n_left;
ragge
1.40
166                 if (l->n_op == ICON) {
167                         l->n_lval = (unsigned)l->n_lval;
168                         goto delp;
169                 }
170                 if (l->n_type < INT || l->n_type == LONGLONG || 
171                     l->n_type == ULONGLONG) {
172                         /* float etc? */
173                         p->n_left = block(SCONVlNIL,
174                             UNSIGNED0MKSUE(UNSIGNED));
175                         break;
176                 }
177                 /* if left is SCONV, cannot remove */
178                 if (l->n_op == SCONV)
ragge
1.1
179                         break;
ragge
1.54
180
181                 /* avoid ADDROF TEMP */
182                 if (l->n_op == ADDROF && l->n_left->n_op == TEMP)
183                         break;
184
ragge
1.40
185                 /* if conversion to another pointer type, just remove */
186                 if (p->n_type > BTMASK && l->n_type > BTMASK)
187                         goto delp;
188                 break;
189
190         delp:   l->n_type = p->n_type;
ragge
1.1
191                 l->n_qual = p->n_qual;
192                 l->n_df = p->n_df;
193                 l->n_sue = p->n_sue;
194                 nfree(p);
195                 p = l;
196                 break;
ragge
1.40
197                 
ragge
1.1
198         case SCONV:
199                 l = p->n_left;
ragge
1.4
200
ragge
1.25
201                 if (p->n_type == l->n_type) {
202                         nfree(p);
203                         return l;
204                 }
205
ragge
1.4
206                 if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
pj
1.30
207                     btdims[p->n_type].suesize == btdims[l->n_type].suesize) {
ragge
1.4
208                         if (p->n_type != FLOAT && p->n_type != DOUBLE &&
ragge
1.15
209                             l->n_type != FLOAT && l->n_type != DOUBLE &&
210                             l->n_type != LDOUBLE && p->n_type != LDOUBLE) {
ragge
1.41
211                                 if (l->n_op == NAME || l->n_op == UMUL ||
212                                     l->n_op == TEMP) {
ragge
1.15
213                                         l->n_type = p->n_type;
214                                         nfree(p);
215                                         return l;
216                                 }
ragge
1.4
217                         }
ragge
1.6
218                 }
219
ragge
1.42
220                 if (DEUNSIGN(p->n_type) == INT && DEUNSIGN(l->n_type) == INT &&
221                     coptype(l->n_op) == BITYPE) {
222                         l->n_type = p->n_type;
223                         nfree(p);
224                         return l;
225                 }
226
ragge
1.3
227                 o = l->n_op;
ragge
1.4
228                 m = p->n_type;
ragge
1.1
229
230                 if (o == ICON) {
231                         CONSZ val = l->n_lval;
232
ragge
1.29
233                         if (!ISPTR(m)) /* Pointers don't need to be conv'd */
234                             switch (m) {
ragge
1.52
235                         case BOOL:
236                                 l->n_lval = l->n_lval != 0;
237                                 break;
ragge
1.1
238                         case CHAR:
239                                 l->n_lval = (char)val;
240                                 break;
241                         case UCHAR:
242                                 l->n_lval = val & 0377;
243                                 break;
ragge
1.15
244                         case SHORT:
ragge
1.1
245                                 l->n_lval = (short)val;
246                                 break;
ragge
1.15
247                         case USHORT:
ragge
1.1
248                                 l->n_lval = val & 0177777;
249                                 break;
ragge
1.15
250                         case ULONG:
ragge
1.1
251                         case UNSIGNED:
252                                 l->n_lval = val & 0xffffffff;
253                                 break;
254                         case ENUMTY:
255                         case MOETY:
ragge
1.15
256                         case LONG:
ragge
1.1
257                         case INT:
258                                 l->n_lval = (int)val;
259                                 break;
260                         case LONGLONG:
261                                 l->n_lval = (long long)val;
ragge
1.15
262                                 break;
ragge
1.1
263                         case ULONGLONG:
264                                 l->n_lval = val;
265                                 break;
266                         case VOID:
267                                 break;
ragge
1.14
268                         case LDOUBLE:
ragge
1.1
269                         case DOUBLE:
270                         case FLOAT:
271                                 l->n_op = FCON;
272                                 l->n_dcon = val;
273                                 break;
274                         default:
275                                 cerror("unknown type %d"m);
276                         }
277                         l->n_type = m;
ragge
1.44
278                         l->n_sue = MKSUE(m);
ragge
1.1
279                         nfree(p);
280                         return l;
281                 }
ragge
1.17
282                 if (DEUNSIGN(p->n_type) == SHORT &&
283                     DEUNSIGN(l->n_type) == SHORT) {
284                         nfree(p);
285                         p = l;
286                 }
ragge
1.36
287                 if ((p->n_type == CHAR || p->n_type == UCHAR ||
288                     p->n_type == SHORT || p->n_type == USHORT) &&
289                     (l->n_type == FLOAT || l->n_type == DOUBLE ||
290                     l->n_type == LDOUBLE)) {
291                         p = block(SCONVpNILp->n_typep->n_dfp->n_sue);
292                         p->n_left->n_type = INT;
293                         return p;
294                 }
ragge
1.1
295                 break;
296
ragge
1.15
297         case MOD:
298         case DIV:
299                 if (o == DIV && p->n_type != CHAR && p->n_type != SHORT)
300                         break;
ragge
1.16
301                 if (o == MOD && p->n_type != CHAR && p->n_type != SHORT)
ragge
1.15
302                         break;
303                 /* make it an int division by inserting conversions */
304                 p->n_left = block(SCONVp->n_leftNILINT0MKSUE(INT));
305                 p->n_right = block(SCONVp->n_rightNILINT0MKSUE(INT));
306                 p = block(SCONVpNILp->n_type0MKSUE(p->n_type));
307                 p->n_left->n_type = INT;
308                 break;
309
ragge
1.1
310         case PMCONV:
311         case PVCONV:
312                 ifp->n_right->n_op != ICON ) cerror"bad conversion"0);
313                 nfree(p);
314                 return(buildtree(o==PMCONV?MUL:DIVp->n_leftp->n_right));
315
ragge
1.31
316         case FORCE:
ragge
1.32
317                 /* put return value in return reg */
318                 p->n_op = ASSIGN;
319                 p->n_right = p->n_left;
320                 p->n_left = block(REGNILNILp->n_type0MKSUE(INT));
ragge
1.53
321                 p->n_left->n_rval = p->n_left->n_type == BOOL ? 
322                     RETREG(CHAR) : RETREG(p->n_type);
ragge
1.31
323                 break;
ragge
1.39
324
325         case LS:
326         case RS:
327                 /* shift count must be in a char
328                  * unless longlong, where it must be int */
329                 if (p->n_right->n_op == ICON)
330                         break/* do not do anything */
331                 if (p->n_type == LONGLONG || p->n_type == ULONGLONG) {
332                         if (p->n_right->n_type != INT)
333                                 p->n_right = block(SCONVp->n_rightNIL,
334                                     INT0MKSUE(INT));
335                         break;
336                 }
337                 if (p->n_right->n_type == CHAR || p->n_right->n_type == UCHAR)
338                         break;
339                 p->n_right = block(SCONVp->n_rightNIL,
340                     CHAR0MKSUE(CHAR));
341                 break;
ragge
1.1
342         }
ragge
1.54
343 #ifdef PCC_DEBUG
344         if (xdebug) {
345                 printf("clocal end: %p\n"p);
346                 fwalk(peprint0);
347         }
348 #endif
ragge
1.1
349         return(p);
350 }
351
352 void
353 myp2tree(NODE *p)
354 {
355 }
356
357 /*ARGSUSED*/
358 int
359 andable(NODE *p)
360 {
361         return(1);  /* all names can have & taken on them */
362 }
363
364 /*
365  * at the end of the arguments of a ftn, set the automatic offset
366  */
367 void
368 cendarg()
369 {
370         autooff = AUTOINIT;
371 }
372
373 /*
ragge
1.36
374  * Return 1 if a variable of type type is OK to put in register.
375  */
376 int
377 cisreg(TWORD t)
378 {
379         if (t == FLOAT || t == DOUBLE || t == LDOUBLE)
380                 return 0/* not yet */
381         return 1;
382 }
383
384 /*
ragge
1.1
385  * return a node, for structure references, which is suitable for
386  * being added to a pointer of type t, in order to be off bits offset
387  * into a structure
388  * t, d, and s are the type, dimension offset, and sizeoffset
389  * For pdp10, return the type-specific index number which calculation
390  * is based on its size. For example, short a[3] would return 3.
391  * Be careful about only handling first-level pointers, the following
392  * indirections must be fullword.
393  */
394 NODE *
395 offcon(OFFSZ offTWORD tunion dimfun *dstruct suedef *sue)
396 {
397         register NODE *p;
398
399         if (xdebug)
400                 printf("offcon: OFFSZ %lld type %x dim %p siz %d\n",
401                     offtdsue->suesize);
402
403         p = bcon(0);
404         p->n_lval = off/SZCHAR/* Default */
405         return(p);
406 }
407
408 /*
409  * Allocate off bits on the stack.  p is a tree that when evaluated
ragge
1.45
410  * is the multiply count for off, t is a storeable node where to write
ragge
1.1
411  * the allocated address.
412  */
413 void
414 spalloc(NODE *tNODE *pOFFSZ off)
415 {
416         NODE *sp;
417
ragge
1.45
418         p = buildtree(MULpbcon(off/SZCHAR)); /* XXX word alignment? */
419
420         /* sub the size from sp */
ragge
1.55
421         sp = block(REGNILNILp->n_type0MKSUE(INT));
ragge
1.45
422         sp->n_lval = 0;
423         sp->n_rval = STKREG;
424         ecomp(buildtree(MINUSEQspp));
ragge
1.1
425
426         /* save the address of sp */
427         sp = block(REGNILNILPTR+INTt->n_dft->n_sue);
428         sp->n_lval = 0;
429         sp->n_rval = STKREG;
430         t->n_type = sp->n_type;
431         ecomp(buildtree(ASSIGNtsp)); /* Emit! */
432
433 }
434
ragge
1.49
435 #if 0
ragge
1.48
436 /*
437  * Print out an integer constant of size size.
438  * can only be sizes <= SZINT.
439  */
ragge
1.47
440 void
441 indata(CONSZ valint size)
442 {
443         switch (size) {
444         case SZCHAR:
445                 printf("\t.byte %d\n", (int)val & 0xff);
446                 break;
447         case SZSHORT:
448                 printf("\t.word %d\n", (int)val & 0xffff);
449                 break;
450         case SZINT:
451                 printf("\t.long %d\n", (int)val & 0xffffffff);
452                 break;
453         default:
454                 cerror("indata");
455         }
456 }
ragge
1.49
457 #endif
ragge
1.47
458
ragge
1.1
459 /*
ragge
1.48
460  * Print out a string of characters.
461  * Assume that the assembler understands C-style escape
462  * sequences.  Location is already set.
463  */
464 void
465 instring(char *str)
466 {
467         char *s;
468
469         /* be kind to assemblers and avoid long strings */
470         printf("\t.ascii \"");
ragge
1.51
471         for (s = str; *s != 0; ) {
472                 if (*s++ == '\\') {
ragge
1.48
473                         (void)esccon(&s);
ragge
1.51
474                 }
ragge
1.48
475                 if (s - str > 64) {
476                         fwrite(str1s - strstdout);
477                         printf("\"\n\t.ascii \"");
478                         str = s;
479                 }
480         }
481         fwrite(str1s - strstdout);
482         printf("\\0\"\n");
483 }
484
ragge
1.49
485 static int inbitsinval;
486
487 /*
488  * set fsz bits in sequence to zero.
489  */
490 void
491 zbits(OFFSZ offint fsz)
492 {
493         int m;
494
495         if (idebug)
ragge
1.51
496                 printf("zbits off %lld, fsz %d inbits %d\n"offfszinbits);
ragge
1.49
497         if ((m = (inbits % SZCHAR))) {
498                 m = SZCHAR - m;
499                 if (fsz < m) {
ragge
1.51
500                         inbits += fsz;
ragge
1.49
501                         return;
502                 } else {
503                         fsz -= m;
504                         printf("\t.byte %d\n"inval);
505                         inval = inbits = 0;
506                 }
507         }
508         if (fsz >= SZCHAR) {
509                 printf("\t.zero %d\n"fsz/SZCHAR);
ragge
1.51
510                 fsz -= (fsz/SZCHAR) * SZCHAR;
ragge
1.49
511         }
512         if (fsz) {
513                 inval = 0;
514                 inbits = fsz;
515         }
516 }
517
518 /*
519  * Initialize a bitfield.
520  */
521 void
522 infld(CONSZ offint fszCONSZ val)
523 {
524         if (idebug)
ragge
1.51
525                 printf("infld off %lld, fsz %d, val %lld inbits %d\n",
526                     offfszvalinbits);
ragge
1.56
527         val &= ((CONSZ)1 << fsz)-1;
ragge
1.49
528         while (fsz + inbits >= SZCHAR) {
529                 inval |= (val << inbits);
530                 printf("\t.byte %d\n"inval & 255);
531                 fsz -= (SZCHAR - inbits);
532                 val >>= (SZCHAR - inbits);
533                 inval = inbits = 0;
534         }
ragge
1.51
535         if (fsz) {
536                 inval |= (val << inbits);
537                 inbits += fsz;
538         }
ragge
1.49
539 }
540
ragge
1.48
541 /*
ragge
1.46
542  * print out a constant node, may be associated with a label.
543  * Do not free the node after use.
ragge
1.49
544  * off is bit offset from the beginning of the aggregate
545  * fsz is the number of bits this is referring to
ragge
1.21
546  */
547 void
ragge
1.49
548 ninval(CONSZ offint fszNODE *p)
ragge
1.21
549 {
ragge
1.46
550         union { float fdouble dlong double lint i[3]; } u;
ragge
1.24
551         struct symtab *q;
ragge
1.23
552         TWORD t;
ragge
1.46
553         int i;
ragge
1.23
554
555         t = p->n_type;
556         if (t > BTMASK)
557                 t = INT/* pointer */
558
ragge
1.46
559         if (p->n_op != ICON && p->n_op != FCON)
ragge
1.40
560                 cerror("ninval: init node not constant");
561
ragge
1.49
562         if (p->n_op == ICON && p->n_sp != NULL && DEUNSIGN(t) != INT)
ragge
1.46
563                 uerror("element not constant");
564
ragge
1.23
565         switch (t) {
ragge
1.21
566         case LONGLONG:
567         case ULONGLONG:
ragge
1.46
568                 i = (p->n_lval >> 32);
569                 p->n_lval &= 0xffffffff;
ragge
1.51
570                 p->n_type = INT;
ragge
1.49
571                 ninval(off32p);
ragge
1.46
572                 p->n_lval = i;
ragge
1.49
573                 ninval(off+3232p);
ragge
1.21
574                 break;
575         case INT:
576         case UNSIGNED:
577                 printf("\t.long 0x%x", (int)p->n_lval);
ragge
1.24
578                 if ((q = p->n_sp) != NULL) {
579                         if ((q->sclass == STATIC && q->slevel > 0) ||
580                             q->sclass == ILABEL) {
581                                 printf("+" LABFMTq->soffset);
ragge
1.21
582                         } else
ragge
1.24
583                                 printf("+%s"exname(q->sname));
ragge
1.21
584                 }
585                 printf("\n");
586                 break;
ragge
1.46
587         case SHORT:
588         case USHORT:
589                 printf("\t.short 0x%x\n", (int)p->n_lval & 0xffff);
590                 break;
ragge
1.52
591         case BOOL:
592                 if (p->n_lval > 1)
593                         p->n_lval = p->n_lval != 0;
594                 /* FALLTHROUGH */
ragge
1.46
595         case CHAR:
596         case UCHAR:
ragge
1.50
597                 printf("\t.byte %d\n", (int)p->n_lval & 0xff);
ragge
1.46
598                 break;
599         case LDOUBLE:
600                 u.i[2] = 0;
601                 u.l = (long double)p->n_dcon;
602                 printf("\t.long\t0x%x,0x%x,0x%x\n"u.i[0], u.i[1], u.i[2]);
603                 break;
604         case DOUBLE:
605                 u.d = (double)p->n_dcon;
606                 printf("\t.long\t0x%x,0x%x\n"u.i[0], u.i[1]);
607                 break;
608         case FLOAT:
609                 u.f = (float)p->n_dcon;
610                 printf("\t.long\t0x%x\n"u.i[0]);
611                 break;
ragge
1.21
612         default:
613                 cerror("ninval");
614         }
615 }
616
ragge
1.46
617 #if 0
ragge
1.21
618 /*
ragge
1.17
619  * print out an integer.
ragge
1.1
620  */
621 void
ragge
1.17
622 inval(CONSZ word)
ragge
1.1
623 {
ragge
1.17
624         word &= 0xffffffff;
625         printf("        .long 0x%llx\n"word);
ragge
1.1
626 }
627
ragge
1.17
628 /* output code to initialize a floating point value */
ragge
1.1
629 /* the proper alignment has been obtained */
630 void
ragge
1.17
631 finval(NODE *p)
ragge
1.1
632 {
ragge
1.43
633         union { float fdouble dlong double lint i[3]; } u;
634
ragge
1.17
635         switch (p->n_type) {
636         case LDOUBLE:
ragge
1.43
637                 u.i[2] = 0;
638                 u.l = (long double)p->n_dcon;
639                 printf("\t.long\t0x%x,0x%x,0x%x\n"u.i[0], u.i[1], u.i[2]);
ragge
1.14
640                 break;
ragge
1.17
641         case DOUBLE:
ragge
1.43
642                 u.d = (double)p->n_dcon;
643                 printf("\t.long\t0x%x,0x%x\n"u.i[0], u.i[1]);
ragge
1.14
644                 break;
ragge
1.17
645         case FLOAT:
ragge
1.43
646                 u.f = (float)p->n_dcon;
647                 printf("\t.long\t0x%x\n"u.i[0]);
ragge
1.14
648                 break;
649         }
ragge
1.1
650 }
ragge
1.46
651 #endif
ragge
1.1
652
653 /* make a name look like an external name in the local machine */
654 char *
655 exname(char *p)
656 {
657         if (p == NULL)
658                 return "";
659         return p;
660 }
661
662 /*
663  * map types which are not defined on the local machine
664  */
ragge
1.15
665 TWORD
ragge
1.1
666 ctype(TWORD type)
667 {
668         switch (BTYPE(type)) {
669         case LONG:
670                 MODTYPE(type,INT);
671                 break;
672
673         case ULONG:
674                 MODTYPE(type,UNSIGNED);
ragge
1.13
675
ragge
1.1
676         }
677         return (type);
678 }
679
pj
1.30
680 void
681 calldec(NODE *pNODE *q
682 {
683 }
684
685 void
686 extdec(struct symtab *q)
687 {
688 }
689
ragge
1.1
690 /* make a common declaration for id, if reasonable */
691 void
692 commdec(struct symtab *q)
693 {
694         int off;
695
696         off = tsize(q->stypeq->sdfq->ssue);
ragge
1.8
697         off = (off+(SZCHAR-1))/SZCHAR;
ragge
1.7
698 #ifdef GCC_COMPAT
699         printf("        .comm %s,0%o\n"gcc_findname(q), off);
700 #else
ragge
1.1
701         printf("        .comm %s,0%o\n"exname(q->sname), off);
ragge
1.7
702 #endif
ragge
1.1
703 }
704
705 /* make a local common declaration for id, if reasonable */
706 void
707 lcommdec(struct symtab *q)
708 {
709         int off;
710
711         off = tsize(q->stypeq->sdfq->ssue);
ragge
1.8
712         off = (off+(SZCHAR-1))/SZCHAR;
ragge
1.1
713         if (q->slevel == 0)
ragge
1.7
714 #ifdef GCC_COMPAT
715                 printf("        .lcomm %s,0%o\n"gcc_findname(q), off);
716 #else
ragge
1.1
717                 printf("        .lcomm %s,0%o\n"exname(q->sname), off);
ragge
1.7
718 #endif
ragge
1.1
719         else
720                 printf("        .lcomm " LABFMT ",0%o\n"q->soffsetoff);
721 }
ragge
1.22
722
723 /*
724  * print a (non-prog) label.
725  */
726 void
727 deflab1(int label)
728 {
729         printf(LABFMT ":\n"label);
730 }
731
ragge
1.28
732 static char *loctbl[] = { "text""data""section .rodata""section .rodata" };
ragge
1.27
733
ragge
1.23
734 void
735 setloc1(int locc)
736 {
737         if (locc == lastloc)
738                 return;
739         lastloc = locc;
ragge
1.27
740         printf("        .%s\n"loctbl[locc]);
ragge
1.23
741 }
ragge
1.48
742
ragge
1.49
743 #if 0
ragge
1.48
744 int
745 ftoint(NODE *pCONSZ **c)
746 {
747         static CONSZ cc[3];
748         union { float fdouble dlong double lint i[3]; } u;
749         int n;
750
751         switch (p->n_type) {
752         case LDOUBLE:
753                 u.i[2] = 0;
754                 u.l = (long double)p->n_dcon;
755                 n = SZLDOUBLE;
756                 break;
757         case DOUBLE:
758                 u.d = (double)p->n_dcon;
759                 n = SZDOUBLE;
760                 break;
761         case FLOAT:
762                 u.f = (float)p->n_dcon;
763                 n = SZFLOAT;
764                 break;
765         }
766         cc[0] = u.i[0];
767         cc[1] = u.i[1];
768         cc[2] = u.i[2];
769         *c = cc;
770         return n;
771 }
ragge
1.49
772 #endif
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-09-18 21:47 +0200