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 (sl->select.s._short) return "short";
49 case V_FLOAT: return "float";
50 case V_CHAR: return "char";
51 case V_VOID: return "void";
52 case V_STRUCT: return "struct";
53 case V_LABEL: return "label";
54 case V_BITFIELD: return "bitfield";
55 case V_BIT: return "bit";
56 case V_SBIT: return "sbit";
57 case V_DOUBLE: return "double";
62 bucket *SymbolTab[256]; /* the symbol table */
63 bucket *StructTab[256]; /* the structure table */
64 bucket *TypedefTab[256]; /* the typedef table */
65 bucket *LabelTab[256]; /* the Label table */
66 bucket *enumTab[256]; /* enumerated table */
68 /*------------------------------------------------------------------*/
69 /* initSymt () - initialises symbol table related stuff */
70 /*------------------------------------------------------------------*/
76 for (i = 0; i < 256; i++)
77 SymbolTab[i] = StructTab[i] = (void *) NULL;
81 /*-----------------------------------------------------------------*/
82 /* newBucket - allocates & returns a new bucket */
83 /*-----------------------------------------------------------------*/
89 bp = Safe_alloc ( sizeof (bucket));
94 /*-----------------------------------------------------------------*/
95 /* hashKey - computes the hashkey given a symbol name */
96 /*-----------------------------------------------------------------*/
98 hashKey (const char *s)
100 unsigned long key = 0;
107 /*-----------------------------------------------------------------*/
108 /* addSym - adds a symbol to the hash Table */
109 /*-----------------------------------------------------------------*/
111 addSym (bucket ** stab,
118 int i; /* index into the hash Table */
119 bucket *bp; /* temp bucket * */
122 symbol *csym = (symbol *)sym;
124 if (getenv("DEBUG_SANITY")) {
125 fprintf (stderr, "addSym: %s ", sname);
127 /* make sure the type is complete and sane */
128 checkTypeSanity(csym->etype, csym->name);
131 /* prevent overflow of the (r)name buffers */
132 if (strlen(sname)>SDCC_SYMNAME_MAX) {
133 werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
134 sname[SDCC_SYMNAME_MAX]='\0';
137 /* the symbols are always added at the head of the list */
139 /* get a free entry */
140 bp = Safe_alloc ( sizeof (bucket));
142 bp->sym = sym; /* update the symbol pointer */
143 bp->level = level; /* update the nest level */
145 strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
147 /* if this is the first entry */
150 bp->prev = bp->next = (void *) NULL; /* point to nothing */
153 /* not first entry then add @ head of list */
163 /*-----------------------------------------------------------------*/
164 /* deleteSym - deletes a symbol from the hash Table entry */
165 /*-----------------------------------------------------------------*/
167 deleteSym (bucket ** stab, void *sym, char *sname)
175 /* find the symbol */
178 if (bp->sym == sym) /* found it then break out */
179 break; /* of the loop */
183 if (!bp) /* did not find it */
185 /* if this is the first one in the chain */
189 if (stab[i]) /* if chain ! empty */
190 stab[i]->prev = (void *) NULL;
192 /* middle || end of chain */
195 if (bp->next) /* if not end of chain */
196 bp->next->prev = bp->prev;
198 bp->prev->next = bp->next;
203 /*-----------------------------------------------------------------*/
204 /* findSym - finds a symbol in a table */
205 /*-----------------------------------------------------------------*/
207 findSym (bucket ** stab, void *sym, const char *sname)
211 bp = stab[hashKey (sname)];
214 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
219 return (bp ? bp->sym : (void *) NULL);
222 /*-----------------------------------------------------------------*/
223 /* findSymWithLevel - finds a symbol with a name & level */
224 /*-----------------------------------------------------------------*/
226 findSymWithLevel (bucket ** stab, symbol * sym)
230 bp = stab[hashKey (sym->name)];
233 ** do the search from the head of the list since the
234 ** elements are added at the head it is ensured that
235 ** we will find the deeper definitions before we find
236 ** the global ones. we need to check for symbols with
237 ** level <= to the level given, if levels match then block
238 ** numbers need to match as well
242 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
244 /* if this is parameter then nothing else need to be checked */
245 if (((symbol *) (bp->sym))->_isparm)
247 /* if levels match then block numbers should also match */
248 if (bp->level && bp->level == sym->level && bp->block == sym->block)
250 /* if levels don't match then we are okay */
251 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
253 /* if this is a global variable then we are ok too */
261 return (void *) NULL;
264 /*-----------------------------------------------------------------*/
265 /* findSymWithBlock - finds a symbol with name in with a block */
266 /*-----------------------------------------------------------------*/
268 findSymWithBlock (bucket ** stab, symbol * sym, int block)
272 bp = stab[hashKey (sym->name)];
275 if (strcmp (bp->name, sym->name) == 0 &&
281 return (bp ? bp->sym : (void *) NULL);
284 /*------------------------------------------------------------------*/
285 /* newSymbol () - returns a new pointer to a symbol */
286 /*------------------------------------------------------------------*/
288 newSymbol (char *name, int scope)
292 sym = Safe_alloc ( sizeof (symbol));
294 strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */
295 sym->level = scope; /* set the level */
296 sym->block = currBlockno;
297 sym->lineDef = mylineno; /* set the line number */
298 sym->fileDef = currFname;
302 /*------------------------------------------------------------------*/
303 /* newLink - creates a new link (declarator,specifier) */
304 /*------------------------------------------------------------------*/
306 newLink (SYM_LINK_CLASS select)
310 p = Safe_alloc ( sizeof (sym_link));
316 /*------------------------------------------------------------------*/
317 /* newStruct - creats a new structdef from the free list */
318 /*------------------------------------------------------------------*/
320 newStruct (char *tag)
324 s = Safe_alloc ( sizeof (structdef));
326 strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
330 /*------------------------------------------------------------------*/
331 /* sclsFromPtr - Return the storage class a pointer points into. */
332 /* S_FIXED is returned for generic pointers or other */
333 /* unexpected cases */
334 /*------------------------------------------------------------------*/
336 sclsFromPtr(sym_link *ptr)
338 switch (DCL_TYPE (ptr))
361 /*------------------------------------------------------------------*/
362 /* pointerTypes - do the computation for the pointer types */
363 /*------------------------------------------------------------------*/
365 pointerTypes (sym_link * ptr, sym_link * type)
370 /* find the first pointer type */
371 while (ptr && !IS_PTR (ptr))
374 /* could not find it */
375 if (!ptr || IS_SPEC (ptr))
378 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
379 pointerTypes (ptr->next, type);
383 /* change the pointer type depending on the
384 storage class of the type */
387 switch (SPEC_SCLS (type))
390 DCL_TYPE (ptr) = FPOINTER;
393 DCL_TYPE (ptr) = IPOINTER;
396 DCL_TYPE (ptr) = PPOINTER;
399 DCL_TYPE (ptr) = POINTER;
402 DCL_TYPE (ptr) = CPOINTER;
405 DCL_TYPE (ptr) = EEPPOINTER;
408 DCL_TYPE (ptr) = port->unqualified_pointer;
411 /* the storage class of type ends here */
412 SPEC_SCLS (type) = 0;
415 /* now change all the remaining unknown pointers
416 to generic pointers */
419 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
420 DCL_TYPE (ptr) = port->unqualified_pointer;
424 /* same for the type although it is highly unlikely that
425 type will have a pointer */
428 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
429 DCL_TYPE (type) = port->unqualified_pointer;
434 /*------------------------------------------------------------------*/
435 /* addDecl - adds a declarator @ the end of a chain */
436 /*------------------------------------------------------------------*/
438 addDecl (symbol * sym, int type, sym_link * p)
444 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
445 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
447 /* if we are passed a link then set head & tail */
456 head = tail = newLink (DECLARATOR);
457 DCL_TYPE (head) = type;
460 /* if this is the first entry */
468 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
470 sym->etype = mergeSpec (sym->etype, head, sym->name);
474 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
477 while (t->next != sym->etype)
480 tail->next = sym->etype;
484 sym->etype->next = head;
490 /* if the type is an unknown pointer and has
491 a tspec then take the storage class const & volatile
492 attribute from the tspec & make it those of this
496 //DCL_TYPE (p) == UPOINTER &&
499 if (!IS_SPEC (sym->etype))
501 sym->etype = sym->etype->next = newLink (SPECIFIER);
503 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
504 DCL_TSPEC (p) = NULL;
507 // if there is a function in this type chain
508 if (p && funcInChain(sym->type)) {
509 processFuncArgs (sym);
515 /*------------------------------------------------------------------
516 checkTypeSanity: prevent the user from doing e.g.:
518 ------------------------------------------------------------------*/
519 void checkTypeSanity(sym_link *etype, char *name) {
523 if (getenv("DEBUG_SANITY")) {
524 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
529 if (!IS_SPEC(etype)) {
530 if (getenv("DEBUG_SANITY")) {
531 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
536 noun=nounName(etype);
538 if (getenv("DEBUG_SANITY")) {
539 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
542 if ((SPEC_NOUN(etype)==V_CHAR ||
543 SPEC_NOUN(etype)==V_FLOAT ||
544 SPEC_NOUN(etype)==V_DOUBLE ||
545 SPEC_NOUN(etype)==V_VOID) &&
546 (etype->select.s._short || SPEC_LONG(etype))) {
547 // long or short for char float double or void
548 werror (E_LONG_OR_SHORT_INVALID, noun, name);
550 if ((SPEC_NOUN(etype)==V_FLOAT ||
551 SPEC_NOUN(etype)==V_DOUBLE ||
552 SPEC_NOUN(etype)==V_VOID) &&
553 (etype->select.s._signed || SPEC_USIGN(etype))) {
554 // signed or unsigned for float double or void
555 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
558 // special case for "short"
559 if (etype->select.s._short) {
560 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
561 etype->select.s._short = 0;
565 "const a;" or "data b;" or "signed s" or "long l"
567 if (!SPEC_NOUN(etype)) {
568 SPEC_NOUN(etype)=V_INT;
571 /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
572 /* a "plain" int bitfield is unsigned */
573 if (SPEC_NOUN(etype)==V_BIT ||
574 SPEC_NOUN(etype)==V_SBIT) {
575 if (!etype->select.s._signed)
576 SPEC_USIGN(etype) = 1;
579 if (etype->select.s._signed && SPEC_USIGN(etype)) {
580 // signed AND unsigned
581 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
583 if (etype->select.s._short && SPEC_LONG(etype)) {
585 werror (E_LONG_AND_SHORT_INVALID, noun, name);
590 /*------------------------------------------------------------------*/
591 /* mergeSpec - merges two specifiers and returns the new one */
592 /*------------------------------------------------------------------*/
594 mergeSpec (sym_link * dest, sym_link * src, char *name)
596 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
598 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
601 werror (E_SYNTAX_ERROR, yytext);
602 // the show must go on
607 if (SPEC_NOUN(src)) {
608 if (!SPEC_NOUN(dest)) {
609 SPEC_NOUN(dest)=SPEC_NOUN(src);
611 /* we shouldn't redeclare the type */
612 if (getenv("DEBUG_SANITY")) {
613 fprintf (stderr, "mergeSpec: ");
615 werror(E_TWO_OR_MORE_DATA_TYPES, name);
619 if (SPEC_SCLS(src)) {
620 /* if destination has no storage class */
621 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
622 SPEC_SCLS (dest) = SPEC_SCLS (src);
624 if (getenv("DEBUG_SANITY")) {
625 fprintf (stderr, "mergeSpec: ");
627 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
631 /* copy all the specifications */
633 // we really should do:
635 if (SPEC_what(src)) {
636 if (SPEC_what(dest)) {
637 werror(W_DUPLICATE_SPEC, "what");
639 SPEC_what(dst)|=SPEC_what(src);
642 // but there are more important thing right now
644 SPEC_LONG (dest) |= SPEC_LONG (src);
645 dest->select.s._short|=src->select.s._short;
646 SPEC_USIGN (dest) |= SPEC_USIGN (src);
647 dest->select.s._signed|=src->select.s._signed;
648 SPEC_STAT (dest) |= SPEC_STAT (src);
649 SPEC_EXTR (dest) |= SPEC_EXTR (src);
650 SPEC_CONST(dest) |= SPEC_CONST (src);
651 SPEC_ABSA (dest) |= SPEC_ABSA (src);
652 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
653 SPEC_ADDR (dest) |= SPEC_ADDR (src);
654 SPEC_OCLS (dest) = SPEC_OCLS (src);
655 SPEC_BLEN (dest) |= SPEC_BLEN (src);
656 SPEC_BSTR (dest) |= SPEC_BSTR (src);
657 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
658 SPEC_ENUM (dest) |= SPEC_ENUM (src);
659 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
660 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
662 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
663 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
665 /* these are the only function attributes that will be set
666 in a specifier while parsing */
667 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
668 FUNC_BANKED(dest) |= FUNC_BANKED(src);
669 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
670 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
671 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
672 FUNC_ISISR(dest) |= FUNC_ISISR(src);
673 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
674 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
675 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
676 FUNC_INTNO(dest) |= FUNC_INTNO(src);
677 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
682 /*------------------------------------------------------------------*/
683 /* genSymName - generates and returns a name used for anonymous vars */
684 /*------------------------------------------------------------------*/
686 genSymName (int level)
688 static int gCount = 0;
689 static char gname[SDCC_NAME_MAX + 1];
691 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
695 /*------------------------------------------------------------------*/
696 /* getSpec - returns the specifier part from a declaration chain */
697 /*------------------------------------------------------------------*/
699 getSpec (sym_link * p)
704 while (p && !(IS_SPEC (p)))
710 /*------------------------------------------------------------------*/
711 /* newCharLink() - creates an char type */
712 /*------------------------------------------------------------------*/
718 p = newLink (SPECIFIER);
719 SPEC_NOUN (p) = V_CHAR;
724 /*------------------------------------------------------------------*/
725 /* newFloatLink - a new Float type */
726 /*------------------------------------------------------------------*/
732 p = newLink (SPECIFIER);
733 SPEC_NOUN (p) = V_FLOAT;
738 /*------------------------------------------------------------------*/
739 /* newLongLink() - new long type */
740 /*------------------------------------------------------------------*/
746 p = newLink (SPECIFIER);
747 SPEC_NOUN (p) = V_INT;
753 /*------------------------------------------------------------------*/
754 /* newIntLink() - creates an int type */
755 /*------------------------------------------------------------------*/
761 p = newLink (SPECIFIER);
762 SPEC_NOUN (p) = V_INT;
767 /*------------------------------------------------------------------*/
768 /* getSize - returns size of a type chain in bits */
769 /*------------------------------------------------------------------*/
771 getSize (sym_link * p)
773 /* if nothing return 0 */
777 { /* if this is the specifier then */
778 switch (SPEC_NOUN (p))
779 { /* depending on the specifier type */
781 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
789 return SPEC_STRUCT (p)->size;
796 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
802 /* this is a declarator */
803 switch (DCL_TYPE (p))
807 return DCL_ELEM (p) * getSize (p->next);
809 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
810 // "can not tell the size of an array[]");
830 /*---------------------------------------------------------------------*/
831 /* getAllocSize - returns size of a type chain in bytes for allocation */
832 /*---------------------------------------------------------------------*/
834 getAllocSize (sym_link *p)
836 if (IS_STRUCT (p) && SPEC_STRUCT (p)->type == STRUCT)
838 /* if this is a struct specifier then */
839 /* calculate the size as it could end */
840 /* with an array of unspecified length */
841 symbol *sflds = SPEC_STRUCT (p)->fields;
843 while (sflds && sflds->next)
846 if (sflds && !IS_BITFIELD (sflds->type))
847 return sflds->offset + getAllocSize (sflds->type);
849 return SPEC_STRUCT (p)->size;
855 /*------------------------------------------------------------------*/
856 /* bitsForType - returns # of bits required to store this type */
857 /*------------------------------------------------------------------*/
859 bitsForType (sym_link * p)
861 /* if nothing return 0 */
866 { /* if this is the specifier then */
868 switch (SPEC_NOUN (p))
869 { /* depending on the specifier type */
871 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
873 return FLOATSIZE * 8;
879 return SPEC_STRUCT (p)->size * 8;
886 return SPEC_BLEN (p);
892 /* this is a specifier */
893 switch (DCL_TYPE (p))
896 return DCL_ELEM (p) * getSize (p->next) * 8;
900 return (PTRSIZE * 8);
905 return (FPTRSIZE * 8);
907 return (GPTRSIZE * 8);
914 /*------------------------------------------------------------------*/
915 /* copySymbolChain - copies a symbol chain */
916 /*------------------------------------------------------------------*/
918 copySymbolChain (symbol * src)
925 dest = copySymbol (src);
926 dest->next = copySymbolChain (src->next);
930 /*------------------------------------------------------------------*/
931 /* copySymbol - makes a copy of a symbol */
932 /*------------------------------------------------------------------*/
934 copySymbol (symbol * src)
941 dest = newSymbol (src->name, src->level);
942 memcpy (dest, src, sizeof (symbol));
943 dest->level = src->level;
944 dest->block = src->block;
945 dest->ival = copyIlist (src->ival);
946 dest->type = copyLinkChain (src->type);
947 dest->etype = getSpec (dest->type);
949 dest->key = src->key;
950 dest->allocreq = src->allocreq;
954 /*------------------------------------------------------------------*/
955 /* reverseSyms - reverses the links for a symbol chain */
956 /*------------------------------------------------------------------*/
958 reverseSyms (symbol * sym)
960 symbol *prev, *curr, *next;
975 sym->next = (void *) NULL;
979 /*------------------------------------------------------------------*/
980 /* reverseLink - reverses the links for a type chain */
981 /*------------------------------------------------------------------*/
983 reverseLink (sym_link * type)
985 sym_link *prev, *curr, *next;
1000 type->next = (void *) NULL;
1004 /*------------------------------------------------------------------*/
1005 /* addSymChain - adds a symbol chain to the symboltable */
1006 /*------------------------------------------------------------------*/
1008 addSymChain (symbol ** symHead)
1010 symbol *sym = *symHead;
1011 symbol *csym = NULL;
1015 for (; sym != NULL; sym = sym->next)
1017 changePointer(sym->type);
1018 checkTypeSanity(sym->etype, sym->name);
1020 if (!sym->level && !(IS_SPEC(sym->etype) && IS_TYPEDEF(sym->etype)))
1023 /* if already exists in the symbol table then check if
1024 one of them is an extern definition if yes then
1025 then check if the type match, if the types match then
1026 delete the current entry and add the new entry */
1027 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
1028 csym->level == sym->level) {
1030 /* If the previous definition was for an array with incomplete */
1031 /* type, and the new definition has completed the type, update */
1032 /* the original type to match */
1033 if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY
1034 && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY)
1036 if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type))
1037 DCL_ELEM(csym->type) = DCL_ELEM(sym->type);
1041 /* If only one of the definitions used the "at" keyword, copy */
1042 /* the address to the other. */
1043 if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype)
1044 && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype))
1046 SPEC_ABSA (sym->etype) = 1;
1047 SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype);
1049 if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype)
1050 && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype))
1052 SPEC_ABSA (csym->etype) = 1;
1053 SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype);
1058 if (csym->ival && sym->ival)
1060 if (compareTypeExact (csym->type, sym->type, sym->level) != 1)
1064 /* one definition extern ? */
1065 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype))
1066 werror (E_EXTERN_MISMATCH, sym->name);
1068 werror (E_DUPLICATE, sym->name);
1069 werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF);
1071 fprintf (stderr, "from type '");
1072 printTypeChain (csym->type, stderr);
1073 if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype))
1074 fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype));
1075 fprintf (stderr, "'\nto type '");
1076 printTypeChain (sym->type, stderr);
1077 if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype))
1078 fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype));
1079 fprintf (stderr, "'\n");
1084 if (csym->ival && !sym->ival)
1085 sym->ival = csym->ival;
1087 /* delete current entry */
1088 deleteSym (SymbolTab, csym, csym->name);
1089 deleteFromSeg(csym);
1091 symPtrPtr = symHead;
1092 while (*symPtrPtr && *symPtrPtr != csym)
1093 symPtrPtr = &(*symPtrPtr)->next;
1094 if (*symPtrPtr == csym)
1095 *symPtrPtr = csym->next;
1100 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1105 /*------------------------------------------------------------------*/
1106 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
1107 /*------------------------------------------------------------------*/
1109 funcInChain (sym_link * lnk)
1120 /*------------------------------------------------------------------*/
1121 /* structElemType - returns the type info of a struct member */
1122 /*------------------------------------------------------------------*/
1124 structElemType (sym_link * stype, value * id)
1126 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1127 sym_link *type, *etype;
1128 sym_link *petype = getSpec (stype);
1132 /* look for the id */
1135 if (strcmp (fields->rname, id->name) == 0)
1137 type = copyLinkChain (fields->type);
1138 etype = getSpec (type);
1139 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1140 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1142 SPEC_CONST (type) |= SPEC_CONST (stype);
1144 DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1147 fields = fields->next;
1151 werror (E_NOT_MEMBER, id->name);
1153 // the show must go on
1154 return newIntLink();
1157 /*------------------------------------------------------------------*/
1158 /* getStructElement - returns element of a tructure definition */
1159 /*------------------------------------------------------------------*/
1161 getStructElement (structdef * sdef, symbol * sym)
1165 for (field = sdef->fields; field; field = field->next)
1166 if (strcmp (field->name, sym->name) == 0)
1169 werror (E_NOT_MEMBER, sym->name);
1171 return sdef->fields;
1174 /*------------------------------------------------------------------*/
1175 /* compStructSize - computes the size of a structure */
1176 /*------------------------------------------------------------------*/
1178 compStructSize (int su, structdef * sdef)
1180 int sum = 0, usum = 0;
1184 /* for the identifiers */
1185 loop = sdef->fields;
1188 /* create the internal name for this variable */
1189 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1194 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1196 /* if this is a bit field */
1199 /* change it to a unsigned bit */
1200 SPEC_NOUN (loop->etype) = V_BITFIELD;
1201 SPEC_USIGN (loop->etype) = 1;
1202 SPEC_BLEN (loop->etype) = loop->bitVar;
1204 if (loop->bitVar == BITVAR_PAD) {
1205 /* A zero length bitfield forces padding */
1206 SPEC_BSTR (loop->etype) = bitOffset;
1207 SPEC_BLEN (loop->etype) = 0;
1212 if (bitOffset == 8) {
1216 /* check if this fit into the remaining */
1217 /* bits of this byte else align it to the */
1218 /* next byte boundary */
1219 if (loop->bitVar <= (8 - bitOffset)) {
1220 /* fits into current byte */
1222 SPEC_BSTR (loop->etype) = bitOffset;
1223 bitOffset += loop->bitVar;
1225 else if (!bitOffset) {
1226 /* does not fit, but is already byte aligned */
1228 SPEC_BSTR (loop->etype) = bitOffset;
1229 bitOffset += loop->bitVar;
1232 /* does not fit; need to realign first */
1234 loop->offset = (su == UNION ? sum = 0 : sum);
1236 SPEC_BSTR (loop->etype) = bitOffset;
1237 bitOffset += loop->bitVar;
1239 while (bitOffset>8) {
1246 /* This is a non-bit field. Make sure we are */
1247 /* byte aligned first */
1250 loop->offset = (su == UNION ? sum = 0 : sum);
1254 checkDecl (loop, 1);
1255 sum += getSize (loop->type);
1260 /* if union then size = sizeof largest field */
1262 /* For UNION, round up after each field */
1263 sum += ((bitOffset+7)/8);
1264 usum = max (usum, sum);
1269 /* For STRUCT, round up after all fields processed */
1271 sum += ((bitOffset+7)/8);
1273 return (su == UNION ? usum : sum);
1276 /*-------------------------------------------------------------------*/
1277 /* promoteAnonStructs - promote anonymous struct/union's fields into */
1278 /* an enclosing struct/union */
1279 /*-------------------------------------------------------------------*/
1281 promoteAnonStructs (int su, structdef * sdef)
1290 tofield = &sdef->fields;
1291 field = sdef->fields;
1294 nextfield = field->next;
1295 if (!*field->name && IS_STRUCT (field->type))
1297 /* Found an anonymous struct/union. Replace it */
1298 /* with the fields it contains and adjust all */
1301 base = field->offset;
1302 subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields);
1304 continue; /* just in case it's empty */
1306 *tofield = subfield;
1309 /* check for field name conflicts resulting from promotion */
1310 dupfield = sdef->fields;
1311 while (dupfield && dupfield != subfield)
1313 if (*subfield->name && !strcmp (dupfield->name, subfield->name))
1315 werrorfl (subfield->fileDef, subfield->lineDef,
1317 su==STRUCT ? "struct" : "union",
1319 werrorfl (dupfield->fileDef, dupfield->lineDef,
1322 dupfield = dupfield->next;
1325 subfield->offset += base;
1327 subfield = subfield->next;
1331 subfield->next = nextfield;
1332 tofield = &subfield->next;
1335 tofield = &field->next;
1341 /*------------------------------------------------------------------*/
1342 /* checkSClass - check the storage class specification */
1343 /*------------------------------------------------------------------*/
1345 checkSClass (symbol * sym, int isProto)
1349 if (getenv("DEBUG_SANITY")) {
1350 fprintf (stderr, "checkSClass: %s \n", sym->name);
1353 /* type is literal can happen for enums change
1355 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1356 SPEC_SCLS (sym->etype) = S_AUTO;
1358 /* if sfr or sbit then must also be volatile */
1359 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1360 SPEC_SCLS (sym->etype) == S_SFR)
1362 SPEC_VOLATILE (sym->etype) = 1;
1365 /* if absolute address given then it mark it as
1366 volatile -- except in the PIC port */
1368 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1369 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1370 if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1373 if (IS_ABSOLUTE (sym->etype))
1374 SPEC_VOLATILE (sym->etype) = 1;
1376 /* If code memory is read only, then pointers to code memory */
1377 /* implicitly point to constants -- make this explicit */
1379 while (t && t->next) {
1380 if (IS_CODEPTR(t) && port->mem.code_ro) {
1381 if (IS_SPEC(t->next)) {
1382 SPEC_CONST (t->next) = 1;
1384 DCL_PTR_CONST (t->next) = 1;
1390 /* global variables declared const put into code */
1391 /* if no other storage class specified */
1392 if (sym->level == 0 &&
1393 SPEC_SCLS(sym->etype) == S_FIXED &&
1394 !IS_FUNC(sym->type)) {
1395 /* find the first non-array link */
1399 if (IS_CONSTANT (t)) {
1400 SPEC_SCLS (sym->etype) = S_CODE;
1404 /* global variable in code space is a constant */
1405 if (sym->level == 0 &&
1406 SPEC_SCLS (sym->etype) == S_CODE &&
1407 port->mem.code_ro) {
1408 /* find the first non-array link */
1415 DCL_PTR_CONST (t) = 1;
1419 /* if bit variable then no storage class can be */
1420 /* specified since bit is already a storage */
1421 if (IS_BITVAR (sym->etype) &&
1422 (SPEC_SCLS (sym->etype) != S_FIXED &&
1423 SPEC_SCLS (sym->etype) != S_SBIT &&
1424 SPEC_SCLS (sym->etype) != S_BIT)
1427 werror (E_BITVAR_STORAGE, sym->name);
1428 SPEC_SCLS (sym->etype) = S_FIXED;
1431 /* extern variables cannot be initialized */
1432 if (IS_EXTERN (sym->etype) && sym->ival)
1434 werror (E_EXTERN_INIT, sym->name);
1438 /* if this is an automatic symbol */
1439 if (sym->level && (options.stackAuto || reentrant)) {
1440 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1441 SPEC_SCLS (sym->etype) == S_FIXED ||
1442 SPEC_SCLS (sym->etype) == S_REGISTER ||
1443 SPEC_SCLS (sym->etype) == S_STACK ||
1444 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1445 SPEC_SCLS (sym->etype) = S_AUTO;
1447 /* storage class may only be specified for statics */
1448 if (!IS_STATIC(sym->etype)) {
1449 werror (E_AUTO_ASSUMED, sym->name);
1454 /* automatic symbols cannot be given */
1455 /* an absolute address ignore it */
1457 SPEC_ABSA (sym->etype) &&
1458 (options.stackAuto || reentrant))
1460 werror (E_AUTO_ABSA, sym->name);
1461 SPEC_ABSA (sym->etype) = 0;
1464 /* arrays & pointers cannot be defined for bits */
1465 /* SBITS or SFRs or BIT */
1466 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1467 (SPEC_NOUN (sym->etype) == V_BIT ||
1468 SPEC_NOUN (sym->etype) == V_SBIT ||
1469 SPEC_NOUN (sym->etype) == V_BITFIELD ||
1470 SPEC_SCLS (sym->etype) == S_SFR))
1471 werror (E_BIT_ARRAY, sym->name);
1473 /* if this is a bit|sbit then set length & start */
1474 if (SPEC_NOUN (sym->etype) == V_BIT ||
1475 SPEC_NOUN (sym->etype) == V_SBIT)
1477 SPEC_BLEN (sym->etype) = 1;
1478 SPEC_BSTR (sym->etype) = 0;
1482 /* variables declared in CODE space must have */
1483 /* initializers if not an extern */
1484 if (SPEC_SCLS (sym->etype) == S_CODE &&
1485 sym->ival == NULL &&
1488 port->mem.code_ro &&
1489 !IS_EXTERN (sym->etype) &&
1490 !funcInChain (sym->type))
1491 werror (E_CODE_NO_INIT, sym->name);
1494 /* if parameter or local variable then change */
1495 /* the storage class to reflect where the var will go */
1496 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED
1497 && !IS_STATIC(sym->etype)
1500 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1502 SPEC_SCLS (sym->etype) = (options.useXstack ?
1503 S_XSTACK : S_STACK);
1507 /* hack-o-matic! I see no reason why the useXstack option should ever
1508 * control this allocation, but the code was originally that way, and
1509 * changing it for non-390 ports breaks the compiler badly.
1511 bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1512 1 : options.useXstack;
1513 SPEC_SCLS (sym->etype) = (useXdata ?
1519 /*------------------------------------------------------------------*/
1520 /* changePointer - change pointer to functions */
1521 /*------------------------------------------------------------------*/
1523 changePointer (sym_link * p)
1526 /* go thru the chain of declarations */
1527 /* if we find a pointer to a function */
1528 /* unconditionally change it to a ptr */
1530 for (; p; p = p->next)
1532 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1533 DCL_TYPE (p) = port->unqualified_pointer;
1534 if (IS_PTR (p) && IS_FUNC (p->next))
1535 DCL_TYPE (p) = CPOINTER;
1539 /*------------------------------------------------------------------*/
1540 /* checkDecl - does semantic validation of a declaration */
1541 /*------------------------------------------------------------------*/
1543 checkDecl (symbol * sym, int isProto)
1546 checkSClass (sym, isProto); /* check the storage class */
1547 changePointer (sym->type); /* change pointers if required */
1549 /* if this is an array without any dimension
1550 then update the dimension from the initial value */
1551 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1552 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1557 /*------------------------------------------------------------------*/
1558 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1559 /*------------------------------------------------------------------*/
1561 copyLinkChain (sym_link * p)
1563 sym_link *head, *curr, *loop;
1566 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1569 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1570 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1578 /*------------------------------------------------------------------*/
1579 /* cleanUpBlock - cleansup the symbol table specified for all the */
1580 /* symbols in the given block */
1581 /*------------------------------------------------------------------*/
1583 cleanUpBlock (bucket ** table, int block)
1588 /* go thru the entire table */
1589 for (i = 0; i < 256; i++)
1591 for (chain = table[i]; chain; chain = chain->next)
1593 if (chain->block >= block)
1595 deleteSym (table, chain->sym, chain->name);
1601 /*------------------------------------------------------------------*/
1602 /* cleanUpLevel - cleansup the symbol table specified for all the */
1603 /* symbols in the given level */
1604 /*------------------------------------------------------------------*/
1606 cleanUpLevel (bucket ** table, int level)
1611 /* go thru the entire table */
1612 for (i = 0; i < 256; i++)
1614 for (chain = table[i]; chain; chain = chain->next)
1616 if (chain->level >= level)
1618 deleteSym (table, chain->sym, chain->name);
1624 /*------------------------------------------------------------------*/
1625 /* computeTypeOr - computes the resultant type from two types */
1626 /*------------------------------------------------------------------*/
1628 computeTypeOr (sym_link * etype1, sym_link * etype2, sym_link * reType)
1631 assert ( (IS_CHAR (etype1) || IS_BIT (etype1))
1632 && (IS_CHAR (etype2) || IS_BIT (etype2)));
1634 if (SPEC_USIGN (etype1) == SPEC_USIGN (etype2))
1636 SPEC_USIGN (reType) = SPEC_USIGN (etype1);
1640 if (SPEC_USIGN (etype1))
1642 if ( IS_LITERAL (etype2)
1643 && floatFromVal (valFromType (etype2)) >= 0)
1644 SPEC_USIGN (reType) = 1;
1647 /* promote to int */
1648 SPEC_USIGN (reType) = 0;
1649 SPEC_NOUN (reType) = V_INT;
1652 else /* etype1 signed */
1654 if ( IS_LITERAL (etype2)
1655 && floatFromVal (valFromType (etype2)) <= 127)
1656 SPEC_USIGN (reType) = 0;
1659 /* promote to int */
1660 SPEC_USIGN (reType) = 0;
1661 SPEC_NOUN (reType) = V_INT;
1665 if (SPEC_USIGN (etype2))
1667 if ( IS_LITERAL (etype1)
1668 && floatFromVal (valFromType (etype1)) >= 0)
1669 SPEC_USIGN (reType) = 1;
1672 /* promote to int */
1673 SPEC_USIGN (reType) = 0;
1674 SPEC_NOUN (reType) = V_INT;
1677 else /* etype2 signed */
1679 if ( IS_LITERAL (etype1)
1680 && floatFromVal (valFromType (etype1)) <= 127)
1681 SPEC_USIGN (reType) = 0;
1684 /* promote to int */
1685 SPEC_USIGN (reType) = 0;
1686 SPEC_NOUN (reType) = V_INT;
1692 /*------------------------------------------------------------------*/
1693 /* computeType - computes the resultant type from two types */
1694 /*------------------------------------------------------------------*/
1696 computeType (sym_link * type1, sym_link * type2,
1697 RESULT_TYPE resultType, int op)
1701 sym_link *etype1 = getSpec (type1);
1704 etype2 = type2 ? getSpec (type2) : type1;
1706 /* if one of them is a float then result is a float */
1707 /* here we assume that the types passed are okay */
1708 /* and can be cast to one another */
1709 /* which ever is greater in size */
1710 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1711 rType = newFloatLink ();
1713 /* if both are bitvars choose the larger one */
1714 if (IS_BITVAR (etype1) && IS_BITVAR (etype2))
1716 rType = SPEC_BLEN (etype1) >= SPEC_BLEN (etype2) ?
1717 copyLinkChain (type1) : copyLinkChain (type1);
1719 /* if only one of them is a bit variable
1720 then the other one prevails */
1721 else if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1723 rType = copyLinkChain (type2);
1724 /* bitfield can have up to 16 bits */
1725 if (getSize (etype1) > 1)
1726 SPEC_NOUN (getSpec (rType)) = V_INT;
1728 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1730 rType = copyLinkChain (type1);
1731 /* bitfield can have up to 16 bits */
1732 if (getSize (etype2) > 1)
1733 SPEC_NOUN (getSpec (rType)) = V_INT;
1736 /* if one of them is a pointer or array then that
1738 if (IS_PTR (type1) || IS_ARRAY (type1))
1739 rType = copyLinkChain (type1);
1740 else if (IS_PTR (type2) || IS_ARRAY (type2))
1741 rType = copyLinkChain (type2);
1742 else if (getSize (type1) > getSize (type2))
1743 rType = copyLinkChain (type1);
1745 rType = copyLinkChain (type2);
1747 reType = getSpec (rType);
1749 /* avoid conflicting types */
1750 reType->select.s._signed = 0;
1752 /* if result is a literal then make not so */
1753 if (IS_LITERAL (reType))
1754 SPEC_SCLS (reType) = S_REGISTER;
1758 case RESULT_TYPE_CHAR:
1759 if (IS_BITVAR (reType))
1761 SPEC_NOUN (reType) = V_CHAR;
1762 SPEC_SCLS (reType) = 0;
1763 SPEC_USIGN (reType) = 0;
1767 case RESULT_TYPE_INT:
1768 case RESULT_TYPE_NONE:
1769 case RESULT_TYPE_OTHER:
1770 if (IS_BIT (reType))
1772 SPEC_NOUN (reType) = V_CHAR;
1773 SPEC_SCLS (reType) = 0;
1774 SPEC_USIGN (reType) = 0;
1777 else if (IS_BITFIELD (reType))
1779 /* could be smarter, but it depends on the op */
1780 /* this is for the worst case: a multiplication of 4 * 4 bit */
1781 SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT;
1782 SPEC_SCLS (reType) = 0;
1783 SPEC_USIGN (reType) = 0;
1786 else if (IS_CHAR (reType))
1788 if (op == '|' || op == '^')
1789 return computeTypeOr (etype1, etype2, reType);
1791 && SPEC_USIGN (etype1) != SPEC_USIGN (etype2))
1793 SPEC_USIGN (reType) = 1;
1798 SPEC_NOUN (reType) = V_INT;
1799 SPEC_USIGN (reType) = 0;
1802 /* TODO: should be in SDCCast.c */
1804 && ( !SPEC_USIGN (etype1)
1805 || !SPEC_USIGN (etype2)))
1807 SPEC_NOUN (reType) = V_INT;
1808 SPEC_USIGN (reType) = 0;
1817 /* SDCC's sign promotion:
1818 - if one or both operands are unsigned, the resultant type will be unsigned
1819 (except char, see below)
1820 - if an operand is promoted to a larger type (char -> int, int -> long),
1821 the larger type will be signed
1823 SDCC tries hard to avoid promotion to int and does 8 bit calculation as
1824 much as possible. We're leaving ISO IEC 9899 here and have to extrapolate
1825 the standard. The standard demands, that the result has to be the same
1826 "as if" the promotion would have been performed:
1828 - if the result of an operation with two char's is promoted to a
1829 larger type, the result will be signed.
1831 More sophisticated are these:
1832 - if the result of an operation with two char's is a char again,
1833 the result will only then be unsigned, if both operands are
1834 unsigned. In all other cases the result will be signed.
1836 This seems to be contradictionary to the first two rules, but it makes
1837 real sense (all types are char's):
1839 A signed char can be negative; this must be preserved in the result
1842 Only if both operands are unsigned it's safe to make the result
1843 unsigned; this helps to avoid overflow:
1846 - ToDo: document '|', '^' and '&'
1848 Homework: - why is (200 * 200 < 0) true?
1849 - why is { char l = 200, r = 200; (r * l > 0) } true?
1852 if (!IS_FLOAT (reType)
1853 && ( (SPEC_USIGN (etype1)
1854 /* if this operand is promoted to a larger type,
1855 then it will be promoted to a signed type */
1856 && !(getSize (etype1) < getSize (reType))
1857 /* char require special handling */
1858 && !IS_CHAR (etype1))
1859 || /* same for 2nd operand */
1860 (SPEC_USIGN (etype2)
1861 && !(getSize (etype2) < getSize (reType))
1862 && !IS_CHAR (etype2))
1863 || /* if both are 'unsigned char' and not promoted
1864 let the result be unsigned too */
1865 ( SPEC_USIGN (etype1)
1866 && SPEC_USIGN (etype2)
1869 && IS_CHAR (reType))))
1870 SPEC_USIGN (reType) = 1;
1872 SPEC_USIGN (reType) = 0;
1877 /*--------------------------------------------------------------------*/
1878 /* compareType - will do type check return 1 if match, -1 if castable */
1879 /*--------------------------------------------------------------------*/
1881 compareType (sym_link * dest, sym_link * src)
1892 /* if dest is a declarator then */
1897 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1899 //checkFunction(src,dest);
1901 return compareType (dest->next, src->next);
1903 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1907 (IS_GENPTR (dest) ||
1908 ((DCL_TYPE(src) == POINTER) && (DCL_TYPE(dest) == IPOINTER))
1911 if (IS_PTR (dest) && IS_ARRAY (src)) {
1912 value *val=aggregateToPointer (valFromType(src));
1913 int res=compareType (dest, val->type);
1914 Safe_free(val->type);
1918 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1919 return compareType (dest->next, src);
1922 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1928 /* if one is a specifier and the other is not */
1929 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1930 (IS_SPEC (dest) && !IS_SPEC (src)))
1933 /* if one of them is a void then ok */
1934 if (SPEC_NOUN (dest) == V_VOID &&
1935 SPEC_NOUN (src) != V_VOID)
1938 if (SPEC_NOUN (dest) != V_VOID &&
1939 SPEC_NOUN (src) == V_VOID)
1942 /* if they are both bitfields then if the lengths
1943 and starts don't match */
1944 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1945 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1946 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1949 /* it is a specifier */
1950 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1952 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1953 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1955 bitsForType (dest) == bitsForType (src))
1956 instead of the next two lines, but the regression tests fail with
1957 them; I guess it's a problem with replaceCheaperOp */
1958 getSize (dest) == getSize (src) &&
1959 !(!IS_BIT (dest) && IS_BIT (src)))
1961 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1966 else if (IS_STRUCT (dest))
1968 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1973 if (SPEC_LONG (dest) != SPEC_LONG (src))
1976 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1982 /*--------------------------------------------------------------------*/
1983 /* compareTypeExact - will do type check return 1 if match exactly */
1984 /*--------------------------------------------------------------------*/
1986 compareTypeExact (sym_link * dest, sym_link * src, int level)
1988 STORAGE_CLASS srcScls, destScls;
1999 /* if dest is a declarator then */
2004 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2005 if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
2007 if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
2009 if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
2013 value *exargs, *acargs, *checkValue;
2015 /* verify function return type */
2016 if (!compareTypeExact (dest->next, src->next, -1))
2018 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
2020 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
2022 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
2025 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
2029 /* compare expected args with actual args */
2030 exargs = FUNC_ARGS(dest);
2031 acargs = FUNC_ARGS(src);
2033 /* for all the expected args do */
2034 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
2036 //checkTypeSanity(acargs->etype, acargs->name);
2038 if (IS_AGGREGATE (acargs->type))
2040 checkValue = copyValue (acargs);
2041 aggregateToPointer (checkValue);
2044 checkValue = acargs;
2047 if (!compareTypeExact (exargs->type, checkValue->type, -1))
2052 /* if one them ended we have a problem */
2053 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2054 (!exargs && acargs && !IS_VOID (acargs->type)))
2058 return compareTypeExact (dest->next, src->next, level);
2065 /* if one is a specifier and the other is not */
2066 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2067 (IS_SPEC (dest) && !IS_SPEC (src)))
2070 /* if one of them is a void then ok */
2071 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2074 /* if they are both bitfields then if the lengths
2075 and starts don't match */
2076 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2077 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2078 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2081 if (IS_INTEGRAL (dest))
2083 /* signedness must match */
2084 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2086 /* size must match */
2087 if (SPEC_LONG (dest) != SPEC_LONG (src))
2089 if (SPEC_SHORT (dest) != SPEC_SHORT (src))
2093 if (IS_STRUCT (dest))
2095 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2099 if (SPEC_CONST (dest) != SPEC_CONST (src))
2101 if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
2103 if (SPEC_STAT (dest) != SPEC_STAT (src))
2105 if (SPEC_ABSA (dest) != SPEC_ABSA (src))
2107 if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
2110 destScls = SPEC_SCLS (dest);
2111 srcScls = SPEC_SCLS (src);
2113 /* Compensate for const to const code change in checkSClass() */
2114 if (!level & port->mem.code_ro && SPEC_CONST (dest))
2116 if (srcScls == S_CODE && destScls == S_FIXED)
2118 if (destScls == S_CODE && srcScls == S_FIXED)
2122 /* compensate for allocGlobal() */
2123 if ((srcScls == S_FIXED || srcScls == S_AUTO)
2124 && port->mem.default_globl_map == xdata
2128 if (level>0 && !SPEC_STAT (dest))
2130 /* Compensate for hack-o-matic in checkSClass() */
2131 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
2133 if (destScls == S_FIXED)
2134 destScls = (options.useXstack ? S_XSTACK : S_STACK);
2135 if (srcScls == S_FIXED)
2136 srcScls = (options.useXstack ? S_XSTACK : S_STACK);
2138 else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
2140 if (destScls == S_FIXED)
2142 if (srcScls == S_FIXED)
2147 if (srcScls != destScls)
2150 printf ("level = %d\n", level);
2151 printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
2152 SPEC_SCLS (src), SPEC_SCLS (dest));
2153 printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
2161 /*------------------------------------------------------------------*/
2162 /* inCalleeSaveList - return 1 if found in callee save list */
2163 /*------------------------------------------------------------------*/
2165 calleeCmp(void *p1, void *p2)
2167 return (strcmp((char *)p1, (char *)(p2)) == 0);
2171 inCalleeSaveList(char *s)
2173 if (options.all_callee_saves)
2175 return isinSetWith(options.calleeSavesSet, s, calleeCmp);
2178 /*-----------------------------------------------------------------*/
2179 /* aggregateToPointer: change an agggregate type function */
2180 /* argument to a pointer to that type. */
2181 /*-----------------------------------------------------------------*/
2183 aggregateToPointer (value * val)
2185 if (IS_AGGREGATE (val->type))
2187 /* if this is a structure */
2188 /* then we need to add a new link */
2189 if (IS_STRUCT (val->type))
2191 /* first lets add DECLARATOR type */
2192 sym_link *p = val->type;
2194 werror (W_STRUCT_AS_ARG, val->name);
2195 val->type = newLink (DECLARATOR);
2196 val->type->next = p;
2199 /* change to a pointer depending on the */
2200 /* storage class specified */
2201 switch (SPEC_SCLS (val->etype))
2204 DCL_TYPE (val->type) = IPOINTER;
2207 DCL_TYPE (val->type) = PPOINTER;
2210 if (SPEC_OCLS(val->etype)) {
2211 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
2213 // this happens for (external) function parameters
2214 DCL_TYPE (val->type) = port->unqualified_pointer;
2220 DCL_TYPE (val->type) = POINTER;
2223 DCL_TYPE (val->type) = CPOINTER;
2226 DCL_TYPE (val->type) = FPOINTER;
2229 DCL_TYPE (val->type) = EEPPOINTER;
2232 DCL_TYPE (val->type) = port->unqualified_pointer;
2235 /* is there is a symbol associated then */
2236 /* change the type of the symbol as well */
2239 val->sym->type = copyLinkChain (val->type);
2240 val->sym->etype = getSpec (val->sym->type);
2245 /*------------------------------------------------------------------*/
2246 /* checkFunction - does all kinds of check on a function */
2247 /*------------------------------------------------------------------*/
2249 checkFunction (symbol * sym, symbol *csym)
2251 value *exargs, *acargs;
2255 if (getenv("DEBUG_SANITY")) {
2256 fprintf (stderr, "checkFunction: %s ", sym->name);
2259 if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
2261 werror(E_SYNTAX_ERROR, sym->name);
2265 /* make sure the type is complete and sane */
2266 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
2268 /* if not type then some kind of error */
2272 /* if the function has no type then make it return int */
2273 if (!sym->type->next)
2274 sym->type->next = sym->etype = newIntLink ();
2276 /* function cannot return aggregate */
2277 if (IS_AGGREGATE (sym->type->next))
2279 werror (E_FUNC_AGGR, sym->name);
2283 /* function cannot return bit */
2284 if (IS_BITVAR (sym->type->next))
2286 werror (E_FUNC_BIT, sym->name);
2290 /* check if this function is defined as calleeSaves
2291 then mark it as such */
2292 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
2294 /* if interrupt service routine */
2295 /* then it cannot have arguments */
2296 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
2298 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
2299 werror (E_INT_ARGS, sym->name);
2300 FUNC_ARGS(sym->type)=NULL;
2304 if (IFFUNC_ISSHADOWREGS(sym->type) && !FUNC_ISISR (sym->type))
2306 werror (E_SHADOWREGS_NO_ISR, sym->name);
2310 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
2312 acargs=acargs->next, argCnt++) {
2314 // this can happen for reentrant functions
2315 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2316 // the show must go on: synthesize a name and symbol
2317 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
2318 acargs->sym = newSymbol (acargs->name, 1);
2319 SPEC_OCLS (acargs->etype) = istack;
2320 acargs->sym->type = copyLinkChain (acargs->type);
2321 acargs->sym->etype = getSpec (acargs->sym->type);
2322 acargs->sym->_isparm = 1;
2323 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2324 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2326 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2331 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2332 return 1; /* not defined nothing more to check */
2334 /* check if body already present */
2335 if (csym && IFFUNC_HASBODY(csym->type))
2337 werror (E_FUNC_BODY, sym->name);
2341 /* check the return value type */
2342 if (compareType (csym->type, sym->type) <= 0)
2344 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2345 printFromToType(csym->type, sym->type);
2349 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2351 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2354 /* I don't think this is necessary for interrupts. An isr is a */
2355 /* root in the calling tree. */
2356 if ((FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type)) &&
2357 (!FUNC_ISISR (sym->type)))
2359 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2362 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2364 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2367 /* Really, reentrant should match regardless of argCnt, but */
2368 /* this breaks some existing code (the fp lib functions). If */
2369 /* the first argument is always passed the same way, this */
2370 /* lax checking is ok (but may not be true for in future ports) */
2371 if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2374 //printf("argCnt = %d\n",argCnt);
2375 werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2378 if (IFFUNC_ISWPARAM (csym->type) != IFFUNC_ISWPARAM (sym->type))
2380 werror (E_PREV_DEF_CONFLICT, csym->name, "wparam");
2383 if (IFFUNC_ISSHADOWREGS (csym->type) != IFFUNC_ISSHADOWREGS (sym->type))
2385 werror (E_PREV_DEF_CONFLICT, csym->name, "shadowregs");
2389 /* compare expected args with actual args */
2390 exargs = FUNC_ARGS(csym->type);
2391 acargs = FUNC_ARGS(sym->type);
2393 /* for all the expected args do */
2396 exargs = exargs->next, acargs = acargs->next, argCnt++)
2398 if (getenv("DEBUG_SANITY")) {
2399 fprintf (stderr, "checkFunction: %s ", exargs->name);
2401 /* make sure the type is complete and sane */
2402 checkTypeSanity(exargs->etype, exargs->name);
2404 /* If the actual argument is an array, any prototype
2405 * will have modified it to a pointer. Duplicate that
2408 if (IS_AGGREGATE (acargs->type))
2410 checkValue = copyValue (acargs);
2411 aggregateToPointer (checkValue);
2415 checkValue = acargs;
2418 if (compareType (exargs->type, checkValue->type) <= 0)
2420 werror (E_ARG_TYPE, argCnt);
2421 printFromToType(exargs->type, checkValue->type);
2426 /* if one them ended we have a problem */
2427 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2428 (!exargs && acargs && !IS_VOID (acargs->type)))
2429 werror (E_ARG_COUNT);
2431 /* replace with this defition */
2432 sym->cdef = csym->cdef;
2433 deleteSym (SymbolTab, csym, csym->name);
2434 deleteFromSeg(csym);
2435 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2436 if (IS_EXTERN (csym->etype) && !
2437 IS_EXTERN (sym->etype))
2439 addSet (&publics, sym);
2444 /*------------------------------------------------------------------*/
2445 /* cdbStructBlock - calls struct printing for a blcks */
2446 /*------------------------------------------------------------------*/
2447 void cdbStructBlock (int block)
2450 bucket **table = StructTab;
2453 /* go thru the entire table */
2454 for (i = 0; i < 256; i++)
2456 for (chain = table[i]; chain; chain = chain->next)
2458 if (chain->block >= block)
2461 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2467 /*-----------------------------------------------------------------*/
2468 /* processFuncArgs - does some processing with function args */
2469 /*-----------------------------------------------------------------*/
2471 processFuncArgs (symbol * func)
2475 sym_link *funcType=func->type;
2477 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2478 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2480 /* find the function declaration within the type */
2481 while (funcType && !IS_FUNC(funcType))
2482 funcType=funcType->next;
2484 /* if this function has variable argument list */
2485 /* then make the function a reentrant one */
2486 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2487 FUNC_ISREENT(funcType)=1;
2489 /* check if this function is defined as calleeSaves
2490 then mark it as such */
2491 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2493 /* loop thru all the arguments */
2494 val = FUNC_ARGS(funcType);
2496 /* if it is void then remove parameters */
2497 if (val && IS_VOID (val->type))
2499 FUNC_ARGS(funcType) = NULL;
2503 /* reset regparm for the port */
2504 (*port->reset_regparms) ();
2506 /* if any of the arguments is an aggregate */
2507 /* change it to pointer to the same type */
2511 char buffer[SDCC_NAME_MAX+1];
2513 SNPRINTF (buffer, sizeof(buffer), "%s parameter %d", func->name, pNum);
2514 checkTypeSanity (val->etype, buffer);
2516 /* mark it as a register parameter if
2517 the function does not have VA_ARG
2518 and as port dictates */
2519 if (!IFFUNC_HASVARARGS(funcType) &&
2520 (argreg = (*port->reg_parm) (val->type)))
2522 SPEC_REGPARM (val->etype) = 1;
2523 SPEC_ARGREG(val->etype) = argreg;
2524 } else if (IFFUNC_ISREENT(funcType)) {
2525 FUNC_HASSTACKPARM(funcType) = 1;
2528 if (IS_AGGREGATE (val->type))
2530 aggregateToPointer (val);
2537 /* if this is an internal generated function call */
2539 /* ignore --stack-auto for this one, we don't know how it is compiled */
2540 /* simply trust on --int-long-reent or --float-reent */
2541 if (IFFUNC_ISREENT(funcType)) {
2545 /* if this function is reentrant or */
2546 /* automatics r 2b stacked then nothing */
2547 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2551 val = FUNC_ARGS(funcType);
2556 /* if a symbolname is not given */
2557 /* synthesize a variable name */
2560 SNPRINTF (val->name, sizeof(val->name),
2561 "_%s_PARM_%d", func->name, pNum++);
2562 val->sym = newSymbol (val->name, 1);
2563 if (SPEC_SCLS(val->etype) == S_BIT)
2564 SPEC_OCLS (val->etype) = bit;
2566 SPEC_OCLS (val->etype) = port->mem.default_local_map;
2567 val->sym->type = copyLinkChain (val->type);
2568 val->sym->etype = getSpec (val->sym->type);
2569 val->sym->_isparm = 1;
2570 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2572 /* ?? static functions shouldn't imply static parameters - EEP */
2573 if (IS_SPEC(func->etype)) {
2574 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2575 SPEC_STAT (func->etype);
2578 addSymChain (&val->sym);
2581 else /* symbol name given create synth name */
2584 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2585 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2586 val->sym->_isparm = 1;
2587 if (SPEC_SCLS(val->etype) == S_BIT)
2588 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = bit;
2590 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2591 (options.model != MODEL_SMALL ? xdata : data);
2594 /* ?? static functions shouldn't imply static parameters - EEP */
2595 if (IS_SPEC(func->etype)) {
2596 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2597 SPEC_STAT (func->etype);
2601 if (!isinSet(operKeyReset, val->sym)) {
2602 addSet (&operKeyReset, val->sym);
2603 applyToSet (operKeyReset, resetParmKey);
2609 /*-----------------------------------------------------------------*/
2610 /* isSymbolEqual - compares two symbols return 1 if they match */
2611 /*-----------------------------------------------------------------*/
2613 isSymbolEqual (symbol * dest, symbol * src)
2615 /* if pointers match then equal */
2619 /* if one of them is null then don't match */
2623 /* if both of them have rname match on rname */
2624 if (dest->rname[0] && src->rname[0])
2625 return (!strcmp (dest->rname, src->rname));
2627 /* otherwise match on name */
2628 return (!strcmp (dest->name, src->name));
2631 void PT(sym_link *type)
2633 printTypeChain(type,0);
2635 /*-----------------------------------------------------------------*/
2636 /* printTypeChain - prints the type chain in human readable form */
2637 /*-----------------------------------------------------------------*/
2639 printTypeChain (sym_link * start, FILE * of)
2643 sym_link * type, * search;
2653 fprintf (of, "void");
2657 /* Print the chain as it is written in the source: */
2658 /* start with the last entry. */
2659 /* However, the storage class at the end of the */
2660 /* chain reall applies to the first in the chain! */
2662 for (type = start; type && type->next; type = type->next)
2665 scls=SPEC_SCLS(type);
2673 case S_DATA: fprintf (of, "data-"); break;
2674 case S_XDATA: fprintf (of, "xdata-"); break;
2675 case S_SFR: fprintf (of, "sfr-"); break;
2676 case S_SBIT: fprintf (of, "sbit-"); break;
2677 case S_CODE: fprintf (of, "code-"); break;
2678 case S_IDATA: fprintf (of, "idata-"); break;
2679 case S_PDATA: fprintf (of, "pdata-"); break;
2680 case S_LITERAL: fprintf (of, "literal-"); break;
2681 case S_STACK: fprintf (of, "stack-"); break;
2682 case S_XSTACK: fprintf (of, "xstack-"); break;
2683 case S_BIT: fprintf (of, "bit-"); break;
2684 case S_EEPROM: fprintf (of, "eeprom-"); break;
2691 if (!IS_FUNC(type)) {
2692 if (DCL_PTR_VOLATILE (type)) {
2693 fprintf (of, "volatile-");
2695 if (DCL_PTR_CONST (type)) {
2696 fprintf (of, "const-");
2699 switch (DCL_TYPE (type))
2702 fprintf (of, "function %s %s",
2703 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2704 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2706 for (args = FUNC_ARGS(type);
2709 printTypeChain(args->type, of);
2716 fprintf (of, "generic* ");
2719 fprintf (of, "code* ");
2722 fprintf (of, "xdata* ");
2725 fprintf (of, "eeprom* ");
2728 fprintf (of, "near* ");
2731 fprintf (of, "idata* ");
2734 fprintf (of, "pdata* ");
2737 fprintf (of, "unknown* ");
2740 if (DCL_ELEM(type)) {
2741 fprintf (of, "[%d] ", DCL_ELEM(type));
2743 fprintf (of, "[] ");
2750 if (SPEC_VOLATILE (type))
2751 fprintf (of, "volatile-");
2752 if (SPEC_CONST (type))
2753 fprintf (of, "const-");
2754 if (SPEC_USIGN (type))
2755 fprintf (of, "unsigned-");
2756 switch (SPEC_NOUN (type))
2760 fprintf (of, "long-");
2761 fprintf (of, "int");
2765 fprintf (of, "char");
2769 fprintf (of, "void");
2773 fprintf (of, "float");
2777 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2781 fprintf (of, "sbit");
2785 fprintf (of, "bit");
2789 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2793 fprintf (of, "double");
2797 fprintf (of, "unknown type");
2801 /* search entry in list before "type" */
2802 for (search = start; search && search->next != type;)
2803 search = search->next;
2812 /*--------------------------------------------------------------------*/
2813 /* printTypeChainRaw - prints the type chain in human readable form */
2814 /* in the raw data structure ordering */
2815 /*--------------------------------------------------------------------*/
2817 printTypeChainRaw (sym_link * start, FILE * of)
2830 fprintf (of, "void");
2840 if (!IS_FUNC(type)) {
2841 if (DCL_PTR_VOLATILE (type)) {
2842 fprintf (of, "volatile-");
2844 if (DCL_PTR_CONST (type)) {
2845 fprintf (of, "const-");
2848 switch (DCL_TYPE (type))
2851 fprintf (of, "function %s %s",
2852 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2853 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2855 for (args = FUNC_ARGS(type);
2858 printTypeChain(args->type, of);
2865 fprintf (of, "generic* ");
2868 fprintf (of, "code* ");
2871 fprintf (of, "xdata* ");
2874 fprintf (of, "eeprom* ");
2877 fprintf (of, "near* ");
2880 fprintf (of, "idata* ");
2883 fprintf (of, "pdata* ");
2886 fprintf (of, "unknown* ");
2889 if (DCL_ELEM(type)) {
2890 fprintf (of, "[%d] ", DCL_ELEM(type));
2892 fprintf (of, "[] ");
2896 if (DCL_TSPEC(type))
2899 printTypeChainRaw(DCL_TSPEC(type), of);
2903 else if (IS_SPEC (type))
2905 switch (SPEC_SCLS (type))
2907 case S_DATA: fprintf (of, "data-"); break;
2908 case S_XDATA: fprintf (of, "xdata-"); break;
2909 case S_SFR: fprintf (of, "sfr-"); break;
2910 case S_SBIT: fprintf (of, "sbit-"); break;
2911 case S_CODE: fprintf (of, "code-"); break;
2912 case S_IDATA: fprintf (of, "idata-"); break;
2913 case S_PDATA: fprintf (of, "pdata-"); break;
2914 case S_LITERAL: fprintf (of, "literal-"); break;
2915 case S_STACK: fprintf (of, "stack-"); break;
2916 case S_XSTACK: fprintf (of, "xstack-"); break;
2917 case S_BIT: fprintf (of, "bit-"); break;
2918 case S_EEPROM: fprintf (of, "eeprom-"); break;
2921 if (SPEC_VOLATILE (type))
2922 fprintf (of, "volatile-");
2923 if (SPEC_CONST (type))
2924 fprintf (of, "const-");
2925 if (SPEC_USIGN (type))
2926 fprintf (of, "unsigned-");
2927 switch (SPEC_NOUN (type))
2931 fprintf (of, "long-");
2932 fprintf (of, "int");
2936 fprintf (of, "char");
2940 fprintf (of, "void");
2944 fprintf (of, "float");
2948 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2952 fprintf (of, "sbit");
2956 fprintf (of, "bit");
2960 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2964 fprintf (of, "double");
2968 fprintf (of, "unknown type");
2973 fprintf (of, "NOT_SPEC_OR_DECL");
2983 /*-----------------------------------------------------------------*/
2984 /* powof2 - returns power of two for the number if number is pow 2 */
2985 /*-----------------------------------------------------------------*/
2987 powof2 (TYPE_UDWORD num)
3000 if (n1s > 1 || nshifts == 0)
3016 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3017 symbol *__muldiv[3][3][2];
3018 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
3019 sym_link *__multypes[3][2];
3020 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
3021 symbol *__conv[2][3][2];
3022 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3023 symbol *__rlrr[2][3][2];
3025 sym_link *floatType;
3028 _mangleFunctionName(char *in)
3030 if (port->getMangledFunctionName)
3032 return port->getMangledFunctionName(in);
3040 /*-----------------------------------------------------------------*/
3041 /* typeFromStr - create a typechain from an encoded string */
3042 /* basic types - 'c' - char */
3048 /* '*' - pointer - default (GPOINTER) */
3049 /* modifiers - 'u' - unsigned */
3050 /* pointer modifiers - 'g' - generic */
3054 /* 'F' - function */
3055 /* examples : "ig*" - generic int * */
3056 /* "cx*" - char xdata * */
3057 /* "ui" - unsigned int */
3058 /*-----------------------------------------------------------------*/
3059 sym_link *typeFromStr (char *s)
3061 sym_link *r = newLink(DECLARATOR);
3073 r->class = SPECIFIER;
3074 SPEC_NOUN(r) = V_CHAR;
3078 r->class = SPECIFIER;
3079 SPEC_NOUN(r) = V_INT;
3082 r->class = SPECIFIER;
3083 SPEC_NOUN(r) = V_INT;
3087 r->class = SPECIFIER;
3088 SPEC_NOUN(r) = V_FLOAT;
3091 r->class = SPECIFIER;
3092 SPEC_NOUN(r) = V_VOID;
3095 DCL_TYPE(r) = port->unqualified_pointer;
3102 assert(*(s+1)=='*');
3103 nr = newLink(DECLARATOR);
3108 DCL_TYPE(r) = GPOINTER;
3111 DCL_TYPE(r) = FPOINTER;
3114 DCL_TYPE(r) = CPOINTER;
3117 DCL_TYPE(r) = POINTER;
3120 DCL_TYPE(r) = FUNCTION;
3121 nr = newLink(DECLARATOR);
3124 DCL_TYPE(r) = CPOINTER;
3130 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
3131 "typeFromStr: unknown type");
3134 if (IS_SPEC(r) && usign) {
3143 /*-----------------------------------------------------------------*/
3144 /* initCSupport - create functions for C support routines */
3145 /*-----------------------------------------------------------------*/
3149 const char *smuldivmod[] =
3153 const char *sbwd[] =
3155 "char", "int", "long"
3161 const char *srlrr[] =
3166 int bwd, su, muldivmod, tofrom, rlrr;
3168 if (getenv("SDCC_NO_C_SUPPORT")) {
3169 /* for debugging only */
3173 floatType = newFloatLink ();
3175 for (bwd = 0; bwd < 3; bwd++)
3192 __multypes[bwd][0] = l;
3193 __multypes[bwd][1] = copyLinkChain (l);
3194 SPEC_USIGN (__multypes[bwd][1]) = 1;
3197 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
3198 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
3199 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
3200 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
3201 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
3202 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
3203 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
3204 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
3205 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
3206 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
3208 for (tofrom = 0; tofrom < 2; tofrom++)
3210 for (bwd = 0; bwd < 3; bwd++)
3212 for (su = 0; su < 2; su++)
3216 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
3217 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
3221 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
3222 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
3229 for (muldivmod = 0; muldivmod < 3; muldivmod++)
3231 for (bwd = 0; bwd < 3; bwd++)
3233 for (su = 0; su < 2; su++)
3235 SNPRINTF (buffer, sizeof(buffer),
3237 smuldivmod[muldivmod],
3240 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3241 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3246 muluint() and mulsint() resp. mululong() and mulslong() return the same result.
3247 Therefore they've been merged into mulint() and mullong().
3250 for (bwd = 0; bwd < 3; bwd++)
3252 for (su = 0; su < 2; su++)
3254 for (muldivmod = 1; muldivmod < 3; muldivmod++)
3257 SNPRINTF (buffer, sizeof(buffer),
3259 smuldivmod[muldivmod],
3262 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3263 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3271 for (su = 0; su < 2; su++)
3273 /* muluchar and mulschar are still separate functions, because e.g. the z80
3274 port is sign/zero-extending to int before calling mulint() */
3275 SNPRINTF (buffer, sizeof(buffer),
3277 smuldivmod[muldivmod],
3280 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3281 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3285 /* word and doubleword */
3286 for (bwd = 1; bwd < 3; bwd++)
3289 SNPRINTF (buffer, sizeof(buffer),
3291 smuldivmod[muldivmod],
3293 __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3294 FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
3295 /* signed = unsigned */
3296 __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
3299 for (rlrr = 0; rlrr < 2; rlrr++)
3301 for (bwd = 0; bwd < 3; bwd++)
3303 for (su = 0; su < 2; su++)
3305 SNPRINTF (buffer, sizeof(buffer),
3310 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
3311 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
3317 /*-----------------------------------------------------------------*/
3318 /* initBuiltIns - create prototypes for builtin functions */
3319 /*-----------------------------------------------------------------*/
3325 if (!port->builtintable) return ;
3327 for (i = 0 ; port->builtintable[i].name ; i++) {
3328 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
3329 port->builtintable[i].nParms,port->builtintable[i].parm_types);
3330 FUNC_ISBUILTIN(sym->type) = 1;
3331 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
3335 sym_link *validateLink(sym_link *l,
3342 if (l && l->class==select)
3347 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
3348 " expected %s, got %s\n",
3349 macro, args, file, line,
3350 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
3352 return l; // never reached, makes compiler happy.
3355 /*--------------------------------------------------------------------*/
3356 /* newEnumType - create an integer type compatible with enumerations */
3357 /*--------------------------------------------------------------------*/
3359 newEnumType (symbol *enumlist)
3367 type = newLink (SPECIFIER);
3368 SPEC_NOUN (type) = V_INT;
3372 /* Determine the range of the enumerated values */
3374 min = max = (int) floatFromVal (valFromType (sym->type));
3375 for (sym = sym->next; sym; sym = sym->next)
3377 v = (int) floatFromVal (valFromType (sym->type));
3384 /* Determine the smallest integer type that is compatible with this range */
3385 type = newLink (SPECIFIER);
3386 if (min>=0 && max<=255)
3388 SPEC_NOUN (type) = V_CHAR;
3389 SPEC_USIGN (type) = 1;
3391 else if (min>=-128 && max<=127)
3393 SPEC_NOUN (type) = V_CHAR;
3395 else if (min>=0 && max<=65535)
3397 SPEC_NOUN (type) = V_INT;
3398 SPEC_USIGN (type) = 1;
3400 else if (min>=-32768 && max<=32767)
3402 SPEC_NOUN (type) = V_INT;
3406 SPEC_NOUN (type) = V_INT;
3407 SPEC_LONG (type) = 1;
3409 SPEC_USIGN (type) = 1;