1 /*-------------------------------------------------------------------------
2 SDCCsymt.c - Code file for Symbols table related structures and MACRO's.
3 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 In other words, you are welcome to use, share and improve this program.
20 You are forbidden to forbid anyone else to use, share and improve
21 what you give them. Help stamp out software-hoarding!
22 -------------------------------------------------------------------------*/
27 value *aggregateToPointer (value *val);
29 void printFromToType(sym_link *from, sym_link *to) {
30 fprintf (stderr, "from type '");
31 printTypeChain (from, stderr);
32 fprintf (stderr, "'\nto type '");
33 printTypeChain (to, stderr);
34 fprintf (stderr, "'\n");
38 char *nounName(sym_link *sl) {
39 switch (SPEC_NOUN(sl))
42 if (SPEC_LONG(sl)) return "long";
43 if (sl->select.s._short) return "short";
46 case V_FLOAT: return "float";
47 case V_CHAR: return "char";
48 case V_VOID: return "void";
49 case V_STRUCT: return "struct";
50 case V_LABEL: return "label";
51 case V_BIT: return "bit";
52 case V_SBIT: return "sbit";
53 case V_DOUBLE: return "double";
58 bucket *SymbolTab[256]; /* the symbol table */
59 bucket *StructTab[256]; /* the structure table */
60 bucket *TypedefTab[256]; /* the typedef table */
61 bucket *LabelTab[256]; /* the Label table */
62 bucket *enumTab[256]; /* enumerated table */
64 /*------------------------------------------------------------------*/
65 /* initSymt () - initialises symbol table related stuff */
66 /*------------------------------------------------------------------*/
72 for (i = 0; i < 256; i++)
73 SymbolTab[i] = StructTab[i] = (void *) NULL;
77 /*-----------------------------------------------------------------*/
78 /* newBucket - allocates & returns a new bucket */
79 /*-----------------------------------------------------------------*/
85 bp = Safe_alloc ( sizeof (bucket));
90 /*-----------------------------------------------------------------*/
91 /* hashKey - computes the hashkey given a symbol name */
92 /*-----------------------------------------------------------------*/
94 hashKey (const char *s)
96 unsigned long key = 0;
103 /*-----------------------------------------------------------------*/
104 /* addSym - adds a symbol to the hash Table */
105 /*-----------------------------------------------------------------*/
107 addSym (bucket ** stab,
114 int i; /* index into the hash Table */
115 bucket *bp; /* temp bucket * */
118 symbol *csym = (symbol *)sym;
120 if (getenv("DEBUG_SANITY")) {
121 fprintf (stderr, "addSym: %s ", sname);
123 /* make sure the type is complete and sane */
124 checkTypeSanity(csym->etype, csym->name);
126 // jwk: if this is a function ptr with a void arg, remove it
127 if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==CPOINTER) {
128 sym_link *type=csym->type->next;
129 if (FUNC_ARGS(type) && SPEC_NOUN(FUNC_ARGS(type)->type)==V_VOID) {
130 FUNC_ARGS(type)=NULL;
135 /* prevent overflow of the (r)name buffers */
136 if (strlen(sname)>SDCC_SYMNAME_MAX) {
137 werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
138 sname[SDCC_SYMNAME_MAX]='\0';
141 /* the symbols are always added at the head of the list */
143 /* get a free entry */
144 bp = Safe_alloc ( sizeof (bucket));
146 bp->sym = sym; /* update the symbol pointer */
147 bp->level = level; /* update the nest level */
149 strcpy (bp->name, sname); /* copy the name into place */
151 /* if this is the first entry */
154 bp->prev = bp->next = (void *) NULL; /* point to nothing */
157 /* not first entry then add @ head of list */
167 /*-----------------------------------------------------------------*/
168 /* deleteSym - deletes a symbol from the hash Table entry */
169 /*-----------------------------------------------------------------*/
171 deleteSym (bucket ** stab, void *sym, char *sname)
179 /* find the symbol */
182 if (bp->sym == sym) /* found it then break out */
183 break; /* of the loop */
187 if (!bp) /* did not find it */
189 /* if this is the first one in the chain */
193 if (stab[i]) /* if chain ! empty */
194 stab[i]->prev = (void *) NULL;
196 /* middle || end of chain */
199 if (bp->next) /* if not end of chain */
200 bp->next->prev = bp->prev;
202 bp->prev->next = bp->next;
207 /*-----------------------------------------------------------------*/
208 /* findSym - finds a symbol in a table */
209 /*-----------------------------------------------------------------*/
211 findSym (bucket ** stab, void *sym, const char *sname)
215 bp = stab[hashKey (sname)];
218 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
223 return (bp ? bp->sym : (void *) NULL);
226 /*-----------------------------------------------------------------*/
227 /* findSymWithLevel - finds a symbol with a name & level */
228 /*-----------------------------------------------------------------*/
230 findSymWithLevel (bucket ** stab, symbol * sym)
234 bp = stab[hashKey (sym->name)];
237 ** do the search from the head of the list since the
238 ** elements are added at the head it is ensured that
239 ** we will find the deeper definitions before we find
240 ** the global ones. we need to check for symbols with
241 ** level <= to the level given, if levels match then block
242 ** numbers need to match as well
246 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
248 /* if this is parameter then nothing else need to be checked */
249 if (((symbol *) (bp->sym))->_isparm)
251 /* if levels match then block numbers should also match */
252 if (bp->level && bp->level == sym->level && bp->block == sym->block)
254 /* if levels don't match then we are okay */
255 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
257 /* if this is a global variable then we are ok too */
265 return (void *) NULL;
268 /*-----------------------------------------------------------------*/
269 /* findSymWithBlock - finds a symbol with name in with a block */
270 /*-----------------------------------------------------------------*/
272 findSymWithBlock (bucket ** stab, symbol * sym, int block)
276 bp = stab[hashKey (sym->name)];
279 if (strcmp (bp->name, sym->name) == 0 &&
285 return (bp ? bp->sym : (void *) NULL);
288 /*------------------------------------------------------------------*/
289 /* newSymbol () - returns a new pointer to a symbol */
290 /*------------------------------------------------------------------*/
292 newSymbol (char *name, int scope)
296 sym = Safe_alloc ( sizeof (symbol));
298 strcpy (sym->name, name); /* copy the name */
299 sym->level = scope; /* set the level */
300 sym->block = currBlockno;
301 sym->lineDef = yylineno; /* set the line number */
305 /*------------------------------------------------------------------*/
306 /* newLink - creates a new link (declarator,specifier) */
307 /*------------------------------------------------------------------*/
313 p = Safe_alloc ( sizeof (sym_link));
318 /*------------------------------------------------------------------*/
319 /* newStruct - creats a new structdef from the free list */
320 /*------------------------------------------------------------------*/
322 newStruct (char *tag)
326 s = Safe_alloc ( sizeof (structdef));
328 strcpy (s->tag, tag); /* copy the tag */
332 /*------------------------------------------------------------------*/
333 /* pointerTypes - do the computation for the pointer types */
334 /*------------------------------------------------------------------*/
336 pointerTypes (sym_link * ptr, sym_link * type)
341 /* find the first pointer type */
342 while (ptr && !IS_PTR (ptr))
345 /* could not find it */
346 if (!ptr || IS_SPEC (ptr))
349 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
350 pointerTypes (ptr->next, type);
354 /* change the pointer type depending on the
355 storage class of the type */
358 DCL_PTR_CONST (ptr) = SPEC_CONST (type);
359 DCL_PTR_VOLATILE (ptr) = SPEC_VOLATILE (type);
360 switch (SPEC_SCLS (type))
363 DCL_TYPE (ptr) = FPOINTER;
366 DCL_TYPE (ptr) = IPOINTER;
369 DCL_TYPE (ptr) = PPOINTER;
372 DCL_TYPE (ptr) = POINTER;
375 DCL_PTR_CONST (ptr) = port->mem.code_ro;
376 DCL_TYPE (ptr) = CPOINTER;
379 DCL_TYPE (ptr) = EEPPOINTER;
382 DCL_TYPE (ptr) = GPOINTER;
385 /* the storage class of type ends here */
388 SPEC_VOLATILE (type) = 0;
391 /* now change all the remaining unknown pointers
392 to generic pointers */
395 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
396 DCL_TYPE (ptr) = GPOINTER;
400 /* same for the type although it is highly unlikely that
401 type will have a pointer */
404 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
405 DCL_TYPE (type) = GPOINTER;
411 /*------------------------------------------------------------------*/
412 /* addDecl - adds a declarator @ the end of a chain */
413 /*------------------------------------------------------------------*/
415 addDecl (symbol * sym, int type, sym_link * p)
421 /* if we are passed a link then set head & tail */
430 head = tail = newLink ();
431 DCL_TYPE (head) = type;
434 /* if this is the first entry */
442 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
444 sym->etype = mergeSpec (sym->etype, head, sym->name);
448 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
451 while (t->next != sym->etype)
454 tail->next = sym->etype;
458 sym->etype->next = head;
464 /* if the type is an unknown pointer and has
465 a tspec then take the storage class const & volatile
466 attribute from the tspec & make it those of this
470 //DCL_TYPE (p) == UPOINTER &&
473 if (!IS_SPEC (sym->etype))
475 sym->etype = sym->etype->next = newLink ();
476 sym->etype->class = SPECIFIER;
478 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
479 SPEC_CONST (sym->etype) = SPEC_CONST (DCL_TSPEC (p));
480 SPEC_VOLATILE (sym->etype) = SPEC_VOLATILE (DCL_TSPEC (p));
481 DCL_TSPEC (p) = NULL;
486 /*------------------------------------------------------------------
487 checkTypeSanity: prevent the user from doing e.g.:
489 ------------------------------------------------------------------*/
490 void checkTypeSanity(sym_link *etype, char *name) {
494 if (getenv("DEBUG_SANITY")) {
495 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
500 if (!IS_SPEC(etype)) {
501 if (getenv("DEBUG_SANITY")) {
502 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
507 noun=nounName(etype);
509 if (getenv("DEBUG_SANITY")) {
510 fprintf (stderr, "checking sanity for %s %x\n", name, (int)etype);
513 if ((SPEC_NOUN(etype)==V_CHAR ||
514 SPEC_NOUN(etype)==V_FLOAT ||
515 SPEC_NOUN(etype)==V_DOUBLE ||
516 SPEC_NOUN(etype)==V_VOID) &&
517 (etype->select.s._short || SPEC_LONG(etype))) {
518 // long or short for char float double or void
519 werror (E_LONG_OR_SHORT_INVALID, noun, name);
521 if ((SPEC_NOUN(etype)==V_FLOAT ||
522 SPEC_NOUN(etype)==V_DOUBLE ||
523 SPEC_NOUN(etype)==V_VOID) &&
524 (etype->select.s._signed || SPEC_USIGN(etype))) {
525 // signed or unsigned for float double or void
526 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
529 // special case for "short"
530 if (etype->select.s._short) {
531 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
532 etype->select.s._short = 0;
536 "const a;" or "data b;" or "signed s" or "long l"
538 if (!SPEC_NOUN(etype)) {
539 SPEC_NOUN(etype)=V_INT;
542 if (etype->select.s._signed && SPEC_USIGN(etype)) {
543 // signed AND unsigned
544 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
546 if (etype->select.s._short && SPEC_LONG(etype)) {
548 werror (E_LONG_AND_SHORT_INVALID, noun, name);
553 /*------------------------------------------------------------------*/
554 /* mergeSpec - merges two specifiers and returns the new one */
555 /*------------------------------------------------------------------*/
557 mergeSpec (sym_link * dest, sym_link * src, char *name)
559 sym_link *symlink=dest;
561 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
563 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
566 werror (E_SYNTAX_ERROR, yytext);
567 // the show must go on
572 if (SPEC_NOUN(src)) {
573 if (!SPEC_NOUN(dest)) {
574 SPEC_NOUN(dest)=SPEC_NOUN(src);
576 /* we shouldn't redeclare the type */
577 if (getenv("DEBUG_SANITY")) {
578 fprintf (stderr, "mergeSpec: ");
580 werror(E_TWO_OR_MORE_DATA_TYPES, name);
584 if (SPEC_SCLS(src)) {
585 /* if destination has no storage class */
586 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
587 SPEC_SCLS (dest) = SPEC_SCLS (src);
589 if (getenv("DEBUG_SANITY")) {
590 fprintf (stderr, "mergeSpec: ");
592 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
596 /* copy all the specifications */
598 // we really should do:
600 if (SPEC_what(src)) {
601 if (SPEC_what(dest)) {
602 werror(W_DUPLICATE_SPEC, "what");
604 SPEC_what(dst)|=SPEC_what(src);
607 // but there are more important thing right now
609 SPEC_LONG (dest) |= SPEC_LONG (src);
610 dest->select.s._short|=src->select.s._short;
611 SPEC_USIGN (dest) |= SPEC_USIGN (src);
612 dest->select.s._signed|=src->select.s._signed;
613 SPEC_STAT (dest) |= SPEC_STAT (src);
614 SPEC_EXTR (dest) |= SPEC_EXTR (src);
615 SPEC_CONST(dest) |= SPEC_CONST (src);
616 SPEC_ABSA (dest) |= SPEC_ABSA (src);
617 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
618 SPEC_ADDR (dest) |= SPEC_ADDR (src);
619 SPEC_OCLS (dest) = SPEC_OCLS (src);
620 SPEC_BLEN (dest) |= SPEC_BLEN (src);
621 SPEC_BSTR (dest) |= SPEC_BSTR (src);
622 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
624 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
625 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
627 /* these are the only function attributes that will be set
628 in a specifier while parsing */
629 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
630 FUNC_BANKED(dest) |= FUNC_BANKED(src);
631 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
632 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
633 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
634 FUNC_ISISR(dest) |= FUNC_ISISR(src);
635 FUNC_INTNO(dest) |= FUNC_INTNO(src);
636 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
641 /*------------------------------------------------------------------*/
642 /* cloneSpec - copies the entire spec and returns a new spec */
643 /*------------------------------------------------------------------*/
645 cloneSpec (sym_link * src)
649 /* go thru chain till we find the specifier */
650 while (src && src->class != SPECIFIER)
654 memcpy (spec, src, sizeof (sym_link));
658 /*------------------------------------------------------------------*/
659 /* genSymName - generates and returns a name used for anonymous vars */
660 /*------------------------------------------------------------------*/
662 genSymName (int level)
664 static int gCount = 0;
665 static char gname[SDCC_NAME_MAX + 1];
667 sprintf (gname, "__%04d%04d", level, gCount++);
671 /*------------------------------------------------------------------*/
672 /* getSpec - returns the specifier part from a declaration chain */
673 /*------------------------------------------------------------------*/
675 getSpec (sym_link * p)
680 while (p && !(IS_SPEC (p)))
686 /*------------------------------------------------------------------*/
687 /* newCharLink() - creates an char type */
688 /*------------------------------------------------------------------*/
695 p->class = SPECIFIER;
696 SPEC_NOUN (p) = V_CHAR;
701 /*------------------------------------------------------------------*/
702 /* newFloatLink - a new Float type */
703 /*------------------------------------------------------------------*/
710 p->class = SPECIFIER;
711 SPEC_NOUN (p) = V_FLOAT;
716 /*------------------------------------------------------------------*/
717 /* newLongLink() - new long type */
718 /*------------------------------------------------------------------*/
725 p->class = SPECIFIER;
726 SPEC_NOUN (p) = V_INT;
732 /*------------------------------------------------------------------*/
733 /* newIntLink() - creates an int type */
734 /*------------------------------------------------------------------*/
741 p->class = SPECIFIER;
742 SPEC_NOUN (p) = V_INT;
747 /*------------------------------------------------------------------*/
748 /* getSize - returns size of a type chain in bits */
749 /*------------------------------------------------------------------*/
751 getSize (sym_link * p)
753 /* if nothing return 0 */
757 { /* if this is the specifier then */
758 switch (SPEC_NOUN (p))
759 { /* depending on the specifier type */
761 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
769 return SPEC_STRUCT (p)->size;
775 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
781 /* this is a specifier */
782 switch (DCL_TYPE (p))
787 return DCL_ELEM (p) * getSize (p->next);
804 /*------------------------------------------------------------------*/
805 /* bitsForType - returns # of bits required to store this type */
806 /*------------------------------------------------------------------*/
808 bitsForType (sym_link * p)
810 /* if nothing return 0 */
815 { /* if this is the specifier then */
817 switch (SPEC_NOUN (p))
818 { /* depending on the specifier type */
820 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
822 return FLOATSIZE * 8;
828 return SPEC_STRUCT (p)->size * 8;
834 return SPEC_BLEN (p);
840 /* this is a specifier */
841 switch (DCL_TYPE (p))
846 return DCL_ELEM (p) * getSize (p->next) * 8;
850 return (PTRSIZE * 8);
854 return (FPTRSIZE * 8);
856 return (GPTRSIZE * 8);
863 /*------------------------------------------------------------------*/
864 /* copySymbolChain - copies a symbol chain */
865 /*------------------------------------------------------------------*/
867 copySymbolChain (symbol * src)
874 dest = copySymbol (src);
875 dest->next = copySymbolChain (src->next);
879 /*------------------------------------------------------------------*/
880 /* copySymbol - makes a copy of a symbol */
881 /*------------------------------------------------------------------*/
883 copySymbol (symbol * src)
890 dest = newSymbol (src->name, src->level);
891 memcpy (dest, src, sizeof (symbol));
892 dest->level = src->level;
893 dest->block = src->block;
894 dest->ival = copyIlist (src->ival);
895 dest->type = copyLinkChain (src->type);
896 dest->etype = getSpec (dest->type);
898 dest->key = src->key;
899 dest->allocreq = src->allocreq;
903 /*------------------------------------------------------------------*/
904 /* reverseSyms - reverses the links for a symbol chain */
905 /*------------------------------------------------------------------*/
907 reverseSyms (symbol * sym)
909 symbol *prev, *curr, *next;
924 sym->next = (void *) NULL;
928 /*------------------------------------------------------------------*/
929 /* reverseLink - reverses the links for a type chain */
930 /*------------------------------------------------------------------*/
932 reverseLink (sym_link * type)
934 sym_link *prev, *curr, *next;
949 type->next = (void *) NULL;
953 /*------------------------------------------------------------------*/
954 /* addSymChain - adds a symbol chain to the symboltable */
955 /*------------------------------------------------------------------*/
957 addSymChain (symbol * symHead)
959 symbol *sym = symHead;
962 for (; sym != NULL; sym = sym->next)
965 checkTypeSanity(sym->etype, sym->name);
967 /* if already exists in the symbol table then check if
968 one of them is an extern definition if yes then
969 then check if the type match, if the types match then
970 delete the current entry and add the new entry */
971 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
972 csym->level == sym->level) {
974 /* one definition extern ? */
975 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) {
976 /* do types match ? */
977 if (compareType (csym->type, sym->type) != 1) {
979 werror (E_EXTERN_MISMATCH, csym->name);
982 /* delete current entry */
983 deleteSym (SymbolTab, csym, csym->name);
986 werror (E_DUPLICATE, sym->name);
992 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
997 /*------------------------------------------------------------------*/
998 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
999 /*------------------------------------------------------------------*/
1001 funcInChain (sym_link * lnk)
1012 /*------------------------------------------------------------------*/
1013 /* structElemType - returns the type info of a sturct member */
1014 /*------------------------------------------------------------------*/
1016 structElemType (sym_link * stype, value * id)
1018 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1019 sym_link *type, *etype;
1020 sym_link *petype = getSpec (stype);
1025 /* look for the id */
1028 if (strcmp (fields->rname, id->name) == 0)
1030 type = copyLinkChain (fields->type);
1031 etype = getSpec (type);
1032 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1033 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1036 fields = fields->next;
1038 werror (E_NOT_MEMBER, id->name);
1043 /*------------------------------------------------------------------*/
1044 /* getStructElement - returns element of a tructure definition */
1045 /*------------------------------------------------------------------*/
1047 getStructElement (structdef * sdef, symbol * sym)
1051 for (field = sdef->fields; field; field = field->next)
1052 if (strcmp (field->name, sym->name) == 0)
1055 werror (E_NOT_MEMBER, sym->name);
1057 return sdef->fields;
1060 /*------------------------------------------------------------------*/
1061 /* compStructSize - computes the size of a structure */
1062 /*------------------------------------------------------------------*/
1064 compStructSize (int su, structdef * sdef)
1066 int sum = 0, usum = 0;
1070 /* for the identifiers */
1071 loop = sdef->fields;
1074 /* create the internal name for this variable */
1075 sprintf (loop->rname, "_%s", loop->name);
1076 loop->offset = (su == UNION ? sum = 0 : sum);
1077 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1079 /* if this is a bit field */
1082 /* change it to a unsigned bit */
1083 SPEC_NOUN (loop->etype) = V_BIT;
1084 SPEC_USIGN (loop->etype) = 1;
1085 /* check if this fit into the remaining */
1086 /* bits of this byte else align it to the */
1087 /* next byte boundary */
1088 if ((SPEC_BLEN (loop->etype) = loop->bitVar) <= (8 - bitOffset)) {
1089 SPEC_BSTR (loop->etype) = bitOffset;
1090 if ((bitOffset += (loop->bitVar % 8)) == 8)
1093 else /* does not fit */ {
1095 SPEC_BSTR (loop->etype) = bitOffset;
1096 sum += (loop->bitVar / 8);
1097 bitOffset += (loop->bitVar % 8);
1099 /* if this is the last field then pad */
1100 if (!loop->next && bitOffset && bitOffset != 8) {
1106 checkDecl (loop, 1);
1107 sum += getSize (loop->type);
1110 /* if function then do the arguments for it */
1111 if (funcInChain (loop->type)) {
1112 processFuncArgs (loop, 1);
1117 /* if this is not a bitfield but the */
1118 /* previous one was and did not take */
1119 /* the whole byte then pad the rest */
1120 if ((loop && !loop->bitVar) && bitOffset) {
1125 /* if union then size = sizeof larget field */
1127 usum = max (usum, sum);
1131 return (su == UNION ? usum : sum);
1134 /*------------------------------------------------------------------*/
1135 /* checkSClass - check the storage class specification */
1136 /*------------------------------------------------------------------*/
1138 checkSClass (symbol * sym, int isProto)
1140 if (getenv("DEBUG_SANITY")) {
1141 fprintf (stderr, "checkSClass: %s \n", sym->name);
1144 /* type is literal can happen foe enums change
1146 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1147 SPEC_SCLS (sym->etype) = S_AUTO;
1149 /* if sfr or sbit then must also be */
1150 /* volatile the initial value will be xlated */
1151 /* to an absolute address */
1152 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1153 SPEC_SCLS (sym->etype) == S_SFR)
1155 SPEC_VOLATILE (sym->etype) = 1;
1156 /* if initial value given */
1159 SPEC_ABSA (sym->etype) = 1;
1160 SPEC_ADDR (sym->etype) =
1161 (int) list2int (sym->ival);
1166 /* if absolute address given then it mark it as
1168 if (IS_ABSOLUTE (sym->etype))
1169 SPEC_VOLATILE (sym->etype) = 1;
1171 /* global variables declared const put into code */
1172 if (sym->level == 0 &&
1173 SPEC_CONST (sym->etype)) {
1174 SPEC_SCLS (sym->etype) = S_CODE;
1177 /* global variable in code space is a constant */
1178 if (sym->level == 0 &&
1179 SPEC_SCLS (sym->etype) == S_CODE &&
1181 SPEC_CONST (sym->etype) = 1;
1184 /* if bit variable then no storage class can be */
1185 /* specified since bit is already a storage */
1186 if (IS_BITVAR (sym->etype) &&
1187 (SPEC_SCLS (sym->etype) != S_FIXED &&
1188 SPEC_SCLS (sym->etype) != S_SBIT &&
1189 SPEC_SCLS (sym->etype) != S_BIT)
1192 werror (E_BITVAR_STORAGE, sym->name);
1193 SPEC_SCLS (sym->etype) = S_FIXED;
1196 /* extern variables cannot be initialized */
1197 if (IS_EXTERN (sym->etype) && sym->ival)
1199 werror (E_EXTERN_INIT, sym->name);
1203 /* if this is an atomatic symbol */
1204 if (sym->level && (options.stackAuto || reentrant)) {
1205 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1206 SPEC_SCLS (sym->etype) == S_FIXED ||
1207 SPEC_SCLS (sym->etype) == S_REGISTER ||
1208 SPEC_SCLS (sym->etype) == S_STACK ||
1209 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1210 SPEC_SCLS (sym->etype) = S_AUTO;
1212 /* storage class may only be specified for statics */
1213 if (!IS_STATIC(sym->etype)) {
1214 werror (E_AUTO_ASSUMED, sym->name);
1219 /* automatic symbols cannot be given */
1220 /* an absolute address ignore it */
1222 SPEC_ABSA (sym->etype) &&
1223 (options.stackAuto || reentrant))
1225 werror (E_AUTO_ABSA, sym->name);
1226 SPEC_ABSA (sym->etype) = 0;
1229 /* arrays & pointers cannot be defined for bits */
1230 /* SBITS or SFRs or BIT */
1231 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1232 (SPEC_NOUN (sym->etype) == V_BIT ||
1233 SPEC_NOUN (sym->etype) == V_SBIT ||
1234 SPEC_SCLS (sym->etype) == S_SFR))
1235 werror (E_BIT_ARRAY, sym->name);
1237 /* if this is a bit|sbit then set length & start */
1238 if (SPEC_NOUN (sym->etype) == V_BIT ||
1239 SPEC_NOUN (sym->etype) == V_SBIT)
1241 SPEC_BLEN (sym->etype) = 1;
1242 SPEC_BSTR (sym->etype) = 0;
1246 /* variables declared in CODE space must have */
1247 /* initializers if not an extern */
1248 if (SPEC_SCLS (sym->etype) == S_CODE &&
1249 sym->ival == NULL &&
1251 port->mem.code_ro &&
1252 !IS_EXTERN (sym->etype) &&
1253 !funcInChain (sym->type))
1254 werror (E_CODE_NO_INIT, sym->name);
1257 /* if parameter or local variable then change */
1258 /* the storage class to reflect where the var will go */
1259 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1260 !IS_STATIC(sym->etype))
1262 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1264 SPEC_SCLS (sym->etype) = (options.useXstack ?
1265 S_XSTACK : S_STACK);
1269 /* hack-o-matic! I see no reason why the useXstack option should ever
1270 * control this allcoation, but the code was originally that way, and
1271 * changing it for non-390 ports breaks the compiler badly.
1273 bool useXdata = TARGET_IS_DS390 ? 1 : options.useXstack;
1274 SPEC_SCLS (sym->etype) = (useXdata ?
1280 /*------------------------------------------------------------------*/
1281 /* changePointer - change pointer to functions */
1282 /*------------------------------------------------------------------*/
1284 changePointer (symbol * sym)
1288 /* go thru the chain of declarations */
1289 /* if we find a pointer to a function */
1290 /* unconditionally change it to a ptr */
1292 for (p = sym->type; p; p = p->next)
1294 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1295 DCL_TYPE (p) = GPOINTER;
1296 if (IS_PTR (p) && IS_FUNC (p->next))
1297 DCL_TYPE (p) = CPOINTER;
1301 /*------------------------------------------------------------------*/
1302 /* checkDecl - does semantic validation of a declaration */
1303 /*------------------------------------------------------------------*/
1305 checkDecl (symbol * sym, int isProto)
1308 checkSClass (sym, isProto); /* check the storage class */
1309 changePointer (sym); /* change pointers if required */
1311 /* if this is an array without any dimension
1312 then update the dimension from the initial value */
1313 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1314 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1319 /*------------------------------------------------------------------*/
1320 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1321 /*------------------------------------------------------------------*/
1323 copyLinkChain (sym_link * p)
1325 sym_link *head, *curr, *loop;
1328 head = loop = (curr ? newLink () : (void *) NULL);
1331 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1332 loop->next = (curr->next ? newLink () : (void *) NULL);
1341 /*------------------------------------------------------------------*/
1342 /* cleanUpBlock - cleansup the symbol table specified for all the */
1343 /* symbols in the given block */
1344 /*------------------------------------------------------------------*/
1346 cleanUpBlock (bucket ** table, int block)
1351 /* go thru the entire table */
1352 for (i = 0; i < 256; i++)
1354 for (chain = table[i]; chain; chain = chain->next)
1356 if (chain->block >= block)
1358 deleteSym (table, chain->sym, chain->name);
1364 /*------------------------------------------------------------------*/
1365 /* cleanUpLevel - cleansup the symbol table specified for all the */
1366 /* symbols in the given level */
1367 /*------------------------------------------------------------------*/
1369 cleanUpLevel (bucket ** table, int level)
1374 /* go thru the entire table */
1375 for (i = 0; i < 256; i++)
1377 for (chain = table[i]; chain; chain = chain->next)
1379 if (chain->level >= level)
1381 deleteSym (table, chain->sym, chain->name);
1387 /*------------------------------------------------------------------*/
1388 /* computeType - computes the resultant type from two types */
1389 /*------------------------------------------------------------------*/
1391 computeType (sym_link * type1, sym_link * type2)
1395 sym_link *etype1 = getSpec (type1);
1396 sym_link *etype2 = getSpec (type2);
1398 /* if one of them is a float then result is a float */
1399 /* here we assume that the types passed are okay */
1400 /* and can be cast to one another */
1401 /* which ever is greater in size */
1402 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1403 rType = newFloatLink ();
1405 /* if only one of them is a bit variable
1406 then the other one prevails */
1407 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1408 rType = copyLinkChain (type2);
1409 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1410 rType = copyLinkChain (type1);
1412 /* if one of them is a pointer then that
1415 rType = copyLinkChain (type1);
1416 else if (IS_PTR (type2))
1417 rType = copyLinkChain (type2);
1418 else if (getSize (type1) > getSize (type2))
1419 rType = copyLinkChain (type1);
1421 rType = copyLinkChain (type2);
1423 reType = getSpec (rType);
1425 /* if either of them unsigned but not val then make this unsigned */
1426 if (((!IS_LITERAL(type1) && SPEC_USIGN (etype1)) ||
1427 (!IS_LITERAL(type2) && SPEC_USIGN (etype2))) &&
1429 SPEC_USIGN (reType) = 1;
1431 SPEC_USIGN (reType) = 0;
1433 /* if result is a literal then make not so */
1434 if (IS_LITERAL (reType))
1435 SPEC_SCLS (reType) = S_REGISTER;
1440 /*--------------------------------------------------------------------*/
1441 /* compareType - will do type check return 1 if match, -1 if castable */
1442 /*--------------------------------------------------------------------*/
1444 compareType (sym_link * dest, sym_link * src)
1455 /* if dest is a declarator then */
1460 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1462 //checkFunction(src,dest);
1464 return compareType (dest->next, src->next);
1466 if (IS_PTR (src) && IS_GENPTR (dest))
1468 if (IS_PTR (dest) && IS_ARRAY (src)) {
1469 value *val=aggregateToPointer (valFromType(src));
1470 int res=compareType (dest, val->type);
1471 Safe_free(val->type);
1473 //return res ? -1 : 0;
1476 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1477 return compareType (dest->next, src);
1480 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1486 /* if one is a specifier and the other is not */
1487 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1488 (IS_SPEC (dest) && !IS_SPEC (src)))
1491 /* if one of them is a void then ok */
1492 if (SPEC_NOUN (dest) == V_VOID &&
1493 SPEC_NOUN (src) != V_VOID)
1496 if (SPEC_NOUN (dest) != V_VOID &&
1497 SPEC_NOUN (src) == V_VOID)
1500 /* if they are both bitfields then if the lengths
1501 and starts don't match */
1502 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1503 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1504 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1507 /* it is a specifier */
1508 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1510 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1511 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1512 getSize (dest) == getSize (src))
1514 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1519 else if (IS_STRUCT (dest))
1521 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1526 if (SPEC_LONG (dest) != SPEC_LONG (src))
1529 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1535 /*------------------------------------------------------------------*/
1536 /* inCalleeSaveList - return 1 if found in callee save list */
1537 /*------------------------------------------------------------------*/
1539 inCalleeSaveList (char *s)
1543 for (i = 0; options.calleeSaves[i]; i++)
1544 if (strcmp (options.calleeSaves[i], s) == 0)
1550 /*-----------------------------------------------------------------*/
1551 /* aggregateToPointer: change an agggregate type function */
1552 /* argument to a pointer to that type. */
1553 /*-----------------------------------------------------------------*/
1555 aggregateToPointer (value * val)
1557 if (IS_AGGREGATE (val->type))
1559 /* if this is a structure */
1560 /* then we need to add a new link */
1561 if (IS_STRUCT (val->type))
1563 /* first lets add DECLARATOR type */
1564 sym_link *p = val->type;
1566 werror (W_STRUCT_AS_ARG, val->name);
1567 val->type = newLink ();
1568 val->type->next = p;
1571 /* change to a pointer depending on the */
1572 /* storage class specified */
1573 switch (SPEC_SCLS (val->etype))
1576 DCL_TYPE (val->type) = IPOINTER;
1579 DCL_TYPE (val->type) = PPOINTER;
1582 if (SPEC_OCLS(val->etype)) {
1583 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1587 if (TARGET_IS_DS390)
1589 /* The AUTO and REGISTER classes should probably
1590 * also become generic pointers, but I haven't yet
1591 * devised a test case for that.
1593 DCL_TYPE (val->type) = GPOINTER;
1596 if (options.model==MODEL_LARGE) {
1597 DCL_TYPE (val->type) = FPOINTER;
1604 DCL_TYPE (val->type) = POINTER;
1607 DCL_TYPE (val->type) = CPOINTER;
1610 DCL_TYPE (val->type) = FPOINTER;
1613 DCL_TYPE (val->type) = EEPPOINTER;
1616 DCL_TYPE (val->type) = GPOINTER;
1619 /* is there is a symbol associated then */
1620 /* change the type of the symbol as well */
1623 val->sym->type = copyLinkChain (val->type);
1624 val->sym->etype = getSpec (val->sym->type);
1629 /*------------------------------------------------------------------*/
1630 /* checkFunction - does all kinds of check on a function */
1631 /*------------------------------------------------------------------*/
1633 checkFunction (symbol * sym, symbol *csym)
1635 value *exargs, *acargs;
1639 if (getenv("DEBUG_SANITY")) {
1640 fprintf (stderr, "checkFunction: %s ", sym->name);
1643 /* make sure the type is complete and sane */
1644 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1646 /* if not type then some kind of error */
1650 /* if the function has no type then make it return int */
1651 if (!sym->type->next)
1652 sym->type->next = sym->etype = newIntLink ();
1654 /* function cannot return aggregate */
1655 if (IS_AGGREGATE (sym->type->next))
1657 werror (E_FUNC_AGGR, sym->name);
1661 /* function cannot return bit */
1662 if (IS_BITVAR (sym->type->next))
1664 werror (E_FUNC_BIT, sym->name);
1668 /* check if this function is defined as calleeSaves
1669 then mark it as such */
1670 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1672 /* if interrupt service routine */
1673 /* then it cannot have arguments */
1674 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1676 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1677 werror (E_INT_ARGS, sym->name);
1678 FUNC_ARGS(sym->type)=NULL;
1682 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
1683 return 1; /* not defined nothing more to check */
1685 /* check if body already present */
1686 if (csym && IFFUNC_HASBODY(csym->type))
1688 werror (E_FUNC_BODY, sym->name);
1692 /* check the return value type */
1693 if (compareType (csym->type, sym->type) <= 0)
1695 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1696 printFromToType(csym->type, sym->type);
1700 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
1702 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1705 if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
1707 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1710 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
1712 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
1715 /* compare expected args with actual args */
1716 exargs = FUNC_ARGS(csym->type);
1717 acargs = FUNC_ARGS(sym->type);
1719 /* for all the expected args do */
1722 exargs = exargs->next, acargs = acargs->next, argCnt++)
1724 if (getenv("DEBUG_SANITY")) {
1725 fprintf (stderr, "checkFunction: %s ", exargs->name);
1727 /* make sure the type is complete and sane */
1728 checkTypeSanity(exargs->etype, exargs->name);
1730 /* If the actual argument is an array, any prototype
1731 * will have modified it to a pointer. Duplicate that
1734 if (IS_AGGREGATE (acargs->type))
1736 checkValue = copyValue (acargs);
1737 aggregateToPointer (checkValue);
1741 checkValue = acargs;
1744 if (compareType (exargs->type, checkValue->type) <= 0)
1746 werror (E_ARG_TYPE, argCnt);
1747 printFromToType(exargs->type, checkValue->type);
1752 /* if one them ended we have a problem */
1753 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1754 (!exargs && acargs && !IS_VOID (acargs->type)))
1755 werror (E_ARG_COUNT);
1757 /* replace with this defition */
1758 sym->cdef = csym->cdef;
1759 deleteSym (SymbolTab, csym, csym->name);
1760 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1761 if (IS_EXTERN (csym->etype) && !
1762 IS_EXTERN (sym->etype))
1764 addSet (&publics, sym);
1769 /*-----------------------------------------------------------------*/
1770 /* processFuncArgs - does some processing with function args */
1771 /*-----------------------------------------------------------------*/
1773 processFuncArgs (symbol * func, int ignoreName)
1777 sym_link *funcType=func->type;
1779 /* if this function has variable argument list */
1780 /* then make the function a reentrant one */
1781 if (IFFUNC_HASVARARGS(funcType))
1782 FUNC_ISREENT(funcType)=1;
1784 /* check if this function is defined as calleeSaves
1785 then mark it as such */
1786 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
1788 /* loop thru all the arguments */
1789 val = FUNC_ARGS(funcType);
1791 /* if it is void then remove parameters */
1792 if (val && IS_VOID (val->type))
1794 FUNC_ARGS(funcType) = NULL;
1798 /* reset regparm for the port */
1799 (*port->reset_regparms) ();
1800 /* if any of the arguments is an aggregate */
1801 /* change it to pointer to the same type */
1804 /* mark it as a register parameter if
1805 the function does not have VA_ARG
1806 and as port dictates */
1807 if (!IFFUNC_HASVARARGS(funcType) &&
1808 (*port->reg_parm) (val->type))
1810 SPEC_REGPARM (val->etype) = 1;
1813 if (IS_AGGREGATE (val->type))
1815 aggregateToPointer (val);
1822 /* if this is an internal generated function call */
1824 /* ignore --stack-auto for this one, we don't know how it is compiled */
1825 /* simply trust on --int-long-reent or --float-reent */
1826 if (IFFUNC_ISREENT(funcType)) {
1830 /* if this function is reentrant or */
1831 /* automatics r 2b stacked then nothing */
1832 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
1836 val = FUNC_ARGS(funcType);
1841 /* if a symbolname is not given */
1842 /* synthesize a variable name */
1846 sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
1847 val->sym = newSymbol (val->name, 1);
1848 SPEC_OCLS (val->etype) = port->mem.default_local_map;
1849 val->sym->type = copyLinkChain (val->type);
1850 val->sym->etype = getSpec (val->sym->type);
1851 val->sym->_isparm = 1;
1852 strcpy (val->sym->rname, val->name);
1853 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1854 SPEC_STAT (func->etype);
1855 addSymChain (val->sym);
1858 else /* symbol name given create synth name */
1861 sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
1862 strcpy (val->sym->rname, val->name);
1863 val->sym->_isparm = 1;
1864 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
1865 (options.model != MODEL_SMALL ? xdata : data);
1866 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1867 SPEC_STAT (func->etype);
1873 /*-----------------------------------------------------------------*/
1874 /* isSymbolEqual - compares two symbols return 1 if they match */
1875 /*-----------------------------------------------------------------*/
1877 isSymbolEqual (symbol * dest, symbol * src)
1879 /* if pointers match then equal */
1883 /* if one of them is null then don't match */
1887 /* if both of them have rname match on rname */
1888 if (dest->rname[0] && src->rname[0])
1889 return (!strcmp (dest->rname, src->rname));
1891 /* otherwise match on name */
1892 return (!strcmp (dest->name, src->name));
1895 void PT(sym_link *type)
1897 printTypeChain(type,0);
1899 /*-----------------------------------------------------------------*/
1900 /* printTypeChain - prints the type chain in human readable form */
1901 /*-----------------------------------------------------------------*/
1903 printTypeChain (sym_link * start, FILE * of)
1906 sym_link * type, * search;
1915 fprintf (of, "void");
1919 /* print the chain as it is written in the source: */
1920 /* start with the last entry */
1921 for (type = start; type && type->next; type = type->next)
1927 if (DCL_PTR_VOLATILE (type)) {
1928 fprintf (of, "volatile ");
1930 switch (DCL_TYPE (type))
1933 fprintf (of, "function ");
1936 if (DCL_PTR_CONST (type))
1937 fprintf (of, "const ");
1938 fprintf (of, "generic * ");
1941 if (DCL_PTR_CONST (type))
1942 fprintf (of, "const ");
1943 fprintf (of, "code * ");
1946 if (DCL_PTR_CONST (type))
1947 fprintf (of, "const ");
1948 fprintf (of, "xdata * ");
1951 if (DCL_PTR_CONST (type))
1952 fprintf (of, "const ");
1953 fprintf (of, "eeprom * ");
1957 if (DCL_PTR_CONST (type))
1958 fprintf (of, "const ");
1959 fprintf (of, "near *");
1962 if (DCL_PTR_CONST (type))
1963 fprintf (of, "const ");
1964 fprintf (of, "idata * ");
1967 if (DCL_PTR_CONST (type))
1968 fprintf (of, "const ");
1969 fprintf (of, "pdata * ");
1972 if (DCL_PTR_CONST (type))
1973 fprintf (of, "const ");
1974 fprintf (of, "unkown * ");
1977 fprintf (of, "[] ");
1983 switch (SPEC_SCLS(type))
1985 case S_DATA: fprintf (of, "data "); break;
1986 case S_XDATA: fprintf (of, "xdata "); break;
1987 case S_SFR: fprintf (of, "sfr "); break;
1988 case S_SBIT: fprintf (of, "sbit "); break;
1989 case S_CODE: fprintf (of, "code "); break;
1990 case S_IDATA: fprintf (of, "idata "); break;
1991 case S_PDATA: fprintf (of, "pdata "); break;
1992 case S_LITERAL: fprintf (of, "literal "); break;
1993 case S_STACK: fprintf (of, "stack "); break;
1994 case S_XSTACK: fprintf (of, "xstack "); break;
1995 case S_BIT: fprintf (of, "bit "); break;
1996 case S_EEPROM: fprintf (of, "eeprom "); break;
2000 if (SPEC_VOLATILE (type))
2001 fprintf (of, "volatile ");
2002 if (SPEC_USIGN (type))
2003 fprintf (of, "unsigned ");
2004 if (SPEC_CONST (type))
2005 fprintf (of, "const ");
2007 switch (SPEC_NOUN (type))
2011 fprintf (of, "long ");
2012 fprintf (of, "int");
2016 fprintf (of, "char");
2020 fprintf (of, "void");
2024 fprintf (of, "float");
2028 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2032 fprintf (of, "sbit");
2036 fprintf (of, "bit {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2040 fprintf (of, "double");
2044 fprintf (of, "unknown type");
2048 /* search entry in list before "type" */
2049 for (search = start; search && search->next != type;)
2050 search = search->next;
2059 /*-----------------------------------------------------------------*/
2060 /* cdbTypeInfo - print the type information for debugger */
2061 /*-----------------------------------------------------------------*/
2063 cdbTypeInfo (sym_link * type, FILE * of)
2065 fprintf (of, "{%d}", getSize (type));
2070 switch (DCL_TYPE (type))
2073 fprintf (of, "DF,");
2076 fprintf (of, "DG,");
2079 fprintf (of, "DC,");
2082 fprintf (of, "DX,");
2085 fprintf (of, "DD,");
2088 fprintf (of, "DI,");
2091 fprintf (of, "DP,");
2094 fprintf (of, "DA,");
2097 fprintf (of, "DA%d,", DCL_ELEM (type));
2105 switch (SPEC_NOUN (type))
2127 fprintf (of, "ST%s", SPEC_STRUCT (type)->tag);
2135 fprintf (of, "SB%d$%d", SPEC_BSTR (type), SPEC_BLEN (type));
2142 if (SPEC_USIGN (type))
2150 /*-----------------------------------------------------------------*/
2151 /* cdbSymbol - prints a symbol & its type information for debugger */
2152 /*-----------------------------------------------------------------*/
2154 cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc)
2166 fprintf (of, "S:"); /* symbol record */
2167 /* if this is not a structure symbol then
2168 we need to figure out the scope information */
2174 if (IS_STATIC (sym->etype))
2175 fprintf (of, "F%s$", moduleName); /* scope is file */
2177 fprintf (of, "G$"); /* scope is global */
2180 /* symbol is local */
2181 fprintf (of, "L%s$", (sym->localof ? sym->localof->name : "-null-"));
2184 fprintf (of, "S$"); /* scope is structure */
2186 /* print the name, & mangled name */
2187 fprintf (of, "%s$%d$%d(", sym->name,
2188 sym->level, sym->block);
2190 cdbTypeInfo (sym->type, of);
2193 /* print the address space */
2194 map = SPEC_OCLS (sym->etype);
2195 fprintf (of, "%c,%d,%d",
2196 (map ? map->dbName : 'Z'), sym->onStack, SPEC_STAK (sym->etype));
2198 /* if assigned to registers then output register names */
2199 /* if this is a function then print
2200 if is it an interrupt routine & interrupt number
2201 and the register bank it is using */
2203 fprintf (of, ",%d,%d,%d", FUNC_ISISR (sym->type),
2204 FUNC_INTNO (sym->type), FUNC_REGBANK (sym->type));
2205 /* alternate location to find this symbol @ : eg registers
2212 /*-----------------------------------------------------------------*/
2213 /* cdbStruct - print a structure for debugger */
2214 /*-----------------------------------------------------------------*/
2216 cdbStruct (structdef * sdef, int block, FILE * of,
2217 int inStruct, char *tag)
2222 /* if block # then must have function scope */
2223 fprintf (of, "F%s$", moduleName);
2224 fprintf (of, "%s[", (tag ? tag : sdef->tag));
2225 for (sym = sdef->fields; sym; sym = sym->next)
2227 fprintf (of, "({%d}", sym->offset);
2228 cdbSymbol (sym, of, TRUE, FALSE);
2236 /*------------------------------------------------------------------*/
2237 /* cdbStructBlock - calls struct printing for a blcks */
2238 /*------------------------------------------------------------------*/
2240 cdbStructBlock (int block, FILE * of)
2243 bucket **table = StructTab;
2247 /* go thru the entire table */
2248 for (i = 0; i < 256; i++)
2250 for (chain = table[i]; chain; chain = chain->next)
2252 if (chain->block >= block)
2254 cdbStruct ((structdef *) chain->sym, chain->block, of, 0, NULL);
2260 /*-----------------------------------------------------------------*/
2261 /* powof2 - returns power of two for the number if number is pow 2 */
2262 /*-----------------------------------------------------------------*/
2264 powof2 (unsigned long num)
2277 if (n1s > 1 || nshifts == 0)
2293 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2294 symbol *__muldiv[3][3][2];
2295 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2296 sym_link *__multypes[3][2];
2297 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2298 symbol *__conv[2][3][2];
2299 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2300 symbol *__rlrr[2][3][2];
2302 sym_link *floatType;
2305 _mangleFunctionName(char *in)
2307 if (port->getMangledFunctionName)
2309 return port->getMangledFunctionName(in);
2317 /*-----------------------------------------------------------------*/
2318 /* initCSupport - create functions for C support routines */
2319 /*-----------------------------------------------------------------*/
2323 const char *smuldivmod[] =
2327 const char *sbwd[] =
2329 "char", "int", "long"
2335 const char *srlrr[] =
2340 int bwd, su, muldivmod, tofrom, rlrr;
2342 if (getenv("SDCC_NO_C_SUPPORT")) {
2343 /* for debugging only */
2347 floatType = newFloatLink ();
2349 for (bwd = 0; bwd < 3; bwd++)
2366 __multypes[bwd][0] = l;
2367 __multypes[bwd][1] = copyLinkChain (l);
2368 SPEC_USIGN (__multypes[bwd][1]) = 1;
2371 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2372 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2373 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2374 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2375 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2376 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2377 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2378 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2379 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2380 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2382 for (tofrom = 0; tofrom < 2; tofrom++)
2384 for (bwd = 0; bwd < 3; bwd++)
2386 for (su = 0; su < 2; su++)
2390 sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]);
2391 __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], floatType, 1, options.float_rent);
2395 sprintf (buffer, "__%s%s2fs", ssu[su], sbwd[bwd]);
2396 __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), floatType, __multypes[bwd][su], 1, options.float_rent);
2402 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2404 for (bwd = 0; bwd < 3; bwd++)
2406 for (su = 0; su < 2; su++)
2408 sprintf (buffer, "_%s%s%s",
2409 smuldivmod[muldivmod],
2412 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2413 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2418 for (rlrr = 0; rlrr < 2; rlrr++)
2420 for (bwd = 0; bwd < 3; bwd++)
2422 for (su = 0; su < 2; su++)
2424 sprintf (buffer, "_%s%s%s",
2428 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2429 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;