source: mainline/uspace/app/pcc/arch/pdp10/local.c@ a7de7182

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a7de7182 was a7de7182, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 14 years ago

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