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 -------------------------------------------------------------------------*/
29 value *aggregateToPointer (value *val);
30 void printTypeChainRaw (sym_link * start, FILE * of);
32 void printFromToType(sym_link *from, sym_link *to) {
33 fprintf (stderr, "from type '");
34 printTypeChain (from, stderr);
35 fprintf (stderr, "'\nto type '");
36 printTypeChain (to, stderr);
37 fprintf (stderr, "'\n");
41 char *nounName(sym_link *sl) {
42 switch (SPEC_NOUN(sl))
45 if (SPEC_LONG(sl)) return "long";
46 if (SPEC_SHORT(sl)) return "short";
49 case V_FLOAT: return "float";
50 case V_FIXED16X16: return "fixed16x16";
51 case V_CHAR: return "char";
52 case V_VOID: return "void";
53 case V_STRUCT: return "struct";
54 case V_LABEL: return "label";
55 case V_BITFIELD: return "bitfield";
56 case V_BIT: return "bit";
57 case V_SBIT: return "sbit";
58 case V_DOUBLE: return "double";
63 bucket *SymbolTab[256]; /* the symbol table */
64 bucket *StructTab[256]; /* the structure table */
65 bucket *TypedefTab[256]; /* the typedef table */
66 bucket *LabelTab[256]; /* the Label table */
67 bucket *enumTab[256]; /* enumerated table */
69 /*------------------------------------------------------------------*/
70 /* initSymt () - initialises symbol table related stuff */
71 /*------------------------------------------------------------------*/
77 for (i = 0; i < 256; i++)
78 SymbolTab[i] = StructTab[i] = (void *) NULL;
82 /*-----------------------------------------------------------------*/
83 /* newBucket - allocates & returns a new bucket */
84 /*-----------------------------------------------------------------*/
90 bp = Safe_alloc ( sizeof (bucket));
95 /*-----------------------------------------------------------------*/
96 /* hashKey - computes the hashkey given a symbol name */
97 /*-----------------------------------------------------------------*/
99 hashKey (const char *s)
101 unsigned long key = 0;
108 /*-----------------------------------------------------------------*/
109 /* addSym - adds a symbol to the hash Table */
110 /*-----------------------------------------------------------------*/
112 addSym (bucket ** stab,
119 int i; /* index into the hash Table */
120 bucket *bp; /* temp bucket * */
123 symbol *csym = (symbol *)sym;
125 if (getenv("DEBUG_SANITY")) {
126 fprintf (stderr, "addSym: %s ", sname);
128 /* make sure the type is complete and sane */
129 checkTypeSanity(csym->etype, csym->name);
132 /* prevent overflow of the (r)name buffers */
133 if (strlen(sname)>SDCC_SYMNAME_MAX) {
134 werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
135 sname[SDCC_SYMNAME_MAX]='\0';
138 /* the symbols are always added at the head of the list */
140 /* get a free entry */
141 bp = Safe_alloc ( sizeof (bucket));
143 bp->sym = sym; /* update the symbol pointer */
144 bp->level = level; /* update the nest level */
146 strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
148 /* if this is the first entry */
151 bp->prev = bp->next = (void *) NULL; /* point to nothing */
154 /* not first entry then add @ head of list */
164 /*-----------------------------------------------------------------*/
165 /* deleteSym - deletes a symbol from the hash Table entry */
166 /*-----------------------------------------------------------------*/
168 deleteSym (bucket ** stab, void *sym, char *sname)
176 /* find the symbol */
179 if (bp->sym == sym) /* found it then break out */
180 break; /* of the loop */
184 if (!bp) /* did not find it */
186 /* if this is the first one in the chain */
190 if (stab[i]) /* if chain ! empty */
191 stab[i]->prev = (void *) NULL;
193 /* middle || end of chain */
196 if (bp->next) /* if not end of chain */
197 bp->next->prev = bp->prev;
199 bp->prev->next = bp->next;
204 /*-----------------------------------------------------------------*/
205 /* findSym - finds a symbol in a table */
206 /*-----------------------------------------------------------------*/
208 findSym (bucket ** stab, void *sym, const char *sname)
212 bp = stab[hashKey (sname)];
215 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
220 return (bp ? bp->sym : (void *) NULL);
223 /*-----------------------------------------------------------------*/
224 /* findSymWithLevel - finds a symbol with a name & level */
225 /*-----------------------------------------------------------------*/
227 findSymWithLevel (bucket ** stab, symbol * sym)
231 bp = stab[hashKey (sym->name)];
234 ** do the search from the head of the list since the
235 ** elements are added at the head it is ensured that
236 ** we will find the deeper definitions before we find
237 ** the global ones. we need to check for symbols with
238 ** level <= to the level given, if levels match then block
239 ** numbers need to match as well
243 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
245 /* if this is parameter then nothing else need to be checked */
246 if (((symbol *) (bp->sym))->_isparm)
248 /* if levels match then block numbers should also match */
249 if (bp->level && bp->level == sym->level && bp->block == sym->block)
251 /* if levels don't match then we are okay */
252 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
254 /* if this is a global variable then we are ok too */
262 return (void *) NULL;
265 /*-----------------------------------------------------------------*/
266 /* findSymWithBlock - finds a symbol with name in with a block */
267 /*-----------------------------------------------------------------*/
269 findSymWithBlock (bucket ** stab, symbol * sym, int block)
273 bp = stab[hashKey (sym->name)];
276 if (strcmp (bp->name, sym->name) == 0 &&
282 return (bp ? bp->sym : (void *) NULL);
285 /*------------------------------------------------------------------*/
286 /* newSymbol () - returns a new pointer to a symbol */
287 /*------------------------------------------------------------------*/
289 newSymbol (char *name, int scope)
293 sym = Safe_alloc ( sizeof (symbol));
295 strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */
296 sym->level = scope; /* set the level */
297 sym->block = currBlockno;
298 sym->lineDef = mylineno; /* set the line number */
299 sym->fileDef = currFname;
303 /*------------------------------------------------------------------*/
304 /* newLink - creates a new link (declarator,specifier) */
305 /*------------------------------------------------------------------*/
307 newLink (SYM_LINK_CLASS select)
311 p = Safe_alloc ( sizeof (sym_link));
317 /*------------------------------------------------------------------*/
318 /* newStruct - creats a new structdef from the free list */
319 /*------------------------------------------------------------------*/
321 newStruct (char *tag)
325 s = Safe_alloc ( sizeof (structdef));
327 strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
331 /*------------------------------------------------------------------*/
332 /* sclsFromPtr - Return the storage class a pointer points into. */
333 /* S_FIXED is returned for generic pointers or other */
334 /* unexpected cases */
335 /*------------------------------------------------------------------*/
337 sclsFromPtr(sym_link *ptr)
339 switch (DCL_TYPE (ptr))
362 /*------------------------------------------------------------------*/
363 /* pointerTypes - do the computation for the pointer types */
364 /*------------------------------------------------------------------*/
366 pointerTypes (sym_link * ptr, sym_link * type)
371 /* find the first pointer type */
372 while (ptr && !IS_PTR (ptr))
375 /* could not find it */
376 if (!ptr || IS_SPEC (ptr))
379 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
380 pointerTypes (ptr->next, type);
384 /* change the pointer type depending on the
385 storage class of the type */
388 switch (SPEC_SCLS (type))
391 DCL_TYPE (ptr) = FPOINTER;
394 DCL_TYPE (ptr) = IPOINTER;
397 DCL_TYPE (ptr) = PPOINTER;
400 DCL_TYPE (ptr) = POINTER;
403 DCL_TYPE (ptr) = CPOINTER;
406 DCL_TYPE (ptr) = EEPPOINTER;
409 DCL_TYPE (ptr) = port->unqualified_pointer;
412 /* the storage class of type ends here */
413 SPEC_SCLS (type) = 0;
416 /* now change all the remaining unknown pointers
417 to generic pointers */
420 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
421 DCL_TYPE (ptr) = port->unqualified_pointer;
425 /* same for the type although it is highly unlikely that
426 type will have a pointer */
429 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
430 DCL_TYPE (type) = port->unqualified_pointer;
435 /*------------------------------------------------------------------*/
436 /* addDecl - adds a declarator @ the end of a chain */
437 /*------------------------------------------------------------------*/
439 addDecl (symbol * sym, int type, sym_link * p)
445 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
446 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
448 /* if we are passed a link then set head & tail */
457 head = tail = newLink (DECLARATOR);
458 DCL_TYPE (head) = type;
461 /* if this is the first entry */
469 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
471 sym->etype = mergeSpec (sym->etype, head, sym->name);
475 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
478 while (t->next != sym->etype)
481 tail->next = sym->etype;
485 sym->etype->next = head;
491 /* if the type is an unknown pointer and has
492 a tspec then take the storage class const & volatile
493 attribute from the tspec & make it those of this
497 //DCL_TYPE (p) == UPOINTER &&
500 if (!IS_SPEC (sym->etype))
502 sym->etype = sym->etype->next = newLink (SPECIFIER);
504 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
505 DCL_TSPEC (p) = NULL;
508 // if there is a function in this type chain
509 if (p && funcInChain(sym->type)) {
510 processFuncArgs (sym);
516 /*------------------------------------------------------------------
517 checkTypeSanity: prevent the user from doing e.g.:
519 ------------------------------------------------------------------*/
520 void checkTypeSanity(sym_link *etype, char *name) {
524 if (getenv("DEBUG_SANITY")) {
525 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
530 if (!IS_SPEC(etype)) {
531 if (getenv("DEBUG_SANITY")) {
532 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
537 noun=nounName(etype);
539 if (getenv("DEBUG_SANITY")) {
540 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
543 if ((SPEC_NOUN(etype)==V_CHAR ||
544 SPEC_NOUN(etype)==V_FLOAT ||
545 SPEC_NOUN(etype)==V_FIXED16X16 ||
546 SPEC_NOUN(etype)==V_DOUBLE ||
547 SPEC_NOUN(etype)==V_VOID) &&
548 (SPEC_SHORT(etype) || SPEC_LONG(etype))) {
549 // long or short for char float double or void
550 werror (E_LONG_OR_SHORT_INVALID, noun, name);
552 if ((SPEC_NOUN(etype)==V_FLOAT ||
553 SPEC_NOUN(etype)==V_FIXED16X16 ||
554 SPEC_NOUN(etype)==V_DOUBLE ||
555 SPEC_NOUN(etype)==V_VOID) &&
556 (etype->select.s.b_signed || SPEC_USIGN(etype))) {
557 // signed or unsigned for float double or void
558 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
561 // special case for "short"
562 if (SPEC_SHORT(etype)) {
563 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
564 SPEC_SHORT(etype) = 0;
568 "const a;" or "data b;" or "signed s" or "long l"
570 if (!SPEC_NOUN(etype)) {
571 SPEC_NOUN(etype)=V_INT;
574 /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
575 /* a "plain" int bitfield is unsigned */
576 if (SPEC_NOUN(etype)==V_BIT ||
577 SPEC_NOUN(etype)==V_SBIT) {
578 if (!etype->select.s.b_signed)
579 SPEC_USIGN(etype) = 1;
582 if (etype->select.s.b_signed && SPEC_USIGN(etype)) {
583 // signed AND unsigned
584 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
586 if (SPEC_SHORT(etype) && SPEC_LONG(etype)) {
588 werror (E_LONG_AND_SHORT_INVALID, noun, name);
593 /*------------------------------------------------------------------*/
594 /* mergeSpec - merges two specifiers and returns the new one */
595 /*------------------------------------------------------------------*/
597 mergeSpec (sym_link * dest, sym_link * src, char *name)
599 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
601 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
604 werror (E_SYNTAX_ERROR, yytext);
605 // the show must go on
610 if (SPEC_NOUN(src)) {
611 if (!SPEC_NOUN(dest)) {
612 SPEC_NOUN(dest)=SPEC_NOUN(src);
614 /* we shouldn't redeclare the type */
615 if (getenv("DEBUG_SANITY")) {
616 fprintf (stderr, "mergeSpec: ");
618 werror(E_TWO_OR_MORE_DATA_TYPES, name);
622 if (SPEC_SCLS(src)) {
623 /* if destination has no storage class */
624 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
625 SPEC_SCLS (dest) = SPEC_SCLS (src);
627 if (getenv("DEBUG_SANITY")) {
628 fprintf (stderr, "mergeSpec: ");
630 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
634 /* copy all the specifications */
636 // we really should do:
638 if (SPEC_what(src)) {
639 if (SPEC_what(dest)) {
640 werror(W_DUPLICATE_SPEC, "what");
642 SPEC_what(dst)|=SPEC_what(src);
645 // but there are more important thing right now
647 SPEC_LONG (dest) |= SPEC_LONG (src);
648 SPEC_SHORT(dest) |= SPEC_SHORT(src);
649 SPEC_USIGN (dest) |= SPEC_USIGN (src);
650 dest->select.s.b_signed|=src->select.s.b_signed;
651 SPEC_STAT (dest) |= SPEC_STAT (src);
652 SPEC_EXTR (dest) |= SPEC_EXTR (src);
653 SPEC_CONST(dest) |= SPEC_CONST (src);
654 SPEC_ABSA (dest) |= SPEC_ABSA (src);
655 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
656 SPEC_ADDR (dest) |= SPEC_ADDR (src);
657 SPEC_OCLS (dest) = SPEC_OCLS (src);
658 SPEC_BLEN (dest) |= SPEC_BLEN (src);
659 SPEC_BSTR (dest) |= SPEC_BSTR (src);
660 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
661 SPEC_ENUM (dest) |= SPEC_ENUM (src);
662 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
663 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
665 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
666 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
668 /* these are the only function attributes that will be set
669 in a specifier while parsing */
670 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
671 FUNC_BANKED(dest) |= FUNC_BANKED(src);
672 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
673 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
674 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
675 FUNC_ISISR(dest) |= FUNC_ISISR(src);
676 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
677 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
678 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
679 FUNC_INTNO(dest) |= FUNC_INTNO(src);
680 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
685 /*------------------------------------------------------------------*/
686 /* genSymName - generates and returns a name used for anonymous vars */
687 /*------------------------------------------------------------------*/
689 genSymName (int level)
691 static int gCount = 0;
692 static char gname[SDCC_NAME_MAX + 1];
694 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
698 /*------------------------------------------------------------------*/
699 /* getSpec - returns the specifier part from a declaration chain */
700 /*------------------------------------------------------------------*/
702 getSpec (sym_link * p)
707 while (p && !(IS_SPEC (p)))
713 /*------------------------------------------------------------------*/
714 /* newCharLink() - creates an char type */
715 /*------------------------------------------------------------------*/
721 p = newLink (SPECIFIER);
722 SPEC_NOUN (p) = V_CHAR;
727 /*------------------------------------------------------------------*/
728 /* newFloatLink - a new Float type */
729 /*------------------------------------------------------------------*/
735 p = newLink (SPECIFIER);
736 SPEC_NOUN (p) = V_FLOAT;
741 /*------------------------------------------------------------------*/
742 /* newFixed16x16Link - a new Float type */
743 /*------------------------------------------------------------------*/
749 p = newLink (SPECIFIER);
750 SPEC_NOUN (p) = V_FIXED16X16;
755 /*------------------------------------------------------------------*/
756 /* newLongLink() - new long type */
757 /*------------------------------------------------------------------*/
763 p = newLink (SPECIFIER);
764 SPEC_NOUN (p) = V_INT;
770 /*------------------------------------------------------------------*/
771 /* newIntLink() - creates an int type */
772 /*------------------------------------------------------------------*/
778 p = newLink (SPECIFIER);
779 SPEC_NOUN (p) = V_INT;
784 /*------------------------------------------------------------------*/
785 /* newBoolLink() - creates an bool type */
786 /*------------------------------------------------------------------*/
792 p = newLink (SPECIFIER);
793 SPEC_NOUN (p) = V_BIT;
798 /*------------------------------------------------------------------*/
799 /* getSize - returns size of a type chain in bytes */
800 /*------------------------------------------------------------------*/
802 getSize (sym_link * p)
804 /* if nothing return 0 */
808 { /* if this is the specifier then */
809 switch (SPEC_NOUN (p))
810 { /* depending on the specifier type */
812 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
822 return SPEC_STRUCT (p)->size;
829 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
835 /* this is a declarator */
836 switch (DCL_TYPE (p))
840 return DCL_ELEM (p) * getSize (p->next);
842 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
843 // "can not tell the size of an array[]");
854 return (IFFUNC_BANKED (p) ? GPTRSIZE : FPTRSIZE);
863 /*------------------------------------------------------------------*/
864 /* checkStructFlexArray - check tree behind a struct */
865 /*------------------------------------------------------------------*/
867 checkStructFlexArray (symbol *sym, sym_link *p)
869 /* if nothing return FALSE */
875 /* (nested) struct with flexible array member? */
876 if (IS_STRUCT (p) && SPEC_STRUCT (p)->b_flexArrayMember)
878 werror (W_INVALID_FLEXARRAY);
884 /* this is a declarator */
887 /* flexible array member? */
890 if (!options.std_c99)
891 werror (W_C89_NO_FLEXARRAY);
895 return checkStructFlexArray (sym, p->next);
900 /*------------------------------------------------------------------*/
901 /* bitsForType - returns # of bits required to store this type */
902 /*------------------------------------------------------------------*/
904 bitsForType (sym_link * p)
906 /* if nothing return 0 */
911 { /* if this is the specifier then */
913 switch (SPEC_NOUN (p))
914 { /* depending on the specifier type */
916 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
918 return FLOATSIZE * 8;
926 return SPEC_STRUCT (p)->size * 8;
933 return SPEC_BLEN (p);
939 /* this is a specifier */
940 switch (DCL_TYPE (p))
943 return DCL_ELEM (p) * getSize (p->next) * 8;
947 return (PTRSIZE * 8);
952 return (FPTRSIZE * 8);
954 return (GPTRSIZE * 8);
961 /*------------------------------------------------------------------*/
962 /* copySymbolChain - copies a symbol chain */
963 /*------------------------------------------------------------------*/
965 copySymbolChain (symbol * src)
972 dest = copySymbol (src);
973 dest->next = copySymbolChain (src->next);
977 /*------------------------------------------------------------------*/
978 /* copySymbol - makes a copy of a symbol */
979 /*------------------------------------------------------------------*/
981 copySymbol (symbol * src)
988 dest = newSymbol (src->name, src->level);
989 memcpy (dest, src, sizeof (symbol));
990 dest->level = src->level;
991 dest->block = src->block;
992 dest->ival = copyIlist (src->ival);
993 dest->type = copyLinkChain (src->type);
994 dest->etype = getSpec (dest->type);
996 dest->key = src->key;
997 dest->allocreq = src->allocreq;
1001 /*------------------------------------------------------------------*/
1002 /* reverseSyms - reverses the links for a symbol chain */
1003 /*------------------------------------------------------------------*/
1005 reverseSyms (symbol * sym)
1007 symbol *prev, *curr, *next;
1022 sym->next = (void *) NULL;
1026 /*------------------------------------------------------------------*/
1027 /* reverseLink - reverses the links for a type chain */
1028 /*------------------------------------------------------------------*/
1030 reverseLink (sym_link * type)
1032 sym_link *prev, *curr, *next;
1047 type->next = (void *) NULL;
1051 /*------------------------------------------------------------------*/
1052 /* addSymChain - adds a symbol chain to the symboltable */
1053 /*------------------------------------------------------------------*/
1055 addSymChain (symbol ** symHead)
1057 symbol *sym = *symHead;
1058 symbol *csym = NULL;
1062 for (; sym != NULL; sym = sym->next)
1064 changePointer(sym->type);
1065 checkTypeSanity(sym->etype, sym->name);
1067 if (!sym->level && !(IS_SPEC(sym->etype) && IS_TYPEDEF(sym->etype)))
1070 /* if already exists in the symbol table then check if
1071 one of them is an extern definition if yes then
1072 then check if the type match, if the types match then
1073 delete the current entry and add the new entry */
1074 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
1075 csym->level == sym->level) {
1077 /* If the previous definition was for an array with incomplete */
1078 /* type, and the new definition has completed the type, update */
1079 /* the original type to match */
1080 if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY
1081 && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY)
1083 if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type))
1084 DCL_ELEM(csym->type) = DCL_ELEM(sym->type);
1088 /* If only one of the definitions used the "at" keyword, copy */
1089 /* the address to the other. */
1090 if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype)
1091 && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype))
1093 SPEC_ABSA (sym->etype) = 1;
1094 SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype);
1096 if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype)
1097 && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype))
1099 SPEC_ABSA (csym->etype) = 1;
1100 SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype);
1105 if (csym->ival && sym->ival)
1107 if (compareTypeExact (csym->type, sym->type, sym->level) != 1)
1111 /* one definition extern ? */
1112 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype))
1113 werror (E_EXTERN_MISMATCH, sym->name);
1115 werror (E_DUPLICATE, sym->name);
1116 werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF);
1118 fprintf (stderr, "from type '");
1119 printTypeChain (csym->type, stderr);
1120 if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype))
1121 fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype));
1122 fprintf (stderr, "'\nto type '");
1123 printTypeChain (sym->type, stderr);
1124 if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype))
1125 fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype));
1126 fprintf (stderr, "'\n");
1131 if (csym->ival && !sym->ival)
1132 sym->ival = csym->ival;
1134 /* delete current entry */
1135 deleteSym (SymbolTab, csym, csym->name);
1136 deleteFromSeg(csym);
1138 symPtrPtr = symHead;
1139 while (*symPtrPtr && *symPtrPtr != csym)
1140 symPtrPtr = &(*symPtrPtr)->next;
1141 if (*symPtrPtr == csym)
1142 *symPtrPtr = csym->next;
1147 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1152 /*------------------------------------------------------------------*/
1153 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
1154 /*------------------------------------------------------------------*/
1156 funcInChain (sym_link * lnk)
1167 /*------------------------------------------------------------------*/
1168 /* structElemType - returns the type info of a struct member */
1169 /*------------------------------------------------------------------*/
1171 structElemType (sym_link * stype, value * id)
1173 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1174 sym_link *type, *etype;
1175 sym_link *petype = getSpec (stype);
1179 /* look for the id */
1182 if (strcmp (fields->rname, id->name) == 0)
1184 type = copyLinkChain (fields->type);
1185 etype = getSpec (type);
1186 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1187 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1189 SPEC_CONST (type) |= SPEC_CONST (stype);
1191 DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1194 fields = fields->next;
1198 werror (E_NOT_MEMBER, id->name);
1200 // the show must go on
1201 return newIntLink();
1204 /*------------------------------------------------------------------*/
1205 /* getStructElement - returns element of a tructure definition */
1206 /*------------------------------------------------------------------*/
1208 getStructElement (structdef * sdef, symbol * sym)
1212 for (field = sdef->fields; field; field = field->next)
1213 if (strcmp (field->name, sym->name) == 0)
1216 werror (E_NOT_MEMBER, sym->name);
1218 return sdef->fields;
1221 /*------------------------------------------------------------------*/
1222 /* compStructSize - computes the size of a structure */
1223 /*------------------------------------------------------------------*/
1225 compStructSize (int su, structdef * sdef)
1227 int sum = 0, usum = 0;
1231 /* for the identifiers */
1232 loop = sdef->fields;
1235 /* create the internal name for this variable */
1236 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1241 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1243 /* if this is a bit field */
1246 /* change it to a unsigned bit */
1247 SPEC_NOUN (loop->etype) = V_BITFIELD;
1248 /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
1249 /* a "plain" int bitfield is unsigned */
1250 if (!loop->etype->select.s.b_signed)
1251 SPEC_USIGN(loop->etype) = 1;
1253 SPEC_BLEN (loop->etype) = loop->bitVar;
1255 if (loop->bitVar == BITVAR_PAD) {
1256 /* A zero length bitfield forces padding */
1257 SPEC_BSTR (loop->etype) = bitOffset;
1258 SPEC_BLEN (loop->etype) = 0;
1263 if (bitOffset == 8) {
1267 /* check if this fit into the remaining */
1268 /* bits of this byte else align it to the */
1269 /* next byte boundary */
1270 if (loop->bitVar <= (8 - bitOffset)) {
1271 /* fits into current byte */
1273 SPEC_BSTR (loop->etype) = bitOffset;
1274 bitOffset += loop->bitVar;
1276 else if (!bitOffset) {
1277 /* does not fit, but is already byte aligned */
1279 SPEC_BSTR (loop->etype) = bitOffset;
1280 bitOffset += loop->bitVar;
1283 /* does not fit; need to realign first */
1285 loop->offset = (su == UNION ? sum = 0 : sum);
1287 SPEC_BSTR (loop->etype) = bitOffset;
1288 bitOffset += loop->bitVar;
1290 while (bitOffset>8) {
1297 /* This is a non-bit field. Make sure we are */
1298 /* byte aligned first */
1301 loop->offset = (su == UNION ? sum = 0 : sum);
1305 checkDecl (loop, 1);
1306 sum += getSize (loop->type);
1308 /* search for "flexibel array members" */
1309 /* and do some syntax checks */
1311 && checkStructFlexArray (loop, loop->type))
1313 /* found a "flexible array member" */
1314 sdef->b_flexArrayMember = TRUE;
1315 /* is another struct-member following? */
1317 werror (E_FLEXARRAY_NOTATEND);
1318 /* is it the first struct-member? */
1319 else if (loop == sdef->fields)
1320 werror (E_FLEXARRAY_INEMPTYSTRCT);
1326 /* if union then size = sizeof largest field */
1328 /* For UNION, round up after each field */
1329 sum += ((bitOffset+7)/8);
1330 usum = max (usum, sum);
1335 /* For STRUCT, round up after all fields processed */
1337 sum += ((bitOffset+7)/8);
1339 return (su == UNION ? usum : sum);
1342 /*-------------------------------------------------------------------*/
1343 /* promoteAnonStructs - promote anonymous struct/union's fields into */
1344 /* an enclosing struct/union */
1345 /*-------------------------------------------------------------------*/
1347 promoteAnonStructs (int su, structdef * sdef)
1356 tofield = &sdef->fields;
1357 field = sdef->fields;
1360 nextfield = field->next;
1361 if (!*field->name && IS_STRUCT (field->type))
1363 /* Found an anonymous struct/union. Replace it */
1364 /* with the fields it contains and adjust all */
1367 base = field->offset;
1368 subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields);
1370 continue; /* just in case it's empty */
1372 *tofield = subfield;
1375 /* check for field name conflicts resulting from promotion */
1376 dupfield = sdef->fields;
1377 while (dupfield && dupfield != subfield)
1379 if (*subfield->name && !strcmp (dupfield->name, subfield->name))
1381 werrorfl (subfield->fileDef, subfield->lineDef,
1383 su==STRUCT ? "struct" : "union",
1385 werrorfl (dupfield->fileDef, dupfield->lineDef,
1388 dupfield = dupfield->next;
1391 subfield->offset += base;
1393 subfield = subfield->next;
1397 subfield->next = nextfield;
1398 tofield = &subfield->next;
1401 tofield = &field->next;
1407 /*------------------------------------------------------------------*/
1408 /* checkSClass - check the storage class specification */
1409 /*------------------------------------------------------------------*/
1411 checkSClass (symbol * sym, int isProto)
1415 if (getenv("DEBUG_SANITY")) {
1416 fprintf (stderr, "checkSClass: %s \n", sym->name);
1419 /* type is literal can happen for enums change
1421 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1422 SPEC_SCLS (sym->etype) = S_AUTO;
1424 /* if sfr or sbit then must also be volatile */
1425 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1426 SPEC_SCLS (sym->etype) == S_SFR)
1428 SPEC_VOLATILE (sym->etype) = 1;
1431 /* if absolute address given then it mark it as
1432 volatile -- except in the PIC port */
1434 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1435 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1436 if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1439 if (IS_ABSOLUTE (sym->etype))
1440 SPEC_VOLATILE (sym->etype) = 1;
1442 if (TARGET_IS_MCS51 &&
1443 IS_ABSOLUTE (sym->etype) &&
1444 SPEC_SCLS (sym->etype) == S_SFR)
1449 if (SPEC_NOUN (sym->etype) == V_CHAR)
1451 else if (SPEC_LONG (sym->etype) == 0)
1456 addr = SPEC_ADDR (sym->etype);
1457 for (n=0; n<size; n+=8)
1458 if (((addr >> n) & 0xFF) < 0x80)
1459 werror (W_SFR_ABSRANGE, sym->name);
1462 /* If code memory is read only, then pointers to code memory */
1463 /* implicitly point to constants -- make this explicit */
1465 while (t && t->next) {
1466 if (IS_CODEPTR(t) && port->mem.code_ro) {
1467 if (IS_SPEC(t->next)) {
1468 SPEC_CONST (t->next) = 1;
1470 DCL_PTR_CONST (t->next) = 1;
1476 /* global variables declared const put into code */
1477 /* if no other storage class specified */
1478 if (sym->level == 0 &&
1479 SPEC_SCLS(sym->etype) == S_FIXED &&
1480 !IS_FUNC(sym->type)) {
1481 /* find the first non-array link */
1485 if (IS_CONSTANT (t)) {
1486 SPEC_SCLS (sym->etype) = S_CODE;
1490 /* global variable in code space is a constant */
1491 if (sym->level == 0 &&
1492 SPEC_SCLS (sym->etype) == S_CODE &&
1493 port->mem.code_ro) {
1494 /* find the first non-array link */
1501 DCL_PTR_CONST (t) = 1;
1505 /* if bit variable then no storage class can be */
1506 /* specified since bit is already a storage */
1507 if (IS_BITVAR (sym->etype) &&
1508 (SPEC_SCLS (sym->etype) != S_FIXED &&
1509 SPEC_SCLS (sym->etype) != S_SBIT &&
1510 SPEC_SCLS (sym->etype) != S_BIT)
1513 werror (E_BITVAR_STORAGE, sym->name);
1514 SPEC_SCLS (sym->etype) = S_FIXED;
1517 /* extern variables cannot be initialized */
1518 if (IS_EXTERN (sym->etype) && sym->ival)
1520 werror (E_EXTERN_INIT, sym->name);
1524 /* if this is an automatic symbol */
1525 if (sym->level && (options.stackAuto || reentrant)) {
1526 if (SPEC_SCLS (sym->etype) != S_BIT) {
1527 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1528 SPEC_SCLS (sym->etype) == S_FIXED ||
1529 SPEC_SCLS (sym->etype) == S_REGISTER ||
1530 SPEC_SCLS (sym->etype) == S_STACK ||
1531 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1532 SPEC_SCLS (sym->etype) = S_AUTO;
1534 /* storage class may only be specified for statics */
1535 if (!IS_STATIC(sym->etype)) {
1536 werror (E_AUTO_ASSUMED, sym->name);
1542 /* automatic symbols cannot be given */
1543 /* an absolute address ignore it */
1545 SPEC_ABSA (sym->etype) &&
1546 (options.stackAuto || reentrant))
1548 werror (E_AUTO_ABSA, sym->name);
1549 SPEC_ABSA (sym->etype) = 0;
1552 /* arrays & pointers cannot be defined for bits */
1553 /* SBITS or SFRs or BIT */
1554 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1555 !IS_FUNCPTR (sym->type) &&
1556 (SPEC_NOUN (sym->etype) == V_BIT ||
1557 SPEC_NOUN (sym->etype) == V_SBIT ||
1558 SPEC_NOUN (sym->etype) == V_BITFIELD ||
1559 SPEC_SCLS (sym->etype) == S_SFR))
1560 werror (E_BIT_ARRAY, sym->name);
1562 /* if this is a bit|sbit then set length & start */
1563 if (SPEC_NOUN (sym->etype) == V_BIT ||
1564 SPEC_NOUN (sym->etype) == V_SBIT)
1566 SPEC_BLEN (sym->etype) = 1;
1567 SPEC_BSTR (sym->etype) = 0;
1571 /* variables declared in CODE space must have */
1572 /* initializers if not an extern */
1573 if (SPEC_SCLS (sym->etype) == S_CODE &&
1574 sym->ival == NULL &&
1577 port->mem.code_ro &&
1578 !IS_EXTERN (sym->etype) &&
1579 !funcInChain (sym->type))
1580 werror (E_CODE_NO_INIT, sym->name);
1583 /* if parameter or local variable then change */
1584 /* the storage class to reflect where the var will go */
1585 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED
1586 && !IS_STATIC(sym->etype)
1589 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1591 SPEC_SCLS (sym->etype) = (options.useXstack ?
1592 S_XSTACK : S_STACK);
1596 /* hack-o-matic! I see no reason why the useXstack option should ever
1597 * control this allocation, but the code was originally that way, and
1598 * changing it for non-390 ports breaks the compiler badly.
1600 bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1601 1 : options.useXstack;
1602 SPEC_SCLS (sym->etype) = (useXdata ?
1608 /*------------------------------------------------------------------*/
1609 /* changePointer - change pointer to functions */
1610 /*------------------------------------------------------------------*/
1612 changePointer (sym_link * p)
1615 /* go thru the chain of declarations */
1616 /* if we find a pointer to a function */
1617 /* change it to a ptr to code area */
1618 /* unless the function is banked. */
1619 for (; p; p = p->next)
1621 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1622 DCL_TYPE (p) = port->unqualified_pointer;
1623 if (IS_PTR (p) && IS_FUNC (p->next))
1624 if (!IFFUNC_BANKED(p->next))
1625 DCL_TYPE (p) = CPOINTER;
1629 /*------------------------------------------------------------------*/
1630 /* checkDecl - does semantic validation of a declaration */
1631 /*------------------------------------------------------------------*/
1633 checkDecl (symbol * sym, int isProto)
1636 checkSClass (sym, isProto); /* check the storage class */
1637 changePointer (sym->type); /* change pointers if required */
1639 /* if this is an array without any dimension
1640 then update the dimension from the initial value */
1641 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1642 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1647 /*------------------------------------------------------------------*/
1648 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1649 /*------------------------------------------------------------------*/
1651 copyLinkChain (sym_link * p)
1653 sym_link *head, *curr, *loop;
1655 /* note: v_struct and v_struct->fields are not copied! */
1657 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1660 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1661 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1669 /*------------------------------------------------------------------*/
1670 /* cleanUpBlock - cleansup the symbol table specified for all the */
1671 /* symbols in the given block */
1672 /*------------------------------------------------------------------*/
1674 cleanUpBlock (bucket ** table, int block)
1679 /* go thru the entire table */
1680 for (i = 0; i < 256; i++)
1682 for (chain = table[i]; chain; chain = chain->next)
1684 if (chain->block >= block)
1686 deleteSym (table, chain->sym, chain->name);
1692 /*------------------------------------------------------------------*/
1693 /* cleanUpLevel - cleansup the symbol table specified for all the */
1694 /* symbols in the given level */
1695 /*------------------------------------------------------------------*/
1697 cleanUpLevel (bucket ** table, int level)
1702 /* go thru the entire table */
1703 for (i = 0; i < 256; i++)
1705 for (chain = table[i]; chain; chain = chain->next)
1707 if (chain->level >= level)
1709 deleteSym (table, chain->sym, chain->name);
1715 /*------------------------------------------------------------------*/
1716 /* computeTypeOr - computes the resultant type from two types */
1717 /*------------------------------------------------------------------*/
1719 computeTypeOr (sym_link * etype1, sym_link * etype2, sym_link * reType)
1722 assert ( (IS_CHAR (etype1) || IS_BIT (etype1))
1723 && (IS_CHAR (etype2) || IS_BIT (etype2)));
1725 if (SPEC_USIGN (etype1) == SPEC_USIGN (etype2))
1727 SPEC_USIGN (reType) = SPEC_USIGN (etype1);
1731 if (SPEC_USIGN (etype1))
1733 if ( IS_LITERAL (etype2)
1734 && floatFromVal (valFromType (etype2)) >= 0)
1735 SPEC_USIGN (reType) = 1;
1738 /* promote to int */
1739 SPEC_USIGN (reType) = 0;
1740 SPEC_NOUN (reType) = V_INT;
1743 else /* etype1 signed */
1745 if ( IS_LITERAL (etype2)
1746 && floatFromVal (valFromType (etype2)) <= 127)
1747 SPEC_USIGN (reType) = 0;
1750 /* promote to int */
1751 SPEC_USIGN (reType) = 0;
1752 SPEC_NOUN (reType) = V_INT;
1756 if (SPEC_USIGN (etype2))
1758 if ( IS_LITERAL (etype1)
1759 && floatFromVal (valFromType (etype1)) >= 0)
1760 SPEC_USIGN (reType) = 1;
1763 /* promote to int */
1764 SPEC_USIGN (reType) = 0;
1765 SPEC_NOUN (reType) = V_INT;
1768 else /* etype2 signed */
1770 if ( IS_LITERAL (etype1)
1771 && floatFromVal (valFromType (etype1)) <= 127)
1772 SPEC_USIGN (reType) = 0;
1775 /* promote to int */
1776 SPEC_USIGN (reType) = 0;
1777 SPEC_NOUN (reType) = V_INT;
1783 /*------------------------------------------------------------------*/
1784 /* computeType - computes the resultant type from two types */
1785 /*------------------------------------------------------------------*/
1787 computeType (sym_link * type1, sym_link * type2,
1788 RESULT_TYPE resultType, int op)
1792 sym_link *etype1 = getSpec (type1);
1795 etype2 = type2 ? getSpec (type2) : type1;
1797 /* if one of them is a float then result is a float */
1798 /* here we assume that the types passed are okay */
1799 /* and can be cast to one another */
1800 /* which ever is greater in size */
1801 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1802 rType = newFloatLink ();
1803 /* if both are fixed16x16 then result is float */
1804 else if (IS_FIXED16X16(etype1) && IS_FIXED16X16(etype2))
1805 rType = newFixed16x16Link();
1806 else if (IS_FIXED16X16(etype1) && IS_FLOAT (etype2))
1807 rType = newFloatLink ();
1808 else if (IS_FLOAT (etype1) && IS_FIXED16X16 (etype2) )
1809 rType = newFloatLink ();
1811 /* if both are bitvars choose the larger one */
1812 else if (IS_BITVAR (etype1) && IS_BITVAR (etype2))
1813 rType = SPEC_BLEN (etype1) >= SPEC_BLEN (etype2) ?
1814 copyLinkChain (type1) : copyLinkChain (type1);
1816 /* if only one of them is a bit variable then the other one prevails */
1817 else if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1819 rType = copyLinkChain (type2);
1820 /* bitfield can have up to 16 bits */
1821 if (getSize (etype1) > 1)
1822 SPEC_NOUN (getSpec (rType)) = V_INT;
1824 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1826 rType = copyLinkChain (type1);
1827 /* bitfield can have up to 16 bits */
1828 if (getSize (etype2) > 1)
1829 SPEC_NOUN (getSpec (rType)) = V_INT;
1831 /* if one of them is a pointer or array then that
1833 else if (IS_PTR (type1) || IS_ARRAY (type1))
1834 rType = copyLinkChain (type1);
1835 else if (IS_PTR (type2) || IS_ARRAY (type2))
1836 rType = copyLinkChain (type2);
1837 else if (getSize (type1) > getSize (type2))
1838 rType = copyLinkChain (type1);
1840 rType = copyLinkChain (type2);
1842 reType = getSpec (rType);
1844 /* avoid conflicting types */
1845 reType->select.s.b_signed = 0;
1847 /* if result is a literal then make not so */
1848 if (IS_LITERAL (reType))
1849 SPEC_SCLS (reType) = S_REGISTER;
1853 case RESULT_TYPE_CHAR:
1854 if (IS_BITVAR (reType))
1856 SPEC_NOUN (reType) = V_CHAR;
1857 SPEC_SCLS (reType) = 0;
1858 SPEC_USIGN (reType) = 0;
1862 case RESULT_TYPE_INT:
1863 case RESULT_TYPE_NONE:
1864 case RESULT_TYPE_OTHER:
1865 if (IS_BIT (reType))
1867 SPEC_NOUN (reType) = V_CHAR;
1868 SPEC_SCLS (reType) = 0;
1869 SPEC_USIGN (reType) = 0;
1872 else if (IS_BITFIELD (reType))
1874 /* could be smarter, but it depends on the op */
1875 /* this is for the worst case: a multiplication of 4 * 4 bit */
1876 SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT;
1877 SPEC_SCLS (reType) = 0;
1878 SPEC_USIGN (reType) = 0;
1881 else if (IS_CHAR (reType))
1883 /* promotion of some special cases */
1888 return computeTypeOr (etype1, etype2, reType);
1890 if (SPEC_USIGN (etype1) != SPEC_USIGN (etype2))
1892 SPEC_USIGN (reType) = 1;
1897 SPEC_NOUN (reType) = V_INT;
1898 SPEC_USIGN (reType) = 0;
1901 /* if both are unsigned char then no promotion required */
1902 if (!(SPEC_USIGN (etype1) && SPEC_USIGN (etype2)))
1904 SPEC_NOUN (reType) = V_INT;
1905 SPEC_USIGN (reType) = 0;
1918 /* SDCC's sign promotion:
1919 - if one or both operands are unsigned, the resultant type will be unsigned
1920 (except char, see below)
1921 - if an operand is promoted to a larger type (char -> int, int -> long),
1922 the larger type will be signed
1924 SDCC tries hard to avoid promotion to int and does 8 bit calculation as
1925 much as possible. We're leaving ISO IEC 9899 here and have to extrapolate
1926 the standard. The standard demands, that the result has to be the same
1927 "as if" the promotion would have been performed:
1929 - if the result of an operation with two char's is promoted to a
1930 larger type, the result will be signed.
1932 More sophisticated are these:
1933 - if the result of an operation with two char's is a char again,
1934 the result will only then be unsigned, if both operands are
1935 unsigned. In all other cases the result will be signed.
1937 This seems to be contradictionary to the first two rules, but it makes
1938 real sense (all types are char's):
1940 A signed char can be negative; this must be preserved in the result
1943 Only if both operands are unsigned it's safe to make the result
1944 unsigned; this helps to avoid overflow:
1947 - ToDo: document '|', '^' and '&'
1949 Homework: - why is (200 * 200 < 0) true?
1950 - why is { char l = 200, r = 200; (r * l > 0) } true?
1953 if (!IS_FLOAT (reType)
1954 && ( (SPEC_USIGN (etype1)
1955 /* if this operand is promoted to a larger type,
1956 then it will be promoted to a signed type */
1957 && !(getSize (etype1) < getSize (reType))
1958 /* char require special handling */
1959 && !IS_CHAR (etype1))
1960 || /* same for 2nd operand */
1961 (SPEC_USIGN (etype2)
1962 && !(getSize (etype2) < getSize (reType))
1963 && !IS_CHAR (etype2))
1964 || /* if both are 'unsigned char' and not promoted
1965 let the result be unsigned too */
1966 ( SPEC_USIGN (etype1)
1967 && SPEC_USIGN (etype2)
1970 && IS_CHAR (reType))))
1971 SPEC_USIGN (reType) = 1;
1973 SPEC_USIGN (reType) = 0;
1978 /*--------------------------------------------------------------------*/
1979 /* compareType - will do type check return 1 if match, -1 if castable */
1980 /*--------------------------------------------------------------------*/
1982 compareType (sym_link * dest, sym_link * src)
1993 /* if dest is a declarator then */
1998 /* banked function pointer */
1999 if (IS_GENPTR (dest) && IS_GENPTR (src))
2001 if (IS_FUNC (src->next) && IS_VOID(dest->next))
2003 if (IS_FUNC (dest->next) && IS_VOID(src->next))
2005 return compareType (dest->next, src->next);
2008 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2010 //checkFunction(src,dest);
2012 return compareType (dest->next, src->next);
2014 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
2018 (IS_GENPTR (dest) ||
2019 ((DCL_TYPE(src) == POINTER) && (DCL_TYPE(dest) == IPOINTER))
2022 if (IS_PTR (dest) && IS_ARRAY (src)) {
2023 value *val=aggregateToPointer (valFromType(src));
2024 int res=compareType (dest, val->type);
2025 Safe_free(val->type);
2029 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
2030 return compareType (dest->next, src);
2033 else if (IS_PTR (dest) && IS_INTEGRAL (src))
2039 /* if one is a specifier and the other is not */
2040 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2041 (IS_SPEC (dest) && !IS_SPEC (src)))
2044 /* if one of them is a void then ok */
2045 if (SPEC_NOUN (dest) == V_VOID &&
2046 SPEC_NOUN (src) != V_VOID)
2049 if (SPEC_NOUN (dest) != V_VOID &&
2050 SPEC_NOUN (src) == V_VOID)
2053 /* if they are both bitfields then if the lengths
2054 and starts don't match */
2055 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2056 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2057 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2060 /* it is a specifier */
2061 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2063 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
2064 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
2066 bitsForType (dest) == bitsForType (src))
2067 instead of the next two lines, but the regression tests fail with
2068 them; I guess it's a problem with replaceCheaperOp */
2069 getSize (dest) == getSize (src) &&
2070 !(!IS_BIT (dest) && IS_BIT (src)))
2072 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
2077 else if (IS_STRUCT (dest))
2079 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2084 if (SPEC_LONG (dest) != SPEC_LONG (src))
2087 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2093 /*--------------------------------------------------------------------*/
2094 /* compareTypeExact - will do type check return 1 if match exactly */
2095 /*--------------------------------------------------------------------*/
2097 compareTypeExact (sym_link * dest, sym_link * src, int level)
2099 STORAGE_CLASS srcScls, destScls;
2110 /* if dest is a declarator then */
2115 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2116 if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
2118 if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
2120 if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
2124 value *exargs, *acargs, *checkValue;
2126 /* verify function return type */
2127 if (!compareTypeExact (dest->next, src->next, -1))
2129 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
2131 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
2133 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
2136 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
2140 /* compare expected args with actual args */
2141 exargs = FUNC_ARGS(dest);
2142 acargs = FUNC_ARGS(src);
2144 /* for all the expected args do */
2145 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
2147 //checkTypeSanity(acargs->etype, acargs->name);
2149 if (IS_AGGREGATE (acargs->type))
2151 checkValue = copyValue (acargs);
2152 aggregateToPointer (checkValue);
2155 checkValue = acargs;
2158 if (!compareTypeExact (exargs->type, checkValue->type, -1))
2163 /* if one them ended we have a problem */
2164 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2165 (!exargs && acargs && !IS_VOID (acargs->type)))
2169 return compareTypeExact (dest->next, src->next, level);
2176 /* if one is a specifier and the other is not */
2177 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2178 (IS_SPEC (dest) && !IS_SPEC (src)))
2181 /* if one of them is a void then ok */
2182 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2185 /* if they are both bitfields then if the lengths
2186 and starts don't match */
2187 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2188 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2189 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2192 if (IS_INTEGRAL (dest))
2194 /* signedness must match */
2195 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2197 /* size must match */
2198 if (SPEC_LONG (dest) != SPEC_LONG (src))
2200 if (SPEC_SHORT (dest) != SPEC_SHORT (src))
2204 if (IS_STRUCT (dest))
2206 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2210 if (SPEC_CONST (dest) != SPEC_CONST (src))
2212 if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
2214 if (SPEC_STAT (dest) != SPEC_STAT (src))
2216 if (SPEC_ABSA (dest) != SPEC_ABSA (src))
2218 if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
2221 destScls = SPEC_SCLS (dest);
2222 srcScls = SPEC_SCLS (src);
2224 /* Compensate for const to const code change in checkSClass() */
2225 if (!level & port->mem.code_ro && SPEC_CONST (dest))
2227 if (srcScls == S_CODE && destScls == S_FIXED)
2229 if (destScls == S_CODE && srcScls == S_FIXED)
2233 /* compensate for allocGlobal() */
2234 if ((srcScls == S_FIXED || srcScls == S_AUTO)
2235 && port->mem.default_globl_map == xdata
2239 if (level>0 && !SPEC_STAT (dest))
2241 /* Compensate for hack-o-matic in checkSClass() */
2242 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
2244 if (destScls == S_FIXED)
2245 destScls = (options.useXstack ? S_XSTACK : S_STACK);
2246 if (srcScls == S_FIXED)
2247 srcScls = (options.useXstack ? S_XSTACK : S_STACK);
2249 else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
2251 if (destScls == S_FIXED)
2253 if (srcScls == S_FIXED)
2258 if (srcScls != destScls)
2261 printf ("level = %d\n", level);
2262 printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
2263 SPEC_SCLS (src), SPEC_SCLS (dest));
2264 printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
2272 /*------------------------------------------------------------------*/
2273 /* inCalleeSaveList - return 1 if found in callee save list */
2274 /*------------------------------------------------------------------*/
2276 calleeCmp(void *p1, void *p2)
2278 return (strcmp((char *)p1, (char *)(p2)) == 0);
2282 inCalleeSaveList(char *s)
2284 if (options.all_callee_saves)
2286 return isinSetWith(options.calleeSavesSet, s, calleeCmp);
2289 /*-----------------------------------------------------------------*/
2290 /* aggregateToPointer: change an agggregate type function */
2291 /* argument to a pointer to that type. */
2292 /*-----------------------------------------------------------------*/
2294 aggregateToPointer (value * val)
2296 if (IS_AGGREGATE (val->type))
2298 /* if this is a structure */
2299 /* then we need to add a new link */
2300 if (IS_STRUCT (val->type))
2302 /* first lets add DECLARATOR type */
2303 sym_link *p = val->type;
2305 werror (W_STRUCT_AS_ARG, val->name);
2306 val->type = newLink (DECLARATOR);
2307 val->type->next = p;
2310 /* change to a pointer depending on the */
2311 /* storage class specified */
2312 switch (SPEC_SCLS (val->etype))
2315 DCL_TYPE (val->type) = IPOINTER;
2318 DCL_TYPE (val->type) = PPOINTER;
2321 if (SPEC_OCLS(val->etype)) {
2322 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
2324 // this happens for (external) function parameters
2325 DCL_TYPE (val->type) = port->unqualified_pointer;
2331 DCL_TYPE (val->type) = POINTER;
2334 DCL_TYPE (val->type) = CPOINTER;
2337 DCL_TYPE (val->type) = FPOINTER;
2340 DCL_TYPE (val->type) = EEPPOINTER;
2343 DCL_TYPE (val->type) = port->unqualified_pointer;
2346 /* is there is a symbol associated then */
2347 /* change the type of the symbol as well */
2350 val->sym->type = copyLinkChain (val->type);
2351 val->sym->etype = getSpec (val->sym->type);
2356 /*------------------------------------------------------------------*/
2357 /* checkFunction - does all kinds of check on a function */
2358 /*------------------------------------------------------------------*/
2360 checkFunction (symbol * sym, symbol *csym)
2362 value *exargs, *acargs;
2366 if (getenv("DEBUG_SANITY")) {
2367 fprintf (stderr, "checkFunction: %s ", sym->name);
2370 if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
2372 werror(E_SYNTAX_ERROR, sym->name);
2376 /* make sure the type is complete and sane */
2377 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
2379 /* if not type then some kind of error */
2383 /* if the function has no type then make it return int */
2384 if (!sym->type->next)
2385 sym->type->next = sym->etype = newIntLink ();
2387 /* function cannot return aggregate */
2388 if (IS_AGGREGATE (sym->type->next))
2390 werror (E_FUNC_AGGR, sym->name);
2394 /* check if this function is defined as calleeSaves
2395 then mark it as such */
2396 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
2398 /* if interrupt service routine */
2399 /* then it cannot have arguments */
2400 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
2402 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
2403 werror (E_INT_ARGS, sym->name);
2404 FUNC_ARGS(sym->type)=NULL;
2408 if (IFFUNC_ISSHADOWREGS(sym->type) && !FUNC_ISISR (sym->type))
2410 werror (E_SHADOWREGS_NO_ISR, sym->name);
2414 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
2416 acargs=acargs->next, argCnt++) {
2418 // this can happen for reentrant functions
2419 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2420 // the show must go on: synthesize a name and symbol
2421 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
2422 acargs->sym = newSymbol (acargs->name, 1);
2423 SPEC_OCLS (acargs->etype) = istack;
2424 acargs->sym->type = copyLinkChain (acargs->type);
2425 acargs->sym->etype = getSpec (acargs->sym->type);
2426 acargs->sym->_isparm = 1;
2427 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2428 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2430 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2435 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2436 return 1; /* not defined nothing more to check */
2438 /* check if body already present */
2439 if (csym && IFFUNC_HASBODY(csym->type))
2441 werror (E_FUNC_BODY, sym->name);
2445 /* check the return value type */
2446 if (compareType (csym->type, sym->type) <= 0)
2448 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2449 printFromToType(csym->type, sym->type);
2453 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2455 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2458 /* I don't think this is necessary for interrupts. An isr is a */
2459 /* root in the calling tree. */
2460 if ((FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type)) &&
2461 (!FUNC_ISISR (sym->type)))
2463 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2466 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2468 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2471 /* Really, reentrant should match regardless of argCnt, but */
2472 /* this breaks some existing code (the fp lib functions). If */
2473 /* the first argument is always passed the same way, this */
2474 /* lax checking is ok (but may not be true for in future ports) */
2475 if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2478 //printf("argCnt = %d\n",argCnt);
2479 werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2482 if (IFFUNC_ISWPARAM (csym->type) != IFFUNC_ISWPARAM (sym->type))
2484 werror (E_PREV_DEF_CONFLICT, csym->name, "wparam");
2487 if (IFFUNC_ISSHADOWREGS (csym->type) != IFFUNC_ISSHADOWREGS (sym->type))
2489 werror (E_PREV_DEF_CONFLICT, csym->name, "shadowregs");
2493 /* compare expected args with actual args */
2494 exargs = FUNC_ARGS(csym->type);
2495 acargs = FUNC_ARGS(sym->type);
2497 /* for all the expected args do */
2500 exargs = exargs->next, acargs = acargs->next, argCnt++)
2502 if (getenv("DEBUG_SANITY")) {
2503 fprintf (stderr, "checkFunction: %s ", exargs->name);
2505 /* make sure the type is complete and sane */
2506 checkTypeSanity(exargs->etype, exargs->name);
2508 /* If the actual argument is an array, any prototype
2509 * will have modified it to a pointer. Duplicate that
2512 if (IS_AGGREGATE (acargs->type))
2514 checkValue = copyValue (acargs);
2515 aggregateToPointer (checkValue);
2519 checkValue = acargs;
2522 if (compareType (exargs->type, checkValue->type) <= 0)
2524 werror (E_ARG_TYPE, argCnt);
2525 printFromToType(exargs->type, checkValue->type);
2530 /* if one them ended we have a problem */
2531 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2532 (!exargs && acargs && !IS_VOID (acargs->type)))
2533 werror (E_ARG_COUNT);
2535 /* replace with this defition */
2536 sym->cdef = csym->cdef;
2537 deleteSym (SymbolTab, csym, csym->name);
2538 deleteFromSeg(csym);
2539 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2540 if (IS_EXTERN (csym->etype) && !
2541 IS_EXTERN (sym->etype))
2543 addSet (&publics, sym);
2548 /*------------------------------------------------------------------*/
2549 /* cdbStructBlock - calls struct printing for a blcks */
2550 /*------------------------------------------------------------------*/
2551 void cdbStructBlock (int block)
2554 bucket **table = StructTab;
2557 /* go thru the entire table */
2558 for (i = 0; i < 256; i++)
2560 for (chain = table[i]; chain; chain = chain->next)
2562 if (chain->block >= block)
2565 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2571 /*-----------------------------------------------------------------*/
2572 /* processFuncPtrArgs - does some processing with args of func ptrs*/
2573 /*-----------------------------------------------------------------*/
2575 processFuncPtrArgs (sym_link * funcType)
2577 value *val = FUNC_ARGS(funcType);
2579 /* if it is void then remove parameters */
2580 if (val && IS_VOID (val->type))
2582 FUNC_ARGS(funcType) = NULL;
2587 /*-----------------------------------------------------------------*/
2588 /* processFuncArgs - does some processing with function args */
2589 /*-----------------------------------------------------------------*/
2591 processFuncArgs (symbol * func)
2595 sym_link *funcType=func->type;
2597 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2598 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2600 /* find the function declaration within the type */
2601 while (funcType && !IS_FUNC(funcType))
2602 funcType=funcType->next;
2604 /* if this function has variable argument list */
2605 /* then make the function a reentrant one */
2606 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2607 FUNC_ISREENT(funcType)=1;
2609 /* check if this function is defined as calleeSaves
2610 then mark it as such */
2611 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2613 /* loop thru all the arguments */
2614 val = FUNC_ARGS(funcType);
2616 /* if it is void then remove parameters */
2617 if (val && IS_VOID (val->type))
2619 FUNC_ARGS(funcType) = NULL;
2623 /* reset regparm for the port */
2624 (*port->reset_regparms) ();
2626 /* if any of the arguments is an aggregate */
2627 /* change it to pointer to the same type */
2631 char buffer[SDCC_NAME_MAX+1];
2633 SNPRINTF (buffer, sizeof(buffer), "%s parameter %d", func->name, pNum);
2634 checkTypeSanity (val->etype, buffer);
2636 /* mark it as a register parameter if
2637 the function does not have VA_ARG
2638 and as port dictates */
2639 if (!IFFUNC_HASVARARGS(funcType) &&
2640 (argreg = (*port->reg_parm) (val->type, FUNC_ISREENT(funcType))))
2642 SPEC_REGPARM (val->etype) = 1;
2643 SPEC_ARGREG(val->etype) = argreg;
2644 } else if (IFFUNC_ISREENT(funcType)) {
2645 FUNC_HASSTACKPARM(funcType) = 1;
2648 if (IS_AGGREGATE (val->type))
2650 aggregateToPointer (val);
2657 /* if this is an internal generated function call */
2659 /* ignore --stack-auto for this one, we don't know how it is compiled */
2660 /* simply trust on --int-long-reent or --float-reent */
2661 if (IFFUNC_ISREENT(funcType)) {
2665 /* if this function is reentrant or */
2666 /* automatics r 2b stacked then nothing */
2667 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2671 val = FUNC_ARGS(funcType);
2676 /* if a symbolname is not given */
2677 /* synthesize a variable name */
2680 SNPRINTF (val->name, sizeof(val->name),
2681 "_%s_PARM_%d", func->name, pNum++);
2682 val->sym = newSymbol (val->name, 1);
2683 if (SPEC_SCLS(val->etype) == S_BIT)
2684 SPEC_OCLS (val->etype) = bit;
2686 SPEC_OCLS (val->etype) = port->mem.default_local_map;
2687 val->sym->type = copyLinkChain (val->type);
2688 val->sym->etype = getSpec (val->sym->type);
2689 val->sym->_isparm = 1;
2690 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2692 /* ?? static functions shouldn't imply static parameters - EEP */
2693 if (IS_SPEC(func->etype)) {
2694 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2695 SPEC_STAT (func->etype);
2698 addSymChain (&val->sym);
2701 else /* symbol name given create synth name */
2704 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2705 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2706 val->sym->_isparm = 1;
2707 if (SPEC_SCLS(val->etype) == S_BIT)
2708 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = bit;
2710 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2711 port->mem.default_local_map;
2714 /* ?? static functions shouldn't imply static parameters - EEP */
2715 if (IS_SPEC(func->etype)) {
2716 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2717 SPEC_STAT (func->etype);
2721 if (SPEC_OCLS (val->sym->etype) == pdata)
2722 val->sym->iaccess = 1;
2723 if (!isinSet(operKeyReset, val->sym)) {
2724 addSet (&operKeyReset, val->sym);
2725 applyToSet (operKeyReset, resetParmKey);
2731 /*-----------------------------------------------------------------*/
2732 /* isSymbolEqual - compares two symbols return 1 if they match */
2733 /*-----------------------------------------------------------------*/
2735 isSymbolEqual (symbol * dest, symbol * src)
2737 /* if pointers match then equal */
2741 /* if one of them is null then don't match */
2745 /* if both of them have rname match on rname */
2746 if (dest->rname[0] && src->rname[0])
2747 return (!strcmp (dest->rname, src->rname));
2749 /* otherwise match on name */
2750 return (!strcmp (dest->name, src->name));
2753 void PT(sym_link *type)
2755 printTypeChain(type,0);
2757 /*-----------------------------------------------------------------*/
2758 /* printTypeChain - prints the type chain in human readable form */
2759 /*-----------------------------------------------------------------*/
2761 printTypeChain (sym_link * start, FILE * of)
2765 sym_link * type, * search;
2775 fprintf (of, "void");
2779 /* Print the chain as it is written in the source: */
2780 /* start with the last entry. */
2781 /* However, the storage class at the end of the */
2782 /* chain reall applies to the first in the chain! */
2784 for (type = start; type && type->next; type = type->next)
2787 scls=SPEC_SCLS(type);
2795 case S_DATA: fprintf (of, "data-"); break;
2796 case S_XDATA: fprintf (of, "xdata-"); break;
2797 case S_SFR: fprintf (of, "sfr-"); break;
2798 case S_SBIT: fprintf (of, "sbit-"); break;
2799 case S_CODE: fprintf (of, "code-"); break;
2800 case S_IDATA: fprintf (of, "idata-"); break;
2801 case S_PDATA: fprintf (of, "pdata-"); break;
2802 case S_LITERAL: fprintf (of, "literal-"); break;
2803 case S_STACK: fprintf (of, "stack-"); break;
2804 case S_XSTACK: fprintf (of, "xstack-"); break;
2805 case S_BIT: fprintf (of, "bit-"); break;
2806 case S_EEPROM: fprintf (of, "eeprom-"); break;
2813 if (!IS_FUNC(type)) {
2814 if (DCL_PTR_VOLATILE (type)) {
2815 fprintf (of, "volatile-");
2817 if (DCL_PTR_CONST (type)) {
2818 fprintf (of, "const-");
2821 switch (DCL_TYPE (type))
2824 fprintf (of, "function %s %s",
2825 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2826 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2828 for (args = FUNC_ARGS(type);
2831 printTypeChain(args->type, of);
2838 fprintf (of, "generic* ");
2841 fprintf (of, "code* ");
2844 fprintf (of, "xdata* ");
2847 fprintf (of, "eeprom* ");
2850 fprintf (of, "near* ");
2853 fprintf (of, "idata* ");
2856 fprintf (of, "pdata* ");
2859 fprintf (of, "unknown* ");
2862 if (DCL_ELEM(type)) {
2863 fprintf (of, "[%d] ", DCL_ELEM(type));
2865 fprintf (of, "[] ");
2872 if (SPEC_VOLATILE (type))
2873 fprintf (of, "volatile-");
2874 if (SPEC_CONST (type))
2875 fprintf (of, "const-");
2876 if (SPEC_USIGN (type))
2877 fprintf (of, "unsigned-");
2878 switch (SPEC_NOUN (type))
2882 fprintf (of, "long-");
2883 fprintf (of, "int");
2887 fprintf (of, "char");
2891 fprintf (of, "void");
2895 fprintf (of, "float");
2899 fprintf (of, "fixed16x16");
2903 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2907 fprintf (of, "sbit");
2911 fprintf (of, "bit");
2915 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2919 fprintf (of, "double");
2923 fprintf (of, "unknown type");
2927 /* search entry in list before "type" */
2928 for (search = start; search && search->next != type;)
2929 search = search->next;
2938 /*--------------------------------------------------------------------*/
2939 /* printTypeChainRaw - prints the type chain in human readable form */
2940 /* in the raw data structure ordering */
2941 /*--------------------------------------------------------------------*/
2943 printTypeChainRaw (sym_link * start, FILE * of)
2956 fprintf (of, "void");
2966 if (!IS_FUNC(type)) {
2967 if (DCL_PTR_VOLATILE (type)) {
2968 fprintf (of, "volatile-");
2970 if (DCL_PTR_CONST (type)) {
2971 fprintf (of, "const-");
2974 switch (DCL_TYPE (type))
2977 fprintf (of, "function %s %s",
2978 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2979 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2981 for (args = FUNC_ARGS(type);
2984 printTypeChain(args->type, of);
2991 fprintf (of, "generic* ");
2994 fprintf (of, "code* ");
2997 fprintf (of, "xdata* ");
3000 fprintf (of, "eeprom* ");
3003 fprintf (of, "near* ");
3006 fprintf (of, "idata* ");
3009 fprintf (of, "pdata* ");
3012 fprintf (of, "unknown* ");
3015 if (DCL_ELEM(type)) {
3016 fprintf (of, "[%d] ", DCL_ELEM(type));
3018 fprintf (of, "[] ");
3022 if (DCL_TSPEC(type))
3025 printTypeChainRaw(DCL_TSPEC(type), of);
3029 else if (IS_SPEC (type))
3031 switch (SPEC_SCLS (type))
3033 case S_DATA: fprintf (of, "data-"); break;
3034 case S_XDATA: fprintf (of, "xdata-"); break;
3035 case S_SFR: fprintf (of, "sfr-"); break;
3036 case S_SBIT: fprintf (of, "sbit-"); break;
3037 case S_CODE: fprintf (of, "code-"); break;
3038 case S_IDATA: fprintf (of, "idata-"); break;
3039 case S_PDATA: fprintf (of, "pdata-"); break;
3040 case S_LITERAL: fprintf (of, "literal-"); break;
3041 case S_STACK: fprintf (of, "stack-"); break;
3042 case S_XSTACK: fprintf (of, "xstack-"); break;
3043 case S_BIT: fprintf (of, "bit-"); break;
3044 case S_EEPROM: fprintf (of, "eeprom-"); break;
3047 if (SPEC_VOLATILE (type))
3048 fprintf (of, "volatile-");
3049 if (SPEC_CONST (type))
3050 fprintf (of, "const-");
3051 if (SPEC_USIGN (type))
3052 fprintf (of, "unsigned-");
3053 switch (SPEC_NOUN (type))
3057 fprintf (of, "long-");
3058 fprintf (of, "int");
3062 fprintf (of, "char");
3066 fprintf (of, "void");
3070 fprintf (of, "float");
3074 fprintf (of, "fixed16x16");
3078 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
3082 fprintf (of, "sbit");
3086 fprintf (of, "bit");
3090 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
3094 fprintf (of, "double");
3098 fprintf (of, "unknown type");
3103 fprintf (of, "NOT_SPEC_OR_DECL");
3113 /*-----------------------------------------------------------------*/
3114 /* powof2 - returns power of two for the number if number is pow 2 */
3115 /*-----------------------------------------------------------------*/
3117 powof2 (TYPE_UDWORD num)
3130 if (n1s > 1 || nshifts == 0)
3146 symbol *__fps16x16_add;
3147 symbol *__fps16x16_sub;
3148 symbol *__fps16x16_mul;
3149 symbol *__fps16x16_div;
3150 symbol *__fps16x16_eq;
3151 symbol *__fps16x16_neq;
3152 symbol *__fps16x16_lt;
3153 symbol *__fps16x16_lteq;
3154 symbol *__fps16x16_gt;
3155 symbol *__fps16x16_gteq;
3157 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3158 symbol *__muldiv[3][3][2];
3159 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
3160 sym_link *__multypes[3][2];
3161 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
3162 symbol *__conv[2][3][2];
3163 /* Dims: to/from fixed16x16, BYTE/WORD/DWORD/FLOAT, SIGNED/USIGNED */
3164 symbol *__fp16x16conv[2][4][2];
3165 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3166 symbol *__rlrr[2][3][2];
3168 sym_link *floatType;
3169 sym_link *fixed16x16Type;
3172 _mangleFunctionName(char *in)
3174 if (port->getMangledFunctionName)
3176 return port->getMangledFunctionName(in);
3184 /*-----------------------------------------------------------------*/
3185 /* typeFromStr - create a typechain from an encoded string */
3186 /* basic types - 'c' - char */
3191 /* 'q' - fixed16x16 */
3193 /* '*' - pointer - default (GPOINTER) */
3194 /* modifiers - 'u' - unsigned */
3195 /* pointer modifiers - 'g' - generic */
3199 /* 'F' - function */
3200 /* examples : "ig*" - generic int * */
3201 /* "cx*" - char xdata * */
3202 /* "ui" - unsigned int */
3203 /*-----------------------------------------------------------------*/
3204 sym_link *typeFromStr (char *s)
3206 sym_link *r = newLink(DECLARATOR);
3218 r->class = SPECIFIER;
3219 SPEC_NOUN(r) = V_CHAR;
3223 r->class = SPECIFIER;
3224 SPEC_NOUN(r) = V_INT;
3227 r->class = SPECIFIER;
3228 SPEC_NOUN(r) = V_INT;
3232 r->class = SPECIFIER;
3233 SPEC_NOUN(r) = V_FLOAT;
3236 r->class = SPECIFIER;
3237 SPEC_NOUN(r) = V_FIXED16X16;
3240 r->class = SPECIFIER;
3241 SPEC_NOUN(r) = V_VOID;
3244 DCL_TYPE(r) = port->unqualified_pointer;
3251 assert(*(s+1)=='*');
3252 nr = newLink(DECLARATOR);
3257 DCL_TYPE(r) = GPOINTER;
3260 DCL_TYPE(r) = FPOINTER;
3263 DCL_TYPE(r) = CPOINTER;
3266 DCL_TYPE(r) = POINTER;
3269 DCL_TYPE(r) = FUNCTION;
3270 nr = newLink(DECLARATOR);
3273 DCL_TYPE(r) = CPOINTER;
3279 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
3280 "typeFromStr: unknown type");
3283 if (IS_SPEC(r) && usign) {
3292 /*-----------------------------------------------------------------*/
3293 /* initCSupport - create functions for C support routines */
3294 /*-----------------------------------------------------------------*/
3298 const char *smuldivmod[] =
3302 const char *sbwd[] =
3304 "char", "int", "long", "fixed16x16",
3306 const char *fp16x16sbwd[] =
3308 "char", "int", "long", "float",
3314 const char *srlrr[] =
3319 int bwd, su, muldivmod, tofrom, rlrr;
3321 if (getenv("SDCC_NO_C_SUPPORT")) {
3322 /* for debugging only */
3326 floatType = newFloatLink ();
3327 fixed16x16Type = newFixed16x16Link ();
3329 for (bwd = 0; bwd < 3; bwd++)
3346 __multypes[bwd][0] = l;
3347 __multypes[bwd][1] = copyLinkChain (l);
3348 SPEC_USIGN (__multypes[bwd][1]) = 1;
3351 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
3352 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
3353 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
3354 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
3355 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
3356 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
3357 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
3358 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
3359 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
3360 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
3362 __fps16x16_add = funcOfType ("__fps16x16_add", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3363 __fps16x16_sub = funcOfType ("__fps16x16_sub", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3364 __fps16x16_mul = funcOfType ("__fps16x16_mul", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3365 __fps16x16_div = funcOfType ("__fps16x16_div", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3366 __fps16x16_eq = funcOfType ("__fps16x16_eq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3367 __fps16x16_neq = funcOfType ("__fps16x16_neq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3368 __fps16x16_lt = funcOfType ("__fps16x16_lt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3369 __fps16x16_lteq = funcOfType ("__fps16x16_lteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3370 __fps16x16_gt = funcOfType ("__fps16x16_gt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3371 __fps16x16_gteq = funcOfType ("__fps16x16_gteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3374 for (tofrom = 0; tofrom < 2; tofrom++)
3376 for (bwd = 0; bwd < 3; bwd++)
3378 for (su = 0; su < 2; su++)
3382 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
3383 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
3387 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
3388 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
3394 for (tofrom = 0; tofrom < 2; tofrom++)
3396 for (bwd = 0; bwd < 4; bwd++)
3398 for (su = 0; su < 2; su++)
3402 SNPRINTF (buffer, sizeof(buffer), "__fps16x162%s%s", ssu[su], fp16x16sbwd[bwd]);
3404 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, floatType, fixed16x16Type, 1, options.float_rent);
3406 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], fixed16x16Type, 1, options.float_rent);
3410 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fps16x16", ssu[su], fp16x16sbwd[bwd]);
3412 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, floatType, 1, options.float_rent);
3414 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, __multypes[bwd][su], 1, options.float_rent);
3421 for (muldivmod = 0; muldivmod < 3; muldivmod++)
3423 for (bwd = 0; bwd < 3; bwd++)
3425 for (su = 0; su < 2; su++)
3427 SNPRINTF (buffer, sizeof(buffer),
3429 smuldivmod[muldivmod],
3432 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3433 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3438 muluint() and mulsint() resp. mululong() and mulslong() return the same result.
3439 Therefore they've been merged into mulint() and mullong().
3442 for (bwd = 0; bwd < 3; bwd++)
3444 for (su = 0; su < 2; su++)
3446 for (muldivmod = 1; muldivmod < 3; muldivmod++)
3449 SNPRINTF (buffer, sizeof(buffer),
3451 smuldivmod[muldivmod],
3454 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3455 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3463 for (su = 0; su < 2; su++)
3465 /* muluchar and mulschar are still separate functions, because e.g. the z80
3466 port is sign/zero-extending to int before calling mulint() */
3467 SNPRINTF (buffer, sizeof(buffer),
3469 smuldivmod[muldivmod],
3472 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3473 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3477 /* word and doubleword */
3478 for (bwd = 1; bwd < 3; bwd++)
3481 SNPRINTF (buffer, sizeof(buffer),
3483 smuldivmod[muldivmod],
3485 __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3486 FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
3487 /* signed = unsigned */
3488 __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
3491 for (rlrr = 0; rlrr < 2; rlrr++)
3493 for (bwd = 0; bwd < 3; bwd++)
3495 for (su = 0; su < 2; su++)
3497 SNPRINTF (buffer, sizeof(buffer),
3502 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
3503 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
3509 /*-----------------------------------------------------------------*/
3510 /* initBuiltIns - create prototypes for builtin functions */
3511 /*-----------------------------------------------------------------*/
3517 if (!port->builtintable) return ;
3519 for (i = 0 ; port->builtintable[i].name ; i++) {
3520 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
3521 port->builtintable[i].nParms,port->builtintable[i].parm_types);
3522 FUNC_ISBUILTIN(sym->type) = 1;
3523 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
3527 sym_link *validateLink(sym_link *l,
3534 if (l && l->class==select)
3539 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
3540 " expected %s, got %s\n",
3541 macro, args, file, line,
3542 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
3544 return l; // never reached, makes compiler happy.
3547 /*--------------------------------------------------------------------*/
3548 /* newEnumType - create an integer type compatible with enumerations */
3549 /*--------------------------------------------------------------------*/
3551 newEnumType (symbol *enumlist)
3559 type = newLink (SPECIFIER);
3560 SPEC_NOUN (type) = V_INT;
3564 /* Determine the range of the enumerated values */
3566 min = max = (int) floatFromVal (valFromType (sym->type));
3567 for (sym = sym->next; sym; sym = sym->next)
3569 v = (int) floatFromVal (valFromType (sym->type));
3576 /* Determine the smallest integer type that is compatible with this range */
3577 type = newLink (SPECIFIER);
3578 if (min>=0 && max<=255)
3580 SPEC_NOUN (type) = V_CHAR;
3581 SPEC_USIGN (type) = 1;
3583 else if (min>=-128 && max<=127)
3585 SPEC_NOUN (type) = V_CHAR;
3587 else if (min>=0 && max<=65535)
3589 SPEC_NOUN (type) = V_INT;
3590 SPEC_USIGN (type) = 1;
3592 else if (min>=-32768 && max<=32767)
3594 SPEC_NOUN (type) = V_INT;
3598 SPEC_NOUN (type) = V_INT;
3599 SPEC_LONG (type) = 1;
3601 SPEC_USIGN (type) = 1;