Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:plunky:20140529192002

Diff

Diff from 1.78 to:

Annotations

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

Annotated File View

plunky
1.78
1 /*      $Id: local.c,v 1.78 2014/05/29 19:20:03 plunky Exp $    */
ragge
1.48
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  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
ragge
1.1
27
28 # include "pass1.h"
29
30 /*      this file contains code which is dependent on the target machine */
31
ragge
1.14
32 static int pointp(TWORD t);
ragge
1.28
33 static struct symtab *newfun(char *nameTWORD type);
ragge
1.14
34
ragge
1.21
35 #define PTRNORMAL       1
36 #define PTRCHAR         2
37 #define PTRSHORT        3
ragge
1.63
38 static int xptype(TWORD t);
ragge
1.14
39
ragge
1.1
40 NODE *
41 clocal(NODE *p)
42 {
43         /* this is called to do local transformations on
44            an expression tree preparitory to its being
45            written out in intermediate code.
46         */
47
48         /* the major essential job is rewriting the
49            automatic variables and arguments in terms of
50            REG and OREG nodes */
51         /* conversion ops which are not necessary are also clobbered here */
52         /* in addition, any special features (such as rewriting
53            exclusive or) are easily handled here as well */
54
55         register struct symtab *q;
ragge
1.19
56         register NODE *r, *l, *oop;
ragge
1.1
57         register int o;
ragge
1.18
58         register int mml;
ragge
1.28
59         int siz;
ragge
1.1
60
ragge
1.63
61 #ifdef PCC_DEBUG
62         if (xdebug) {
63                 printf("clocal: %p\n"p);
64                 fwalk(peprint0);
65         }
66 #endif
67
ragge
1.27
68         switcho = p->n_op ){
ragge
1.1
69
70         case NAME:
ragge
1.28
71                 if ((q = p->n_sp) == NULL)
72                         return p/* Nothing to care about */
73
74                 switch (q->sclass) {
ragge
1.1
75
ragge
1.3
76                 case PARAM:
ragge
1.63
77                         /* First 7 parameters are in registers */
78                         /* XXX last may be double */
79                         if (q->soffset/SZINT < 7) {
80                                 p->n_op = REG;
81                                 p->n_rval = q->soffset/SZINT;
82                                 break;
83                         } else
84                                 q->soffset -= 7*SZINT;
85                                 
ragge
1.1
86                 case AUTO:
87                         /* fake up a structure reference */
ragge
1.61
88                         if (q->stype == CHAR || q->stype == UCHAR ||
89                             q->stype == SHORT || q->stype == USHORT)
90                                 r = block(REGNILNILPTR+q->stype00);
91                         else
92                                 r = block(REGNILNILPTR+STRTY00);
ragge
1.27
93                         r->n_lval = 0;
94                         r->n_rval = FPREG;
ragge
1.3
95                         p = stref(block(STREFrp000));
ragge
1.1
96                         break;
97
98                 case STATIC:
ragge
1.28
99                         if (q->slevel == 0)
100                                 break;
ragge
1.27
101                         p->n_lval = 0;
ragge
1.1
102                         break;
103
104                 case REGISTER:
ragge
1.27
105                         p->n_op = REG;
106                         p->n_lval = 0;
ragge
1.28
107                         p->n_rval = q->soffset;
ragge
1.1
108                         break;
109
110                         }
111                 break;
112
ragge
1.69
113         case CALL:
114                 /* avoid recursive calls */
115                 r = tempnode(0p->n_typep->n_dfp->n_sue);
116                 l = tempnode(regno(r), p->n_typep->n_dfp->n_sue);
117                 ecomp(buildtree(ASSIGNrp));
118                 p = l;
119                 break;
120
ragge
1.14
121         case PCONV:
ragge
1.27
122                 l = p->n_left;
ragge
1.14
123                 /*
124                  * Handle frame pointer directly without conversion,
125                  * for efficiency.
126                  */
ragge
1.55
127                 if (l->n_op == REG && l->n_rval == 0) {
ragge
1.27
128 rmpc:                   l->n_type = p->n_type;
ragge
1.33
129                         l->n_df = p->n_df;
ragge
1.30
130                         l->n_sue = p->n_sue;
ragge
1.38
131                         nfree(p);
ragge
1.15
132                         return l;
133                 }
134                 /* Convert ICON with name to new type */
ragge
1.28
135                 if (l->n_op == ICON && l->n_sp != NULL &&
ragge
1.27
136                     l->n_type == INCREF(STRTY) && 
ragge
1.48
137                     (p->n_type == INCREF(CHAR) ||
138                     p->n_type == INCREF(UCHAR) ||
139                     p->n_type == INCREF(SHORT) ||
140                     p->n_type == INCREF(USHORT))) {
ragge
1.27
141                         l->n_lval *= (BTYPE(p->n_type) == CHAR ||
142                             BTYPE(p->n_type) == UCHAR ? 4 : 2);
ragge
1.15
143                         goto rmpc;
ragge
1.14
144                 }
ragge
1.20
145                 /* Convert only address constants, never convert other */
ragge
1.27
146                 if (l->n_op == ICON) {
ragge
1.28
147                         if (l->n_sp == NULL)
ragge
1.20
148                                 goto rmpc;
ragge
1.27
149                         if (p->n_type == INCREF(CHAR) ||
150                             p->n_type == INCREF(UCHAR) ||
ragge
1.42
151                             p->n_type == INCREF(VOID))
ragge
1.27
152                                 l->n_lval = (l->n_lval & 07777777777) |
ragge
1.62
153                                     0700000000000LL;
ragge
1.27
154                         else if (p->n_type == INCREF(SHORT) ||
155                             p->n_type == INCREF(USHORT))
156                                 l->n_lval = (l->n_lval & 07777777777) |
ragge
1.62
157                                     0750000000000LL;
ragge
1.20
158                         else
ragge
1.27
159                                 l->n_lval = l->n_lval & 07777777777;
ragge
1.14
160                         goto rmpc;
ragge
1.20
161                 }
ragge
1.1
162
ragge
1.17
163                 /* Remove more conversions of identical pointers */
ragge
1.18
164                 /* Be careful! optim() may do bad things */
ragge
1.27
165                 if (ISPTR(DECREF(p->n_type))) {
166                         if (ISPTR(DECREF(l->n_type))) {
ragge
1.48
167                                 if ((coptype(l->n_op) == UTYPE ||
168                                     coptype(l->n_op) == BITYPE) &&
ragge
1.27
169                                     (l->n_left->n_op == REG))
170                                         l->n_left->n_type = p->n_type;
ragge
1.18
171                                 goto rmpc;
ragge
1.17
172                         }
173                 }
ragge
1.19
174
175                 /* Change PCONV from int to double pointer to right shift */
ragge
1.27
176                 if (ISPTR(p->n_type) && ISPTR(DECREF(p->n_type)) &&
177                     (l->n_type == INT || l->n_type == UNSIGNED)) {
178                         p->n_op = RS;
179                         p->n_right = bcon(2);
ragge
1.19
180                         break;
ragge
1.15
181                 }
ragge
1.21
182                 
183                 /* Check for cast integral -> pointer */
ragge
1.27
184                 if (BTYPE(l->n_type) == l->n_type)
ragge
1.21
185                         break;
186
187                 /* Remove conversions to identical pointers */
ragge
1.63
188                 switch (xptype(p->n_type)) {
ragge
1.21
189                 case PTRNORMAL:
ragge
1.63
190                         if (xptype(l->n_type) == PTRNORMAL)
ragge
1.21
191                                 goto rmpc;
192                         break;
193
194                 case PTRSHORT:
ragge
1.63
195                         if (xptype(l->n_type) == PTRSHORT)
ragge
1.21
196                                 goto rmpc;
197                         break;
ragge
1.20
198
ragge
1.21
199                 case PTRCHAR:
ragge
1.63
200                         if (xptype(l->n_type) == PTRCHAR)
ragge
1.21
201                                 goto rmpc;
202                         break;
203                 }
ragge
1.20
204
ragge
1.15
205                 break;
ragge
1.11
206
ragge
1.15
207         case SCONV:
ragge
1.27
208                 l = p->n_left;
ragge
1.1
209
ragge
1.27
210                 if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
ragge
1.63
211                     btdims[p->n_type].suesize == btdims[l->n_type].suesize) {
ragge
1.51
212                         if (p->n_type != FLOAT && p->n_type != DOUBLE &&
213                              l->n_type != FLOAT && l->n_type != DOUBLE) {
214                                 nfree(p);
215                                 return l;
216                         }
ragge
1.18
217                 }
218                 /* cast to (void) XXX should be removed in MI code */
ragge
1.42
219                 if (p->n_type == VOID) {
ragge
1.38
220                         nfree(p);
ragge
1.18
221                         return l;
222                 }
ragge
1.27
223                 m = p->n_type;
224                 ml = l->n_type;
ragge
1.18
225                 if (m == ml) {
ragge
1.38
226                         nfree(p);
ragge
1.18
227                         return l;
228                 }
ragge
1.27
229                 o = l->n_op;
ragge
1.20
230                 if (ml == FLOAT || ml == DOUBLE) {
ragge
1.41
231                         if (o != FCON)
ragge
1.20
232                                 break;
233                         ml = ISUNSIGNED(m) ? UNSIGNED : INT/* LONG? */
stefan
1.66
234                         r = xbcon(ml == INT ? (int)p->n_left->n_dcon :
235                                               (unsigned)p->n_left->n_dcon,
236                                   NULLml);
ragge
1.38
237                         nfree(p->n_left);
ragge
1.27
238                         p->n_left = r;
ragge
1.20
239                         o = ICON;
240                         if (m == ml) {
ragge
1.38
241                                 r = p->n_left;
242                                 nfree(p);
243                                 return r;
ragge
1.20
244                         }
245                 }
ragge
1.18
246                 if (o == ICON) {
ragge
1.27
247                         CONSZ val = l->n_lval;
ragge
1.18
248
249                         switch (m) {
250                         case CHAR:
ragge
1.27
251                                 l->n_lval = val & 0777;
ragge
1.18
252                                 if (val & 0400)
ragge
1.27
253                                         l->n_lval |= ~((CONSZ)0777);
ragge
1.18
254                                 break;
255                         case UCHAR:
ragge
1.27
256                                 l->n_lval = val & 0777;
ragge
1.18
257                                 break;
258                         case USHORT:
ragge
1.27
259                                 l->n_lval = val & 0777777;
ragge
1.18
260                                 break;
261                         case SHORT:
ragge
1.27
262                                 l->n_lval = val & 0777777;
ragge
1.18
263                                 if (val & 0400000)
ragge
1.27
264                                         l->n_lval |= ~((CONSZ)0777777);
ragge
1.18
265                                 break;
266                         case UNSIGNED:
ragge
1.62
267                                 l->n_lval = val & 0777777777777LL;
ragge
1.18
268                                 break;
269                         case INT:
ragge
1.62
270                                 l->n_lval = val & 0777777777777LL;
ragge
1.18
271                                 if (val & 0400000000000LL)
ragge
1.62
272                                         l->n_lval |= ~(0777777777777LL);
ragge
1.18
273                                 break;
274                         case LONGLONG:  /* XXX */
275                         case ULONGLONG:
ragge
1.27
276                                 l->n_lval = val;
ragge
1.18
277                                 break;
ragge
1.42
278                         case VOID:
ragge
1.18
279                                 break;
ragge
1.51
280                         case DOUBLE:
281                         case FLOAT:
282                                 l->n_op = FCON;
283                                 l->n_dcon = 0;
284                                 break;
ragge
1.18
285                         default:
286                                 cerror("unknown type %d"m);
287                         }
ragge
1.27
288                         l->n_type = m;
ragge
1.73
289                         l->n_sue = 0;
ragge
1.38
290                         nfree(p);
ragge
1.15
291                         return l;
292                 }
293                 break;
ragge
1.1
294
ragge
1.14
295         case PMCONV:
ragge
1.19
296         case PVCONV:
ragge
1.56
297 /*                if( p->n_right->n_op != ICON ) cerror( "bad conversion", 0); */
ragge
1.38
298                 nfree(p);
ragge
1.27
299                 return(buildtree(o==PMCONV?MUL:DIVp->n_leftp->n_right));
ragge
1.11
300
ragge
1.1
301         case RS:
ragge
1.59
302         case RSEQ:
ragge
1.1
303                 /* convert >> to << with negative shift count */
ragge
1.21
304                 /* Beware! constant shifts will be converted back in optim() */
ragge
1.1
305
ragge
1.58
306                 if (p->n_right->n_op != UMINUS) {
307                         p->n_right = buildtree(UMINUSp->n_rightNIL);
ragge
1.10
308                 } else {
ragge
1.27
309                         r = p->n_right;
310                         p->n_right = p->n_right->n_left;
ragge
1.38
311                         nfree(r);
ragge
1.1
312                 }
ragge
1.27
313                 if (p->n_op == RS)
314                         p->n_op = LS;
ragge
1.10
315                 else
ragge
1.59
316                         p->n_op = LSEQ;
ragge
1.1
317                 break;
318
ragge
1.58
319         case UMUL/* Convert structure assignment to memcpy() */
ragge
1.61
320                 if (p->n_left->n_op == PLUS &&
321                     p->n_left->n_left->n_op == PCONV &&
322                     p->n_left->n_right->n_op == ICON &&
323                     (p->n_type == CHAR || p->n_type == UCHAR ||
324                     p->n_type == SHORT || p->n_type == USHORT)) {
325                         /* Can remove the left SCONV */
326                         l = p->n_left->n_left;
327                         p->n_left->n_left = l->n_left;
328                         nfree(l);
329                         break;
330
331                 }
ragge
1.27
332                 if (p->n_left->n_op != STASG)
ragge
1.19
333                         break;
334                 oop = p;
ragge
1.27
335                 p = p->n_left;
ragge
1.30
336                 siz = p->n_sue->suesize/SZCHAR;
ragge
1.27
337                 l = p->n_left;
338                 r = p->n_right;
ragge
1.54
339                 if (l->n_type == STRTY || l->n_type == UNIONTY) {
ragge
1.58
340                         if (l->n_op == UMUL) {
ragge
1.27
341                                 p->n_left = l->n_left;
ragge
1.38
342                                 nfree(l);
ragge
1.27
343                                 l = p->n_left;
ragge
1.19
344                         } else {
ragge
1.57
345                                 l = block(ADDROFlNILINCREF(l->n_type),
ragge
1.73
346                                     00);
ragge
1.19
347                         }
348                 }
ragge
1.54
349                 if ((l->n_type != (STRTY+PTR) && l->n_type != (UNIONTY+PTR)) ||
350                     (r->n_type != (STRTY+PTR) && r->n_type != (UNIONTY+PTR)))
ragge
1.27
351                         cerror("bad stasg, l = %o, r = %o"l->n_typer->n_type);
ragge
1.28
352                 q = newfun("__structcpy"p->n_type);
ragge
1.19
353
354                 /* structure pointer block */
ragge
1.73
355                 l = block(CMlrINT00);
ragge
1.19
356                 /* Size block */
ragge
1.73
357                 r = block(CMlbcon(siz), INT00);
ragge
1.19
358
stefan
1.66
359                 l = xbcon(0qq->stype);
ragge
1.27
360                 p->n_left = l;
361                 p->n_right = r;
362                 p->n_op = CALL;
363                 oop->n_left = p;
ragge
1.19
364                 return oop;
ragge
1.35
365
ragge
1.64
366         case FORCE:
367                 p->n_op = ASSIGN;
368                 p->n_right = p->n_left;
ragge
1.73
369                 p->n_left = block(REGNILNILp->n_type00);
ragge
1.64
370                 p->n_left->n_rval = RETREG(p->n_type);
371                 break;
372
ragge
1.15
373         }
ragge
1.1
374
375         return(p);
376 }
ragge
1.45
377
378 void
379 myp2tree(NODE *p)
380 {
381         NODE *r;
382
383         switch (p->n_op) {
384         case ULT/* exor sign bit to avoid unsigned comparitions */
385         case ULE:
386         case UGT:
387         case UGE:
ragge
1.53
388                 if (ISLONGLONG(p->n_left->n_type)) {
stefan
1.66
389                         /* XXX */
390                         r = xbcon(0x8000000000000000ULLNULLLONGLONG);
391                 } else
392                         r = xbcon(0400000000000LLNULLINT);
ragge
1.45
393                 p->n_left = buildtree(ERp->n_leftr);
394                 if (ISUNSIGNED(p->n_left->n_type))
395                         p->n_left->n_type = DEUNSIGN(p->n_left->n_type);
396
ragge
1.53
397                 if (ISLONGLONG(p->n_right->n_type)) {
stefan
1.66
398                         /* XXX */
399                         r = xbcon(0x8000000000000000ULLNULLLONGLONG);
400                 } else
401                         r = xbcon(0400000000000LLNULLINT);
ragge
1.45
402                 p->n_right = buildtree(ERp->n_rightr);
403                 if (ISUNSIGNED(p->n_right->n_type))
404                         p->n_right->n_type = DEUNSIGN(p->n_right->n_type);
405
406                 p->n_op -= (ULT-LT);
407                 break;
ragge
1.67
408         case FCON:
409                 cerror("fix float constants");
ragge
1.45
410         }
411 }
412
ragge
1.1
413
ragge
1.28
414 struct symtab *
ragge
1.19
415 newfun(char *nameTWORD type)
416 {
417         struct symtab *sp;
418
ragge
1.28
419         sp = lookup(name0);
ragge
1.42
420         if (sp->stype == VOID) {
ragge
1.20
421                 sp->stype = INCREF(type | FTN);
ragge
1.19
422                 sp->sclass = EXTERN;
ragge
1.28
423                 sp->soffset = 0;
ragge
1.20
424         }
425 #ifdef notdef
426         else if (!ISFTN(DECREF(sp->stype)))
ragge
1.19
427                 uerror("reserved name '%s' used illegally"name);
ragge
1.20
428 #endif
ragge
1.28
429         return sp;
ragge
1.19
430 }
431
ragge
1.1
432 /*ARGSUSED*/
433 int
434 andable(NODE *p)
435 {
436         return(1);  /* all names can have & taken on them */
437 }
438
439 /*
440  * is an automatic variable of type t OK for a register variable
441  * Everything is trusted to be in register here.
442  */
443 int
444 cisreg(TWORD t)
445 {
446         return(1);
ragge
1.21
447 }
448
449 int
ragge
1.63
450 xptype(TWORD t)
ragge
1.21
451 {
452         int tt = BTYPE(t);
453         int erv;
454
455         if (!ISPTR(t))
456                 cerror("not a pointer");
457
458         e = t & ~BTMASK;
ragge
1.63
459         rv = e;
ragge
1.21
460         while (e) {
461                 rv = e;
462                 if (DECREF(e) == 0)
463                         break;
464                 e = DECREF(e);
465         }
466         if (ISFTN(rv))
467                 return PTRNORMAL;
468
469         switch (tt) {
470         case INT:
471         case LONG:
472         case LONGLONG:
473         case FLOAT:
474         case DOUBLE:
475         case STRTY:
476         case UNIONTY:
477         case UNSIGNED:
478         case ULONG:
479         case ULONGLONG:
480                 return PTRNORMAL;
ragge
1.42
481         case VOID:
ragge
1.21
482         case CHAR:
483         case UCHAR:
484                 if (DECREF(t) == tt || ISARY(rv))
485                         return PTRCHAR;
486                 return PTRNORMAL;
487         case SHORT:
488         case USHORT:
489                 if (DECREF(t) == tt || ISARY(rv))
490                         return PTRSHORT;
491                 return PTRNORMAL;
492         default:
493                 break;
494         }
495         cerror("unknown type");
496         return PTRNORMAL/* XXX */
ragge
1.1
497 }
498
ragge
1.14
499 /*
500  * Help routine to the one below; return true if it's not a word pointer.
501  */
502 static int
503 pointp(TWORD t)
504 {
505         int rv = 0;
506
507         if (ISPTR(t) && ((t & TMASK1) == 0))
508                 return 1;
509
510         t &= ~BTMASK;
511         while (t) {
512                 rv = ISARY(t);
513                 t = DECREF(t);
514         }
515         return rv;
516 }
517
ragge
1.11
518 /*
519  * return a node, for structure references, which is suitable for
520  * being added to a pointer of type t, in order to be off bits offset
521  * into a structure
522  * t, d, and s are the type, dimension offset, and sizeoffset
ragge
1.14
523  * For pdp10, return the type-specific index number which calculation
524  * is based on its size. For example, short a[3] would return 3.
525  * Be careful about only handling first-level pointers, the following
526  * indirections must be fullword.
ragge
1.11
527  */
ragge
1.1
528 NODE *
ragge
1.33
529 offcon(OFFSZ offTWORD tunion dimfun *dstruct suedef *sue)
ragge
1.1
530 {
531         register NODE *p;
532
ragge
1.15
533         if (xdebug)
ragge
1.32
534                 printf("offcon: OFFSZ %lld type %x dim %p siz %d\n",
535                     offtdsue->suesize);
ragge
1.1
536
537         p = bcon(0);
ragge
1.27
538         p->n_lval = off/SZINT;  /* Default */
ragge
1.14
539         if (ISPTR(DECREF(t)))
540                 return p;       /* Pointer/pointer reference */
ragge
1.46
541         switch (BTMASK & t) {
ragge
1.11
542         case INT:
543         case UNSIGNED:
544         case LONG:
545         case ULONG:
546         case STRTY:
547         case UNIONTY:
548         case LONGLONG:
549         case ULONGLONG:
ragge
1.47
550         case FLOAT:
551         case DOUBLE:
ragge
1.11
552                 break;
553
554         case SHORT:
555         case USHORT:
ragge
1.14
556                 if (pointp(t))
ragge
1.27
557                         p->n_lval = off/SZSHORT;
ragge
1.11
558                 break;
559
ragge
1.42
560         case VOID/* void pointers */
ragge
1.11
561         case CHAR:
562         case UCHAR:
ragge
1.14
563                 if (pointp(t))
ragge
1.27
564                         p->n_lval = off/SZCHAR;
ragge
1.11
565                 break;
566
567         default:
ragge
1.30
568                 cerror("offcon, off %llo size %d type %x"offsue->suesizet);
ragge
1.11
569         }
ragge
1.15
570         if (xdebug)
ragge
1.27
571                 printf("offcon return 0%llo\n"p->n_lval);
ragge
1.1
572         return(p);
573 }
574
ragge
1.26
575 /*
576  * Allocate off bits on the stack.  p is a tree that when evaluated
577  * is the multiply count for off, t is a NAME node where to write
578  * the allocated address.
ragge
1.56
579  * Be aware that a pointer conversion may be needed when saving 
580  * to node t!
ragge
1.26
581  */
582 void
583 spalloc(NODE *tNODE *pOFFSZ off)
584 {
585         NODE *sp;
586
587         if ((off % SZINT) == 0)
588                 p =  buildtree(MULpbcon(off/SZINT));
589         else if ((off % SZSHORT) == 0) {
590                 p = buildtree(MULpbcon(off/SZSHORT));
591                 p = buildtree(PLUSpbcon(1));
592                 p = buildtree(RSpbcon(1));
593         } else if ((off % SZCHAR) == 0) {
594                 p = buildtree(MULpbcon(off/SZCHAR));
595                 p = buildtree(PLUSpbcon(3));
596                 p = buildtree(RSpbcon(2));
597         } else
598                 cerror("roundsp");
599
600         /* save the address of sp */
ragge
1.33
601         sp = block(REGNILNILPTR+INTt->n_dft->n_sue);
ragge
1.27
602         sp->n_lval = 0;
603         sp->n_rval = STKREG;
ragge
1.56
604         /* Cast sp to destination type (may be redundant) */
605         sp = buildtree(CAST,
606             block(NAMENILNILt->n_typet->n_dft->n_sue), sp);
607         nfree(sp->n_left);
608         nfree(sp);
609         sp = sp->n_right;
ragge
1.26
610         ecomp(buildtree(ASSIGNtsp)); /* Emit! */
611
612         /* add the size to sp */
ragge
1.27
613         sp = block(REGNILNILp->n_type00);
614         sp->n_lval = 0;
615         sp->n_rval = STKREG;
ragge
1.26
616         ecomp(buildtree(PLUSEQspp));
617 }
ragge
1.1
618
ragge
1.63
619 #if 0
ragge
1.9
620 static int inwd;        /* current bit offsed in word */
621 static CONSZ word;      /* word being built from fields */
ragge
1.1
622
ragge
1.9
623 /*
624  * Generate initialization code for assigning a constant c
625  * to a field of width sz
626  * we assume that the proper alignment has been obtained
627  * inoff is updated to have the proper final value
628  * we also assume sz  < SZINT
629  */
ragge
1.1
630 void
631 incode(NODE *pint sz)
632 {
ragge
1.52
633         char *s;
634
ragge
1.9
635         inoff += sz;
636         if ((sz + inwd) > SZINT)
637                 cerror("incode: field > int");
638
ragge
1.27
639         word |= ((p->n_lval & ((1 << sz) - 1)) << (36 - inwd - sz));
ragge
1.1
640
641         inwd += sz;
ragge
1.9
642         if (inoff % SZINT == 0) {
ragge
1.52
643                 s = isinlining ? permalloc(30) : tmpalloc(30);
plunky
1.78
644                 sprintf(s"\t.long 0%llo\n"word);
ragge
1.52
645                 send_passt(IP_ASMs);
ragge
1.1
646                 word = inwd = 0;
647         }
ragge
1.39
648         tfree(p);
ragge
1.1
649 }
650
651 /* output code to initialize space of size sz to the value d */
652 /* the proper alignment has been obtained */
653 /* inoff is updated to have the proper final value */
654 /* on the target machine, write it out in octal! */
655 void
ragge
1.41
656 fincode(NODE *pint sz)
ragge
1.1
657 {
ragge
1.51
658         double d = p->n_dcon;
659
ragge
1.1
660         if(!nerrors)
661                 printf("        %s      0%c%.20e\n",
662                     sz == SZDOUBLE ? ".double" : ".float",
663                 sz == SZDOUBLE ? 'd' : 'f'd);
664         inoff += sz;
665 }
666
667 void
668 cinit(NODE *pint sz)
669 {
670         NODE *l;
671
672         /*
673          * as a favor (?) to people who want to write
674          *     int i = 9600/134.5;
675          * we will, under the proper circumstances, do
676          * a coercion here.
677          */
ragge
1.27
678         switch (p->n_type) {
ragge
1.1
679         case INT:
680         case UNSIGNED:
ragge
1.27
681                 l = p->n_left;
ragge
1.41
682                 if (l->n_op != SCONV || l->n_left->n_op != FCON)
ragge
1.27
683                         break;
ragge
1.38
684                 nfree(l);
ragge
1.27
685                 l = l->n_left;
ragge
1.49
686                 l->n_lval = (long)(l->n_dcon);
ragge
1.28
687                 l->n_sp = NULL;
ragge
1.27
688                 l->n_op = ICON;
689                 l->n_type = INT;
690                 p->n_left = l;
ragge
1.1
691                 break;
692         }
693         /* arrange for the initialization of p into a space of size sz */
694         /* the proper alignment has been opbtained */
695         /* inoff is updated to have the proper final value */
696         ecodep );
697         inoff += sz;
698 }
699
700 /*
701  * define n bits of zeros in a vfd
702  */
703 void
704 vfdzero(int n)
705 {
ragge
1.52
706         char *s;
707
ragge
1.1
708         inoff += n;
709         inwd += n;
710         if (inoff%ALINT ==0) {
ragge
1.52
711                 s = isinlining ? permalloc(30) : tmpalloc(30);
plunky
1.78
712                 sprintf(s"\t.long 0%llo\n"word);
ragge
1.52
713                 send_passt(IP_ASMs);
ragge
1.1
714                 word = inwd = 0;
715         }
716 }
ragge
1.63
717 #endif
ragge
1.1
718
719 /* make a name look like an external name in the local machine */
720 char *
721 exname(char *p)
722 {
ragge
1.28
723         if (p == NULL)
724                 return "";
725         return p;
ragge
1.1
726 }
727
728 /*
729  * map types which are not defined on the local machine
730  */
ragge
1.63
731 TWORD
ragge
1.1
732 ctype(TWORD type)
733 {
734         switch (BTYPE(type)) {
735         case LONG:
736                 MODTYPE(type,INT);
737                 break;
738         case ULONG:
739                 MODTYPE(type,UNSIGNED);
ragge
1.63
740                 break;
741         case LDOUBLE:
742                 MODTYPE(type,DOUBLE);
743                 break;
ragge
1.1
744         }
745         return (type);
746 }
747
748 /* curid is a variable which is defined but
749  * is not initialized (and not a function );
750  * This routine returns the stroage class for an uninitialized declaration
751  */
752 int
753 noinit()
754 {
755         return(EXTERN);
756 }
757
ragge
1.63
758 void
759 calldec(NODE *pNODE *q
760 {
761 }
762
763 void
764 extdec(struct symtab *q)
765 {
766 }
767
ragge
1.1
768 /* make a common declaration for id, if reasonable */
769 void
ragge
1.69
770 defzero(struct symtab *sp)
ragge
1.40
771 {
772         int off;
ragge
1.69
773  
774         off = tsize(sp->stypesp->sdfsp->ssue);
ragge
1.40
775         off = (off+(SZINT-1))/SZINT;
ragge
1.69
776         printf("        .%scomm "sp->sclass == STATIC ? "l" : "");
777         if (sp->slevel == 0)
778                 printf("%s,0%o\n"exname(sp->soname), off);
ragge
1.43
779         else
ragge
1.69
780                 printf(LABFMT ",0%o\n"sp->soffsetoff);
ragge
1.63
781 }
782
783 /*
784  * set fsz bits in sequence to zero.
785  */
786 void
787 zbits(OFFSZ offint fsz)
788 {
789         cerror("zbits");
790 }
791
ragge
1.48
792 /*
ragge
1.63
793  * Initialize a bitfield.
ragge
1.48
794  */
795 void
ragge
1.63
796 infld(CONSZ offint fszCONSZ val)
ragge
1.48
797 {
ragge
1.63
798 //      if (idebug)
799 //              printf("infld off %lld, fsz %d, val %lld inbits %d\n",
800 //                  off, fsz, val, inbits);
801         cerror("infld");
ragge
1.48
802 }
803
ragge
1.63
804 /*
805  * print out a constant node, may be associated with a label.
806  * Do not free the node after use.
807  * off is bit offset from the beginning of the aggregate
808  * fsz is the number of bits this is referring to
809  */
ragge
1.76
810 int
ragge
1.63
811 ninval(CONSZ offint fszNODE *p)
ragge
1.48
812 {
ragge
1.63
813         cerror("ninval");
ragge
1.40
814 }
ragge
1.63
815
816
ragge
1.68
817 /*
818  * Give target the opportunity of handling pragmas.
819  */
820 int
ragge
1.72
821 mypragma(char *str)
ragge
1.68
822 {
ragge
1.72
823         return 0;
824 }
ragge
1.68
825
826 /*
827  * Called when a identifier has been declared, to give target last word.
828  */
829 void
830 fixdef(struct symtab *sp)
831 {
832 }
833
gmcgarry
1.70
834 void
835 pass1_lastchance(struct interpass *ip)
836 {
837 }
838
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-02 02:22 +0200