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 -------------------------------------------------------------------------*/
26 #include "dbuf_string.h"
30 value *aggregateToPointer (value *val);
31 void printTypeChainRaw (sym_link * start, FILE * of);
33 void printFromToType(sym_link *from, sym_link *to) {
34 fprintf (stderr, "from type '");
35 printTypeChain (from, stderr);
36 fprintf (stderr, "'\nto type '");
37 printTypeChain (to, stderr);
38 fprintf (stderr, "'\n");
42 char *nounName(sym_link *sl) {
43 switch (SPEC_NOUN(sl))
46 if (SPEC_LONG(sl)) return "long";
47 if (SPEC_SHORT(sl)) return "short";
50 case V_FLOAT: return "float";
51 case V_FIXED16X16: return "fixed16x16";
52 case V_CHAR: return "char";
53 case V_VOID: return "void";
54 case V_STRUCT: return "struct";
55 case V_LABEL: return "label";
56 case V_BITFIELD: return "bitfield";
57 case V_BIT: return "bit";
58 case V_SBIT: return "sbit";
59 case V_DOUBLE: return "double";
64 bucket *SymbolTab[256]; /* the symbol table */
65 bucket *StructTab[256]; /* the structure table */
66 bucket *TypedefTab[256]; /* the typedef table */
67 bucket *LabelTab[256]; /* the Label table */
68 bucket *enumTab[256]; /* enumerated table */
70 /*------------------------------------------------------------------*/
71 /* initSymt () - initialises symbol table related stuff */
72 /*------------------------------------------------------------------*/
78 for (i = 0; i < 256; i++)
79 SymbolTab[i] = StructTab[i] = (void *) NULL;
83 /*-----------------------------------------------------------------*/
84 /* newBucket - allocates & returns a new bucket */
85 /*-----------------------------------------------------------------*/
91 bp = Safe_alloc ( sizeof (bucket));
96 /*-----------------------------------------------------------------*/
97 /* hashKey - computes the hashkey given a symbol name */
98 /*-----------------------------------------------------------------*/
100 hashKey (const char *s)
102 unsigned long key = 0;
109 /*-----------------------------------------------------------------*/
110 /* addSym - adds a symbol to the hash Table */
111 /*-----------------------------------------------------------------*/
113 addSym (bucket ** stab,
120 int i; /* index into the hash Table */
121 bucket *bp; /* temp bucket * */
124 symbol *csym = (symbol *)sym;
126 if (getenv("DEBUG_SANITY")) {
127 fprintf (stderr, "addSym: %s ", sname);
129 /* make sure the type is complete and sane */
130 checkTypeSanity(csym->etype, csym->name);
133 /* prevent overflow of the (r)name buffers */
134 if (strlen(sname)>SDCC_SYMNAME_MAX) {
135 werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
136 sname[SDCC_SYMNAME_MAX]='\0';
139 /* the symbols are always added at the head of the list */
141 /* get a free entry */
142 bp = Safe_alloc ( sizeof (bucket));
144 bp->sym = sym; /* update the symbol pointer */
145 bp->level = level; /* update the nest level */
147 strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
149 /* if this is the first entry */
152 bp->prev = bp->next = (void *) NULL; /* point to nothing */
155 /* not first entry then add @ head of list */
165 /*-----------------------------------------------------------------*/
166 /* deleteSym - deletes a symbol from the hash Table entry */
167 /*-----------------------------------------------------------------*/
169 deleteSym (bucket ** stab, void *sym, char *sname)
177 /* find the symbol */
180 if (bp->sym == sym) /* found it then break out */
181 break; /* of the loop */
185 if (!bp) /* did not find it */
187 /* if this is the first one in the chain */
191 if (stab[i]) /* if chain ! empty */
192 stab[i]->prev = (void *) NULL;
194 /* middle || end of chain */
197 if (bp->next) /* if not end of chain */
198 bp->next->prev = bp->prev;
200 bp->prev->next = bp->next;
205 /*-----------------------------------------------------------------*/
206 /* findSym - finds a symbol in a table */
207 /*-----------------------------------------------------------------*/
209 findSym (bucket ** stab, void *sym, const char *sname)
213 bp = stab[hashKey (sname)];
216 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
221 return (bp ? bp->sym : (void *) NULL);
224 /*-----------------------------------------------------------------*/
225 /* findSymWithLevel - finds a symbol with a name & level */
226 /*-----------------------------------------------------------------*/
228 findSymWithLevel (bucket ** stab, symbol * sym)
232 bp = stab[hashKey (sym->name)];
235 ** do the search from the head of the list since the
236 ** elements are added at the head it is ensured that
237 ** we will find the deeper definitions before we find
238 ** the global ones. we need to check for symbols with
239 ** level <= to the level given, if levels match then block
240 ** numbers need to match as well
244 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
246 /* if this is parameter then nothing else need to be checked */
247 if (((symbol *) (bp->sym))->_isparm)
249 /* if levels match then block numbers should also match */
250 if (bp->level && bp->level == sym->level && bp->block == sym->block)
252 /* if levels don't match then we are okay */
253 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
255 /* if this is a global variable then we are ok too */
263 return (void *) NULL;
266 /*-----------------------------------------------------------------*/
267 /* findSymWithBlock - finds a symbol with name in with a block */
268 /*-----------------------------------------------------------------*/
270 findSymWithBlock (bucket ** stab, symbol * sym, int block)
274 bp = stab[hashKey (sym->name)];
277 if (strcmp (bp->name, sym->name) == 0 &&
283 return (bp ? bp->sym : (void *) NULL);
286 /*------------------------------------------------------------------*/
287 /* newSymbol () - returns a new pointer to a symbol */
288 /*------------------------------------------------------------------*/
290 newSymbol (char *name, int scope)
294 sym = Safe_alloc ( sizeof (symbol));
296 strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */
297 sym->level = scope; /* set the level */
298 sym->block = currBlockno;
299 sym->lineDef = lexLineno; /* set the line number */
300 sym->fileDef = lexFilename;
304 /*------------------------------------------------------------------*/
305 /* newLink - creates a new link (declarator,specifier) */
306 /*------------------------------------------------------------------*/
308 newLink (SYM_LINK_CLASS select)
312 p = Safe_alloc ( sizeof (sym_link));
318 /*------------------------------------------------------------------*/
319 /* newStruct - creats a new structdef from the free list */
320 /*------------------------------------------------------------------*/
322 newStruct (char *tag)
326 s = Safe_alloc ( sizeof (structdef));
328 strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
332 /*------------------------------------------------------------------*/
333 /* sclsFromPtr - Return the storage class a pointer points into. */
334 /* S_FIXED is returned for generic pointers or other */
335 /* unexpected cases */
336 /*------------------------------------------------------------------*/
338 sclsFromPtr(sym_link *ptr)
340 switch (DCL_TYPE (ptr))
363 /*------------------------------------------------------------------*/
364 /* pointerTypes - do the computation for the pointer types */
365 /*------------------------------------------------------------------*/
367 pointerTypes (sym_link * ptr, sym_link * type)
372 /* find the first pointer type */
373 while (ptr && !IS_PTR (ptr))
376 /* could not find it */
377 if (!ptr || IS_SPEC (ptr))
380 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
381 pointerTypes (ptr->next, type);
385 /* change the pointer type depending on the
386 storage class of the type */
389 switch (SPEC_SCLS (type))
392 DCL_TYPE (ptr) = FPOINTER;
395 DCL_TYPE (ptr) = IPOINTER;
398 DCL_TYPE (ptr) = PPOINTER;
401 DCL_TYPE (ptr) = POINTER;
404 DCL_TYPE (ptr) = CPOINTER;
407 DCL_TYPE (ptr) = EEPPOINTER;
410 DCL_TYPE (ptr) = port->unqualified_pointer;
413 /* the storage class of type ends here */
414 SPEC_SCLS (type) = 0;
417 /* now change all the remaining unknown pointers
418 to generic pointers */
421 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
422 DCL_TYPE (ptr) = port->unqualified_pointer;
426 /* same for the type although it is highly unlikely that
427 type will have a pointer */
430 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
431 DCL_TYPE (type) = port->unqualified_pointer;
436 /*------------------------------------------------------------------*/
437 /* addDecl - adds a declarator @ the end of a chain */
438 /*------------------------------------------------------------------*/
440 addDecl (symbol * sym, int type, sym_link * p)
442 static sym_link *empty = NULL;
447 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
448 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
451 empty = newLink(SPECIFIER);
453 /* if we are passed a link then set head & tail */
462 head = tail = newLink (DECLARATOR);
463 DCL_TYPE (head) = type;
466 /* if this is the first entry */
472 else if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
474 sym->etype = mergeSpec (sym->etype, head, sym->name);
476 else if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
479 while (t->next != sym->etype)
482 tail->next = sym->etype;
484 else if (IS_FUNC (sym->type) && IS_SPEC (sym->type->next) &&
485 !memcmp(sym->type->next, empty, sizeof(sym_link)))
487 sym->type->next = head;
492 sym->etype->next = head;
496 /* if the type is an unknown pointer and has
497 a tspec then take the storage class const & volatile
498 attribute from the tspec & make it those of this
502 //DCL_TYPE (p) == UPOINTER &&
505 if (!IS_SPEC (sym->etype))
507 sym->etype = sym->etype->next = newLink (SPECIFIER);
509 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
510 DCL_TSPEC (p) = NULL;
513 // if there is a function in this type chain
514 if (p && funcInChain(sym->type)) {
515 processFuncArgs (sym);
521 /*------------------------------------------------------------------
522 checkTypeSanity: prevent the user from doing e.g.:
524 ------------------------------------------------------------------*/
525 void checkTypeSanity(sym_link *etype, char *name) {
529 if (getenv("DEBUG_SANITY")) {
530 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
535 if (!IS_SPEC(etype)) {
536 if (getenv("DEBUG_SANITY")) {
537 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
542 noun=nounName(etype);
544 if (getenv("DEBUG_SANITY")) {
545 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
548 if ((SPEC_NOUN(etype)==V_CHAR ||
549 SPEC_NOUN(etype)==V_FLOAT ||
550 SPEC_NOUN(etype)==V_FIXED16X16 ||
551 SPEC_NOUN(etype)==V_DOUBLE ||
552 SPEC_NOUN(etype)==V_VOID) &&
553 (SPEC_SHORT(etype) || SPEC_LONG(etype))) {
554 // long or short for char float double or void
555 werror (E_LONG_OR_SHORT_INVALID, noun, name);
557 if ((SPEC_NOUN(etype)==V_FLOAT ||
558 SPEC_NOUN(etype)==V_FIXED16X16 ||
559 SPEC_NOUN(etype)==V_DOUBLE ||
560 SPEC_NOUN(etype)==V_VOID) &&
561 (etype->select.s.b_signed || SPEC_USIGN(etype))) {
562 // signed or unsigned for float double or void
563 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
566 // special case for "short"
567 if (SPEC_SHORT(etype)) {
568 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
569 SPEC_SHORT(etype) = 0;
573 "const a;" or "data b;" or "signed s" or "long l"
575 if (!SPEC_NOUN(etype)) {
576 SPEC_NOUN(etype)=V_INT;
579 /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
580 /* a "plain" int bitfield is unsigned */
581 if (SPEC_NOUN(etype)==V_BIT ||
582 SPEC_NOUN(etype)==V_SBIT) {
583 if (!etype->select.s.b_signed)
584 SPEC_USIGN(etype) = 1;
587 if (etype->select.s.b_signed && SPEC_USIGN(etype)) {
588 // signed AND unsigned
589 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
591 if (SPEC_SHORT(etype) && SPEC_LONG(etype)) {
593 werror (E_LONG_AND_SHORT_INVALID, noun, name);
598 /*------------------------------------------------------------------*/
599 /* mergeSpec - merges two specifiers and returns the new one */
600 /*------------------------------------------------------------------*/
602 mergeSpec (sym_link * dest, sym_link * src, char *name)
604 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
606 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
609 werror (E_SYNTAX_ERROR, yytext);
610 // the show must go on
615 if (SPEC_NOUN(src)) {
616 if (!SPEC_NOUN(dest)) {
617 SPEC_NOUN(dest)=SPEC_NOUN(src);
619 /* we shouldn't redeclare the type */
620 if (getenv("DEBUG_SANITY")) {
621 fprintf (stderr, "mergeSpec: ");
623 werror(E_TWO_OR_MORE_DATA_TYPES, name);
627 if (SPEC_SCLS(src)) {
628 /* if destination has no storage class */
629 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
630 SPEC_SCLS (dest) = SPEC_SCLS (src);
632 if (getenv("DEBUG_SANITY")) {
633 fprintf (stderr, "mergeSpec: ");
635 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
639 /* copy all the specifications */
641 // we really should do:
643 if (SPEC_what(src)) {
644 if (SPEC_what(dest)) {
645 werror(W_DUPLICATE_SPEC, "what");
647 SPEC_what(dst)|=SPEC_what(src);
650 // but there are more important thing right now
652 SPEC_LONG (dest) |= SPEC_LONG (src);
653 SPEC_SHORT(dest) |= SPEC_SHORT(src);
654 SPEC_USIGN (dest) |= SPEC_USIGN (src);
655 dest->select.s.b_signed|=src->select.s.b_signed;
656 SPEC_STAT (dest) |= SPEC_STAT (src);
657 SPEC_EXTR (dest) |= SPEC_EXTR (src);
658 SPEC_INLINE (dest) |= SPEC_INLINE (src);
659 SPEC_CONST(dest) |= SPEC_CONST (src);
660 SPEC_ABSA (dest) |= SPEC_ABSA (src);
661 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
662 SPEC_RESTRICT (dest) |= SPEC_RESTRICT (src);
663 SPEC_ADDR (dest) |= SPEC_ADDR (src);
664 SPEC_OCLS (dest) = SPEC_OCLS (src);
665 SPEC_BLEN (dest) |= SPEC_BLEN (src);
666 SPEC_BSTR (dest) |= SPEC_BSTR (src);
667 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
668 SPEC_ENUM (dest) |= SPEC_ENUM (src);
669 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
670 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
672 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
673 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
675 /* these are the only function attributes that will be set
676 in a specifier while parsing */
677 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
678 FUNC_BANKED(dest) |= FUNC_BANKED(src);
679 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
680 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
681 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
682 FUNC_ISISR(dest) |= FUNC_ISISR(src);
683 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
684 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
685 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
686 FUNC_INTNO(dest) |= FUNC_INTNO(src);
687 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
688 FUNC_ISINLINE (dest) |= FUNC_ISINLINE (src);
693 /*-------------------------------------------------------------------*/
694 /* genSymName - generates and returns a name used for anonymous vars */
695 /*-------------------------------------------------------------------*/
697 genSymName (int level)
699 static int gCount = 0;
700 static char gname[SDCC_NAME_MAX + 1];
702 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
706 /*------------------------------------------------------------------*/
707 /* getSpec - returns the specifier part from a declaration chain */
708 /*------------------------------------------------------------------*/
710 getSpec (sym_link * p)
715 while (p && !(IS_SPEC (p)))
721 /*------------------------------------------------------------------*/
722 /* newCharLink() - creates an char type */
723 /*------------------------------------------------------------------*/
729 p = newLink (SPECIFIER);
730 SPEC_NOUN (p) = V_CHAR;
735 /*------------------------------------------------------------------*/
736 /* newFloatLink - a new Float type */
737 /*------------------------------------------------------------------*/
743 p = newLink (SPECIFIER);
744 SPEC_NOUN (p) = V_FLOAT;
749 /*------------------------------------------------------------------*/
750 /* newFixed16x16Link - a new Float type */
751 /*------------------------------------------------------------------*/
757 p = newLink (SPECIFIER);
758 SPEC_NOUN (p) = V_FIXED16X16;
763 /*------------------------------------------------------------------*/
764 /* newLongLink() - new long type */
765 /*------------------------------------------------------------------*/
771 p = newLink (SPECIFIER);
772 SPEC_NOUN (p) = V_INT;
778 /*------------------------------------------------------------------*/
779 /* newIntLink() - creates an int type */
780 /*------------------------------------------------------------------*/
786 p = newLink (SPECIFIER);
787 SPEC_NOUN (p) = V_INT;
792 /*------------------------------------------------------------------*/
793 /* newBoolLink() - creates an bool type */
794 /*------------------------------------------------------------------*/
800 p = newLink (SPECIFIER);
801 SPEC_NOUN (p) = V_BIT;
806 /*------------------------------------------------------------------*/
807 /* getSize - returns size of a type chain in bytes */
808 /*------------------------------------------------------------------*/
810 getSize (sym_link * p)
812 /* if nothing return 0 */
816 { /* if this is the specifier then */
817 switch (SPEC_NOUN (p))
818 { /* depending on the specifier type */
820 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
830 return SPEC_STRUCT (p)->size;
837 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
843 /* this is a declarator */
844 switch (DCL_TYPE (p))
848 return DCL_ELEM (p) * getSize (p->next);
850 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
851 // "can not tell the size of an array[]");
862 return (IFFUNC_BANKED (p) ? GPTRSIZE : FPTRSIZE);
871 /*------------------------------------------------------------------*/
872 /* checkStructFlexArray - check tree behind a struct */
873 /*------------------------------------------------------------------*/
875 checkStructFlexArray (symbol *sym, sym_link *p)
877 /* if nothing return FALSE */
883 /* (nested) struct with flexible array member? */
884 if (IS_STRUCT (p) && SPEC_STRUCT (p)->b_flexArrayMember)
886 werror (W_INVALID_FLEXARRAY);
892 /* this is a declarator */
895 /* flexible array member? */
898 if (!options.std_c99)
899 werror (W_C89_NO_FLEXARRAY);
903 return checkStructFlexArray (sym, p->next);
908 /*------------------------------------------------------------------*/
909 /* bitsForType - returns # of bits required to store this type */
910 /*------------------------------------------------------------------*/
912 bitsForType (sym_link * p)
914 /* if nothing return 0 */
919 { /* if this is the specifier then */
921 switch (SPEC_NOUN (p))
922 { /* depending on the specifier type */
924 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
926 return FLOATSIZE * 8;
934 return SPEC_STRUCT (p)->size * 8;
941 return SPEC_BLEN (p);
947 /* this is a specifier */
948 switch (DCL_TYPE (p))
951 return DCL_ELEM (p) * getSize (p->next) * 8;
955 return (PTRSIZE * 8);
960 return (FPTRSIZE * 8);
962 return (GPTRSIZE * 8);
969 /*------------------------------------------------------------------*/
970 /* copySymbolChain - copies a symbol chain */
971 /*------------------------------------------------------------------*/
973 copySymbolChain (symbol * src)
980 dest = copySymbol (src);
981 dest->next = copySymbolChain (src->next);
985 /*------------------------------------------------------------------*/
986 /* copySymbol - makes a copy of a symbol */
987 /*------------------------------------------------------------------*/
989 copySymbol (symbol * src)
996 dest = newSymbol (src->name, src->level);
997 memcpy (dest, src, sizeof (symbol));
998 dest->level = src->level;
999 dest->block = src->block;
1000 dest->ival = copyIlist (src->ival);
1001 dest->type = copyLinkChain (src->type);
1002 dest->etype = getSpec (dest->type);
1004 dest->key = src->key;
1005 dest->allocreq = src->allocreq;
1009 /*------------------------------------------------------------------*/
1010 /* reverseSyms - reverses the links for a symbol chain */
1011 /*------------------------------------------------------------------*/
1013 reverseSyms (symbol * sym)
1015 symbol *prev, *curr, *next;
1030 sym->next = (void *) NULL;
1034 /*------------------------------------------------------------------*/
1035 /* reverseLink - reverses the links for a type chain */
1036 /*------------------------------------------------------------------*/
1038 reverseLink (sym_link * type)
1040 sym_link *prev, *curr, *next;
1055 type->next = (void *) NULL;
1059 /*------------------------------------------------------------------*/
1060 /* addSymChain - adds a symbol chain to the symboltable */
1061 /*------------------------------------------------------------------*/
1063 addSymChain (symbol ** symHead)
1065 symbol *sym = *symHead;
1066 symbol *csym = NULL;
1070 for (; sym != NULL; sym = sym->next)
1072 changePointer(sym->type);
1073 checkTypeSanity(sym->etype, sym->name);
1075 if (!sym->level && !(IS_SPEC(sym->etype) && IS_TYPEDEF(sym->etype)))
1079 /* if this is an array without any dimension
1080 then update the dimension from the initial value */
1081 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1082 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1085 /* if already exists in the symbol table on the same level */
1086 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
1087 csym->level == sym->level)
1089 /* if not formal parameter and not in file scope
1090 then show symbol redefined error
1091 else check if symbols have conpatible types */
1092 if (!sym->_isparm && sym->level > 0)
1096 /* If the previous definition was for an array with incomplete
1097 type, and the new definition has completed the type, update
1098 the original type to match */
1099 if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY
1100 && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY)
1102 if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type))
1103 DCL_ELEM(csym->type) = DCL_ELEM(sym->type);
1107 /* If only one of the definitions used the "at" keyword, copy */
1108 /* the address to the other. */
1109 if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype)
1110 && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype))
1112 SPEC_ABSA (sym->etype) = 1;
1113 SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype);
1115 if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype)
1116 && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype))
1118 SPEC_ABSA (csym->etype) = 1;
1119 SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype);
1124 if (csym->ival && sym->ival)
1126 if (compareTypeExact (csym->type, sym->type, sym->level) != 1)
1132 /* one definition extern ? */
1133 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype))
1134 werror (E_EXTERN_MISMATCH, sym->name);
1136 werror (E_DUPLICATE, sym->name);
1137 werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF);
1139 fprintf (stderr, "from type '");
1140 printTypeChain (csym->type, stderr);
1141 if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype))
1142 fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype));
1143 fprintf (stderr, "'\nto type '");
1144 printTypeChain (sym->type, stderr);
1145 if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype))
1146 fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype));
1147 fprintf (stderr, "'\n");
1152 if (csym->ival && !sym->ival)
1153 sym->ival = csym->ival;
1155 if (!csym->cdef && !sym->cdef && IS_EXTERN (sym->etype))
1157 /* if none of symbols is a compiler defined function
1158 and at least one is not extern
1159 then set the new symbol to non extern */
1160 SPEC_EXTR(sym->etype) = SPEC_EXTR(csym->etype);
1163 /* delete current entry */
1164 deleteSym (SymbolTab, csym, csym->name);
1165 deleteFromSeg(csym);
1167 symPtrPtr = symHead;
1168 while (*symPtrPtr && *symPtrPtr != csym)
1169 symPtrPtr = &(*symPtrPtr)->next;
1170 if (*symPtrPtr == csym)
1171 *symPtrPtr = csym->next;
1175 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1180 /*------------------------------------------------------------------*/
1181 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
1182 /*------------------------------------------------------------------*/
1184 funcInChain (sym_link * lnk)
1195 /*------------------------------------------------------------------*/
1196 /* structElemType - returns the type info of a struct member */
1197 /*------------------------------------------------------------------*/
1199 structElemType (sym_link * stype, value * id)
1201 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1202 sym_link *type, *etype;
1203 sym_link *petype = getSpec (stype);
1207 /* look for the id */
1210 if (strcmp (fields->rname, id->name) == 0)
1212 type = copyLinkChain (fields->type);
1213 etype = getSpec (type);
1214 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1215 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1216 SPEC_OCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1217 SPEC_OCLS (etype) : SPEC_OCLS (petype));
1219 SPEC_CONST (type) |= SPEC_CONST (stype);
1221 DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1224 fields = fields->next;
1228 werror (E_NOT_MEMBER, id->name);
1230 // the show must go on
1231 return newIntLink();
1234 /*------------------------------------------------------------------*/
1235 /* getStructElement - returns element of a tructure definition */
1236 /*------------------------------------------------------------------*/
1238 getStructElement (structdef * sdef, symbol * sym)
1242 for (field = sdef->fields; field; field = field->next)
1243 if (strcmp (field->name, sym->name) == 0)
1246 werror (E_NOT_MEMBER, sym->name);
1248 return sdef->fields;
1251 /*------------------------------------------------------------------*/
1252 /* compStructSize - computes the size of a structure */
1253 /*------------------------------------------------------------------*/
1255 compStructSize (int su, structdef * sdef)
1257 int sum = 0, usum = 0;
1261 /* for the identifiers */
1262 loop = sdef->fields;
1265 /* create the internal name for this variable */
1266 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1271 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1273 /* if this is a bit field */
1276 /* change it to a unsigned bit */
1277 SPEC_NOUN (loop->etype) = V_BITFIELD;
1278 /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
1279 /* a "plain" int bitfield is unsigned */
1280 if (!loop->etype->select.s.b_signed)
1281 SPEC_USIGN(loop->etype) = 1;
1283 SPEC_BLEN (loop->etype) = loop->bitVar;
1285 if (loop->bitVar == BITVAR_PAD) {
1286 /* A zero length bitfield forces padding */
1287 SPEC_BSTR (loop->etype) = bitOffset;
1288 SPEC_BLEN (loop->etype) = 0;
1293 if (bitOffset == 8) {
1297 /* check if this fit into the remaining */
1298 /* bits of this byte else align it to the */
1299 /* next byte boundary */
1300 if (loop->bitVar <= (8 - bitOffset)) {
1301 /* fits into current byte */
1303 SPEC_BSTR (loop->etype) = bitOffset;
1304 bitOffset += loop->bitVar;
1306 else if (!bitOffset) {
1307 /* does not fit, but is already byte aligned */
1309 SPEC_BSTR (loop->etype) = bitOffset;
1310 bitOffset += loop->bitVar;
1313 if( TARGET_IS_PIC16 && getenv("PIC16_PACKED_BITFIELDS") ) {
1314 /* if PIC16 && enviroment variable is set, then
1315 * tightly pack bitfields, this means that when a
1316 * bitfield goes beyond byte alignment, do not
1317 * automatically start allocatint from next byte,
1318 * but also use the available bits first */
1319 fprintf(stderr, ": packing bitfields in structures\n");
1320 SPEC_BSTR (loop->etype) = bitOffset;
1321 bitOffset += loop->bitVar;
1322 loop->offset = (su == UNION ? sum = 0 : sum);
1324 /* does not fit; need to realign first */
1326 loop->offset = (su == UNION ? sum = 0 : sum);
1328 SPEC_BSTR (loop->etype) = bitOffset;
1329 bitOffset += loop->bitVar;
1332 while (bitOffset>8) {
1339 /* This is a non-bit field. Make sure we are */
1340 /* byte aligned first */
1343 loop->offset = (su == UNION ? sum = 0 : sum);
1347 checkDecl (loop, 1);
1348 sum += getSize (loop->type);
1350 /* search for "flexibel array members" */
1351 /* and do some syntax checks */
1353 && checkStructFlexArray (loop, loop->type))
1355 /* found a "flexible array member" */
1356 sdef->b_flexArrayMember = TRUE;
1357 /* is another struct-member following? */
1359 werror (E_FLEXARRAY_NOTATEND);
1360 /* is it the first struct-member? */
1361 else if (loop == sdef->fields)
1362 werror (E_FLEXARRAY_INEMPTYSTRCT);
1368 /* if union then size = sizeof largest field */
1370 /* For UNION, round up after each field */
1371 sum += ((bitOffset+7)/8);
1372 usum = max (usum, sum);
1377 /* For STRUCT, round up after all fields processed */
1379 sum += ((bitOffset+7)/8);
1381 return (su == UNION ? usum : sum);
1384 /*-------------------------------------------------------------------*/
1385 /* promoteAnonStructs - promote anonymous struct/union's fields into */
1386 /* an enclosing struct/union */
1387 /*-------------------------------------------------------------------*/
1389 promoteAnonStructs (int su, structdef * sdef)
1398 tofield = &sdef->fields;
1399 field = sdef->fields;
1402 nextfield = field->next;
1403 if (!*field->name && IS_STRUCT (field->type))
1405 /* Found an anonymous struct/union. Replace it */
1406 /* with the fields it contains and adjust all */
1409 base = field->offset;
1410 subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields);
1412 continue; /* just in case it's empty */
1414 *tofield = subfield;
1417 /* check for field name conflicts resulting from promotion */
1418 dupfield = sdef->fields;
1419 while (dupfield && dupfield != subfield)
1421 if (*subfield->name && !strcmp (dupfield->name, subfield->name))
1423 werrorfl (subfield->fileDef, subfield->lineDef,
1425 su==STRUCT ? "struct" : "union",
1427 werrorfl (dupfield->fileDef, dupfield->lineDef,
1430 dupfield = dupfield->next;
1433 subfield->offset += base;
1435 subfield = subfield->next;
1439 subfield->next = nextfield;
1440 tofield = &subfield->next;
1443 tofield = &field->next;
1449 /*------------------------------------------------------------------*/
1450 /* checkSClass - check the storage class specification */
1451 /*------------------------------------------------------------------*/
1453 checkSClass (symbol * sym, int isProto)
1457 if (getenv("DEBUG_SANITY")) {
1458 fprintf (stderr, "checkSClass: %s \n", sym->name);
1461 /* type is literal can happen for enums change to auto */
1462 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1463 SPEC_SCLS (sym->etype) = S_AUTO;
1465 /* if sfr or sbit then must also be volatile */
1466 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1467 SPEC_SCLS (sym->etype) == S_SFR)
1469 SPEC_VOLATILE (sym->etype) = 1;
1472 /* make sure restrict is only used with pointers */
1473 if (SPEC_RESTRICT (sym->etype))
1475 werrorfl (sym->fileDef, sym->lineDef, E_BAD_RESTRICT);
1476 SPEC_RESTRICT (sym->etype) = 0;
1481 if (IS_DECL (t) && DCL_PTR_RESTRICT (t) && !IS_PTR (t))
1483 werrorfl (sym->fileDef, sym->lineDef, E_BAD_RESTRICT);
1484 DCL_PTR_RESTRICT (t) = 0;
1490 /* if absolute address given then it mark it as
1491 volatile -- except in the PIC port */
1493 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1494 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1495 if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1498 if (IS_ABSOLUTE (sym->etype))
1499 SPEC_VOLATILE (sym->etype) = 1;
1501 if (TARGET_IS_MCS51 &&
1502 IS_ABSOLUTE (sym->etype) &&
1503 SPEC_SCLS (sym->etype) == S_SFR)
1508 if (SPEC_NOUN (sym->etype) == V_CHAR)
1510 else if (SPEC_LONG (sym->etype) == 0)
1515 addr = SPEC_ADDR (sym->etype);
1516 for (n=0; n<size; n+=8)
1517 if (((addr >> n) & 0xFF) < 0x80)
1518 werror (W_SFR_ABSRANGE, sym->name);
1521 /* If code memory is read only, then pointers to code memory */
1522 /* implicitly point to constants -- make this explicit */
1524 while (t && t->next) {
1525 if (IS_CODEPTR(t) && port->mem.code_ro) {
1526 if (IS_SPEC(t->next)) {
1527 SPEC_CONST (t->next) = 1;
1529 DCL_PTR_CONST (t->next) = 1;
1535 /* global variables declared const put into code */
1536 /* if no other storage class specified */
1537 if (sym->level == 0 &&
1538 SPEC_SCLS(sym->etype) == S_FIXED &&
1539 !IS_FUNC(sym->type)) {
1540 /* find the first non-array link */
1544 if (IS_CONSTANT (t)) {
1545 SPEC_SCLS (sym->etype) = S_CODE;
1549 /* global variable in code space is a constant */
1550 if (sym->level == 0 &&
1551 SPEC_SCLS (sym->etype) == S_CODE &&
1552 port->mem.code_ro) {
1553 /* find the first non-array link */
1560 DCL_PTR_CONST (t) = 1;
1564 /* if bit variable then no storage class can be */
1565 /* specified since bit is already a storage */
1566 if (IS_BITVAR (sym->etype) &&
1567 (SPEC_SCLS (sym->etype) != S_FIXED &&
1568 SPEC_SCLS (sym->etype) != S_SBIT &&
1569 SPEC_SCLS (sym->etype) != S_BIT)
1572 werror (E_BITVAR_STORAGE, sym->name);
1573 SPEC_SCLS (sym->etype) = S_FIXED;
1576 /* extern variables cannot be initialized */
1577 if (IS_EXTERN (sym->etype) && sym->ival)
1579 werror (E_EXTERN_INIT, sym->name);
1583 /* if this is an automatic symbol */
1584 if (sym->level && (options.stackAuto || reentrant)) {
1585 if (SPEC_SCLS (sym->etype) != S_BIT) {
1586 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1587 SPEC_SCLS (sym->etype) == S_FIXED ||
1588 SPEC_SCLS (sym->etype) == S_REGISTER ||
1589 SPEC_SCLS (sym->etype) == S_STACK ||
1590 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1591 SPEC_SCLS (sym->etype) = S_AUTO;
1593 /* storage class may only be specified for statics */
1594 if (!IS_STATIC(sym->etype)) {
1595 werror (E_AUTO_ASSUMED, sym->name);
1601 /* automatic symbols cannot be given */
1602 /* an absolute address ignore it */
1603 if (sym->level && !IS_STATIC(sym->etype) &&
1604 SPEC_ABSA (sym->etype) &&
1605 (options.stackAuto || reentrant))
1607 werror (E_AUTO_ABSA, sym->name);
1608 SPEC_ABSA (sym->etype) = 0;
1611 /* arrays & pointers cannot be defined for bits */
1612 /* SBITS or SFRs or BIT */
1613 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1614 !IS_FUNCPTR (sym->type) &&
1615 (SPEC_NOUN (sym->etype) == V_BIT ||
1616 SPEC_NOUN (sym->etype) == V_SBIT ||
1617 SPEC_NOUN (sym->etype) == V_BITFIELD ||
1618 SPEC_SCLS (sym->etype) == S_SFR))
1619 werror (E_BIT_ARRAY, sym->name);
1621 /* if this is a bit|sbit then set length & start */
1622 if (SPEC_NOUN (sym->etype) == V_BIT ||
1623 SPEC_NOUN (sym->etype) == V_SBIT)
1625 SPEC_BLEN (sym->etype) = 1;
1626 SPEC_BSTR (sym->etype) = 0;
1630 /* variables declared in CODE space must have */
1631 /* initializers if not an extern */
1632 if (SPEC_SCLS (sym->etype) == S_CODE &&
1633 sym->ival == NULL &&
1636 port->mem.code_ro &&
1637 !IS_EXTERN (sym->etype) &&
1638 !SPEC_ABSA (sym->etype) &&
1639 !funcInChain (sym->type))
1640 werror (E_CODE_NO_INIT, sym->name);
1643 /* if parameter or local variable then change */
1644 /* the storage class to reflect where the var will go */
1645 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED
1646 && !IS_STATIC(sym->etype)
1649 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1651 SPEC_SCLS (sym->etype) = (options.useXstack ?
1652 S_XSTACK : S_STACK);
1656 /* hack-o-matic! I see no reason why the useXstack option should ever
1657 * control this allocation, but the code was originally that way, and
1658 * changing it for non-390 ports breaks the compiler badly.
1660 bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1661 1 : options.useXstack;
1662 SPEC_SCLS (sym->etype) = (useXdata ?
1668 /*------------------------------------------------------------------*/
1669 /* changePointer - change pointer to functions */
1670 /*------------------------------------------------------------------*/
1672 changePointer (sym_link * p)
1675 /* go thru the chain of declarations */
1676 /* if we find a pointer to a function */
1677 /* change it to a ptr to code area */
1678 /* unless the function is banked. */
1679 for (; p; p = p->next)
1681 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1682 DCL_TYPE (p) = port->unqualified_pointer;
1683 if (IS_PTR (p) && IS_FUNC (p->next))
1684 if (!IFFUNC_BANKED(p->next))
1685 DCL_TYPE (p) = CPOINTER;
1689 /*------------------------------------------------------------------*/
1690 /* checkDecl - does semantic validation of a declaration */
1691 /*------------------------------------------------------------------*/
1693 checkDecl (symbol * sym, int isProto)
1696 checkSClass (sym, isProto); /* check the storage class */
1697 changePointer (sym->type); /* change pointers if required */
1699 /* if this is an array without any dimension
1700 then update the dimension from the initial value */
1701 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1702 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1707 /*------------------------------------------------------------------*/
1708 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1709 /*------------------------------------------------------------------*/
1711 copyLinkChain (sym_link * p)
1713 sym_link *head, *curr, *loop;
1715 /* note: v_struct and v_struct->fields are not copied! */
1717 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1720 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1721 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1729 /*------------------------------------------------------------------*/
1730 /* cleanUpBlock - cleansup the symbol table specified for all the */
1731 /* symbols in the given block */
1732 /*------------------------------------------------------------------*/
1734 cleanUpBlock (bucket ** table, int block)
1739 /* go thru the entire table */
1740 for (i = 0; i < 256; i++)
1742 for (chain = table[i]; chain; chain = chain->next)
1744 if (chain->block >= block)
1746 deleteSym (table, chain->sym, chain->name);
1752 /*------------------------------------------------------------------*/
1753 /* cleanUpLevel - cleansup the symbol table specified for all the */
1754 /* symbols in the given level */
1755 /*------------------------------------------------------------------*/
1757 cleanUpLevel (bucket ** table, int level)
1762 /* go thru the entire table */
1763 for (i = 0; i < 256; i++)
1765 for (chain = table[i]; chain; chain = chain->next)
1767 if (chain->level >= level)
1769 deleteSym (table, chain->sym, chain->name);
1775 /*------------------------------------------------------------------*/
1776 /* computeTypeOr - computes the resultant type from two types */
1777 /*------------------------------------------------------------------*/
1779 computeTypeOr (sym_link * etype1, sym_link * etype2, sym_link * reType)
1782 assert ( (IS_CHAR (etype1) || IS_BIT (etype1))
1783 && (IS_CHAR (etype2) || IS_BIT (etype2)));
1785 if (SPEC_USIGN (etype1) == SPEC_USIGN (etype2))
1787 SPEC_USIGN (reType) = SPEC_USIGN (etype1);
1791 if (SPEC_USIGN (etype1))
1793 if ( IS_LITERAL (etype2)
1794 && floatFromVal (valFromType (etype2)) >= 0)
1795 SPEC_USIGN (reType) = 1;
1798 /* promote to int */
1799 SPEC_USIGN (reType) = 0;
1800 SPEC_NOUN (reType) = V_INT;
1803 else /* etype1 signed */
1805 if ( IS_LITERAL (etype2)
1806 && floatFromVal (valFromType (etype2)) <= 127)
1807 SPEC_USIGN (reType) = 0;
1810 /* promote to int */
1811 SPEC_USIGN (reType) = 0;
1812 SPEC_NOUN (reType) = V_INT;
1816 if (SPEC_USIGN (etype2))
1818 if ( IS_LITERAL (etype1)
1819 && floatFromVal (valFromType (etype1)) >= 0)
1820 SPEC_USIGN (reType) = 1;
1823 /* promote to int */
1824 SPEC_USIGN (reType) = 0;
1825 SPEC_NOUN (reType) = V_INT;
1828 else /* etype2 signed */
1830 if ( IS_LITERAL (etype1)
1831 && floatFromVal (valFromType (etype1)) <= 127)
1832 SPEC_USIGN (reType) = 0;
1835 /* promote to int */
1836 SPEC_USIGN (reType) = 0;
1837 SPEC_NOUN (reType) = V_INT;
1843 /*------------------------------------------------------------------*/
1844 /* computeType - computes the resultant type from two types */
1845 /*------------------------------------------------------------------*/
1847 computeType (sym_link * type1, sym_link * type2,
1848 RESULT_TYPE resultType, int op)
1852 sym_link *etype1 = getSpec (type1);
1855 etype2 = type2 ? getSpec (type2) : type1;
1857 /* if one of them is a float then result is a float */
1858 /* here we assume that the types passed are okay */
1859 /* and can be cast to one another */
1860 /* which ever is greater in size */
1861 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1862 rType = newFloatLink ();
1863 /* if both are fixed16x16 then result is float */
1864 else if (IS_FIXED16X16(etype1) && IS_FIXED16X16(etype2))
1865 rType = newFixed16x16Link();
1866 else if (IS_FIXED16X16(etype1) && IS_FLOAT (etype2))
1867 rType = newFloatLink ();
1868 else if (IS_FLOAT (etype1) && IS_FIXED16X16 (etype2) )
1869 rType = newFloatLink ();
1871 /* if both are bitvars choose the larger one */
1872 else if (IS_BITVAR (etype1) && IS_BITVAR (etype2))
1873 rType = SPEC_BLEN (etype1) >= SPEC_BLEN (etype2) ?
1874 copyLinkChain (type1) : copyLinkChain (type2);
1876 /* if only one of them is a bit variable then the other one prevails */
1877 else if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1879 rType = copyLinkChain (type2);
1880 /* bitfield can have up to 16 bits */
1881 if (getSize (etype1) > 1)
1882 SPEC_NOUN (getSpec (rType)) = V_INT;
1884 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1886 rType = copyLinkChain (type1);
1887 /* bitfield can have up to 16 bits */
1888 if (getSize (etype2) > 1)
1889 SPEC_NOUN (getSpec (rType)) = V_INT;
1891 /* if one of them is a pointer or array then that
1893 else if (IS_PTR (type1) || IS_ARRAY (type1))
1894 rType = copyLinkChain (type1);
1895 else if (IS_PTR (type2) || IS_ARRAY (type2))
1896 rType = copyLinkChain (type2);
1897 else if (getSize (type1) > getSize (type2))
1898 rType = copyLinkChain (type1);
1900 rType = copyLinkChain (type2);
1902 reType = getSpec (rType);
1904 /* avoid conflicting types */
1905 reType->select.s.b_signed = 0;
1907 /* if result is a literal then make not so */
1908 if (IS_LITERAL (reType))
1909 SPEC_SCLS (reType) = S_REGISTER;
1913 case RESULT_TYPE_IFX:
1917 case RESULT_TYPE_BIT:
1920 SPEC_NOUN (reType) = V_BIT;
1924 case RESULT_TYPE_CHAR:
1925 if (IS_BITVAR (reType))
1927 SPEC_NOUN (reType) = V_CHAR;
1928 SPEC_SCLS (reType) = 0;
1929 SPEC_USIGN (reType) = 0;
1933 case RESULT_TYPE_INT:
1934 case RESULT_TYPE_NONE:
1935 case RESULT_TYPE_OTHER:
1936 if (IS_BIT (reType))
1938 SPEC_NOUN (reType) = V_CHAR;
1939 SPEC_SCLS (reType) = 0;
1940 SPEC_USIGN (reType) = 0;
1943 else if (IS_BITFIELD (reType))
1945 /* could be smarter, but it depends on the op */
1946 /* this is for the worst case: a multiplication of 4 * 4 bit */
1947 SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT;
1948 SPEC_SCLS (reType) = 0;
1949 SPEC_USIGN (reType) = 0;
1952 else if (IS_CHAR (reType))
1954 /* promotion of some special cases */
1959 return computeTypeOr (etype1, etype2, reType);
1961 if (SPEC_USIGN (etype1) != SPEC_USIGN (etype2))
1963 SPEC_USIGN (reType) = 1;
1968 SPEC_NOUN (reType) = V_INT;
1969 SPEC_USIGN (reType) = 0;
1972 /* if both are unsigned char then no promotion required */
1973 if (!(SPEC_USIGN (etype1) && SPEC_USIGN (etype2)))
1975 SPEC_NOUN (reType) = V_INT;
1976 SPEC_USIGN (reType) = 0;
1989 /* SDCC's sign promotion:
1990 - if one or both operands are unsigned, the resultant type will be unsigned
1991 (except char, see below)
1992 - if an operand is promoted to a larger type (char -> int, int -> long),
1993 the larger type will be signed
1995 SDCC tries hard to avoid promotion to int and does 8 bit calculation as
1996 much as possible. We're leaving ISO IEC 9899 here and have to extrapolate
1997 the standard. The standard demands, that the result has to be the same
1998 "as if" the promotion would have been performed:
2000 - if the result of an operation with two char's is promoted to a
2001 larger type, the result will be signed.
2003 More sophisticated are these:
2004 - if the result of an operation with two char's is a char again,
2005 the result will only then be unsigned, if both operands are
2006 unsigned. In all other cases the result will be signed.
2008 This seems to be contradictionary to the first two rules, but it makes
2009 real sense (all types are char's):
2011 A signed char can be negative; this must be preserved in the result
2014 Only if both operands are unsigned it's safe to make the result
2015 unsigned; this helps to avoid overflow:
2018 - ToDo: document '|', '^' and '&'
2020 Homework: - why is (200 * 200 < 0) true?
2021 - why is { char l = 200, r = 200; (r * l > 0) } true?
2024 if (!IS_FLOAT (reType)
2025 && ( (SPEC_USIGN (etype1)
2026 /* if this operand is promoted to a larger type,
2027 then it will be promoted to a signed type */
2028 && !(bitsForType (etype1) < bitsForType (reType))
2029 /* char require special handling */
2030 && !IS_CHAR (etype1))
2031 || /* same for 2nd operand */
2032 (SPEC_USIGN (etype2)
2033 && !(bitsForType (etype2) < bitsForType (reType))
2034 && !IS_CHAR (etype2))
2035 || /* if both are 'unsigned char' and not promoted
2036 let the result be unsigned too */
2037 ( SPEC_USIGN (etype1)
2038 && SPEC_USIGN (etype2)
2041 && IS_CHAR (reType))))
2042 SPEC_USIGN (reType) = 1;
2044 SPEC_USIGN (reType) = 0;
2050 comparePtrType (sym_link * dest, sym_link * src, bool bMustCast)
2054 if (IS_VOID (src->next) && IS_VOID (dest->next))
2055 return bMustCast ? -1 : 1;
2056 if ((IS_VOID (src->next) && !IS_VOID (dest->next)) ||
2057 (!IS_VOID (src->next) && IS_VOID (dest->next)) )
2059 res = compareType (dest->next, src->next);
2061 return bMustCast ? -1 : 1;
2068 /*--------------------------------------------------------------------*/
2069 /* compareType - will do type check return 1 if match, 0 if no match, */
2070 /* -1 if castable, -2 if only signedness differs */
2071 /*--------------------------------------------------------------------*/
2073 compareType (sym_link * dest, sym_link * src)
2084 /* if dest is a declarator then */
2089 /* banked function pointer */
2090 if (IS_GENPTR (dest) && IS_GENPTR (src))
2092 if (IS_FUNC (src->next) && IS_VOID(dest->next))
2094 if (IS_FUNC (dest->next) && IS_VOID(src->next))
2096 return comparePtrType(dest, src, FALSE);
2099 if (DCL_TYPE (src) == DCL_TYPE (dest))
2103 //checkFunction(src,dest);
2105 return comparePtrType(dest, src, FALSE);
2107 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next))
2112 (IS_GENPTR (dest) ||
2113 ((DCL_TYPE(src) == POINTER) && (DCL_TYPE(dest) == IPOINTER))
2116 return comparePtrType(dest, src, TRUE);
2118 if (IS_PTR (dest) && IS_ARRAY (src))
2120 value *val=aggregateToPointer (valFromType(src));
2121 int res=compareType (dest, val->type);
2122 Safe_free(val->type);
2126 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
2127 return compareType (dest->next, src);
2130 else if (IS_PTR (dest) && IS_INTEGRAL (src))
2136 if (IS_PTR (src) && IS_VOID (dest))
2139 /* if one is a specifier and the other is not */
2140 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2141 (IS_SPEC (dest) && !IS_SPEC (src)))
2144 /* if one of them is a void then ok */
2145 if (SPEC_NOUN (dest) == V_VOID &&
2146 SPEC_NOUN (src) != V_VOID)
2149 if (SPEC_NOUN (dest) != V_VOID &&
2150 SPEC_NOUN (src) == V_VOID)
2153 /* if they are both bitfields then if the lengths
2154 and starts don't match */
2155 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2156 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2157 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2160 /* it is a specifier */
2161 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2163 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
2164 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
2166 bitsForType (dest) == bitsForType (src))
2167 instead of the next two lines, but the regression tests fail with
2168 them; I guess it's a problem with replaceCheaperOp */
2169 getSize (dest) == getSize (src) &&
2170 (IS_BIT (dest) == IS_BIT (src)))
2172 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
2177 else if (IS_STRUCT (dest))
2179 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2184 if (SPEC_LONG (dest) != SPEC_LONG (src))
2187 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2193 /*--------------------------------------------------------------------*/
2194 /* compareTypeExact - will do type check return 1 if match exactly */
2195 /*--------------------------------------------------------------------*/
2197 compareTypeExact (sym_link * dest, sym_link * src, int level)
2199 STORAGE_CLASS srcScls, destScls;
2210 /* if dest is a declarator then */
2215 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2216 if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
2218 if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
2220 if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
2224 value *exargs, *acargs, *checkValue;
2226 /* verify function return type */
2227 if (!compareTypeExact (dest->next, src->next, -1))
2229 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
2231 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
2233 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
2236 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
2240 /* compare expected args with actual args */
2241 exargs = FUNC_ARGS(dest);
2242 acargs = FUNC_ARGS(src);
2244 /* for all the expected args do */
2245 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
2247 //checkTypeSanity(acargs->etype, acargs->name);
2249 if (IS_AGGREGATE (acargs->type))
2251 checkValue = copyValue (acargs);
2252 aggregateToPointer (checkValue);
2255 checkValue = acargs;
2258 if (!compareTypeExact (exargs->type, checkValue->type, -1))
2263 /* if one them ended we have a problem */
2264 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2265 (!exargs && acargs && !IS_VOID (acargs->type)))
2269 return compareTypeExact (dest->next, src->next, level);
2276 /* if one is a specifier and the other is not */
2277 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2278 (IS_SPEC (dest) && !IS_SPEC (src)))
2281 /* if one of them is a void then ok */
2282 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2285 /* if they are both bitfields then if the lengths
2286 and starts don't match */
2287 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2288 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2289 SPEC_BSTR (dest) != SPEC_BSTR (src)))
2292 if (IS_INTEGRAL (dest))
2294 /* signedness must match */
2295 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2297 /* size must match */
2298 if (SPEC_LONG (dest) != SPEC_LONG (src))
2300 if (SPEC_SHORT (dest) != SPEC_SHORT (src))
2304 if (IS_STRUCT (dest))
2306 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2310 if (SPEC_CONST (dest) != SPEC_CONST (src))
2312 if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
2314 if (SPEC_STAT (dest) != SPEC_STAT (src))
2316 if (SPEC_ABSA (dest) != SPEC_ABSA (src))
2318 if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
2321 destScls = SPEC_SCLS (dest);
2322 srcScls = SPEC_SCLS (src);
2324 /* Compensate for const to const code change in checkSClass() */
2325 if (!level & port->mem.code_ro && SPEC_CONST (dest))
2327 if (srcScls == S_CODE && destScls == S_FIXED)
2329 if (destScls == S_CODE && srcScls == S_FIXED)
2333 /* compensate for allocGlobal() */
2334 if ((srcScls == S_FIXED || srcScls == S_AUTO)
2335 && port->mem.default_globl_map == xdata
2339 if (level>0 && !SPEC_STAT (dest))
2341 /* Compensate for hack-o-matic in checkSClass() */
2342 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
2344 if (destScls == S_FIXED)
2345 destScls = (options.useXstack ? S_XSTACK : S_STACK);
2346 if (srcScls == S_FIXED)
2347 srcScls = (options.useXstack ? S_XSTACK : S_STACK);
2349 else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
2351 if (destScls == S_FIXED)
2353 if (srcScls == S_FIXED)
2358 if (srcScls != destScls)
2361 printf ("level = %d\n", level);
2362 printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
2363 SPEC_SCLS (src), SPEC_SCLS (dest));
2364 printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
2372 /*------------------------------------------------------------------*/
2373 /* inCalleeSaveList - return 1 if found in callee save list */
2374 /*------------------------------------------------------------------*/
2376 calleeCmp(void *p1, void *p2)
2378 return (strcmp((char *)p1, (char *)(p2)) == 0);
2382 inCalleeSaveList(char *s)
2384 if (options.all_callee_saves)
2386 return isinSetWith(options.calleeSavesSet, s, calleeCmp);
2389 /*-----------------------------------------------------------------*/
2390 /* aggregateToPointer: change an aggregate type function */
2391 /* argument to a pointer to that type. */
2392 /*-----------------------------------------------------------------*/
2394 aggregateToPointer (value * val)
2396 if (IS_AGGREGATE (val->type))
2398 /* if this is a structure */
2399 /* then we need to add a new link */
2400 if (IS_STRUCT (val->type))
2402 /* first lets add DECLARATOR type */
2403 sym_link *p = val->type;
2405 werror (W_STRUCT_AS_ARG, val->name);
2406 val->type = newLink (DECLARATOR);
2407 val->type->next = p;
2410 /* change to a pointer depending on the */
2411 /* storage class specified */
2412 switch (SPEC_SCLS (val->etype))
2415 DCL_TYPE (val->type) = IPOINTER;
2418 DCL_TYPE (val->type) = PPOINTER;
2421 if (SPEC_OCLS(val->etype)) {
2422 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
2424 // this happens for (external) function parameters
2425 DCL_TYPE (val->type) = port->unqualified_pointer;
2429 DCL_TYPE (val->type) = PTR_TYPE(SPEC_OCLS(val->etype));
2433 DCL_TYPE (val->type) = POINTER;
2436 DCL_TYPE (val->type) = CPOINTER;
2439 DCL_TYPE (val->type) = FPOINTER;
2442 DCL_TYPE (val->type) = EEPPOINTER;
2445 DCL_TYPE (val->type) = port->unqualified_pointer;
2448 /* is there is a symbol associated then */
2449 /* change the type of the symbol as well */
2452 val->sym->type = copyLinkChain (val->type);
2453 val->sym->etype = getSpec (val->sym->type);
2458 /*------------------------------------------------------------------*/
2459 /* checkFunction - does all kinds of check on a function */
2460 /*------------------------------------------------------------------*/
2462 checkFunction (symbol * sym, symbol *csym)
2464 value *exargs, *acargs;
2468 if (getenv("DEBUG_SANITY")) {
2469 fprintf (stderr, "checkFunction: %s ", sym->name);
2472 if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
2474 werror(E_SYNTAX_ERROR, sym->name);
2478 /* move inline specifier from return type to function attributes */
2479 if (IS_INLINE (sym->etype))
2481 SPEC_INLINE (sym->etype) = 0;
2482 FUNC_ISINLINE (sym->type) = 1;
2485 /* make sure the type is complete and sane */
2486 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
2488 /* if not type then some kind of error */
2492 /* if the function has no type then make it return int */
2493 if (!sym->type->next)
2494 sym->type->next = sym->etype = newIntLink ();
2496 /* function cannot return aggregate */
2497 if (IS_AGGREGATE (sym->type->next))
2499 werror (E_FUNC_AGGR, sym->name);
2503 /* check if this function is defined as calleeSaves
2504 then mark it as such */
2505 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
2507 /* if interrupt service routine */
2508 /* then it cannot have arguments */
2509 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
2511 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
2512 werror (E_INT_ARGS, sym->name);
2513 FUNC_ARGS(sym->type)=NULL;
2517 if (IFFUNC_ISSHADOWREGS(sym->type) && !FUNC_ISISR (sym->type))
2519 werror (E_SHADOWREGS_NO_ISR, sym->name);
2522 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
2524 acargs=acargs->next, argCnt++) {
2526 // this can happen for reentrant functions
2527 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2528 // the show must go on: synthesize a name and symbol
2529 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
2530 acargs->sym = newSymbol (acargs->name, 1);
2531 SPEC_OCLS (acargs->etype) = istack;
2532 acargs->sym->type = copyLinkChain (acargs->type);
2533 acargs->sym->etype = getSpec (acargs->sym->type);
2534 acargs->sym->_isparm = 1;
2535 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2536 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2538 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2543 /*JCF: Mark the register bank as used*/
2544 RegBankUsed[FUNC_REGBANK (sym->type)] = 1;
2546 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2547 return 1; /* not defined nothing more to check */
2549 /* check if body already present */
2550 if (csym && IFFUNC_HASBODY(csym->type))
2552 werror (E_FUNC_BODY, sym->name);
2556 /* check the return value type */
2557 if (compareType (csym->type, sym->type) <= 0)
2559 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2560 printFromToType(csym->type, sym->type);
2564 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2566 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2569 /* I don't think this is necessary for interrupts. An isr is a */
2570 /* root in the calling tree. */
2571 if ((FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type)) &&
2572 (!FUNC_ISISR (sym->type)))
2574 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2577 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2579 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2582 /* Really, reentrant should match regardless of argCnt, but */
2583 /* this breaks some existing code (the fp lib functions). If */
2584 /* the first argument is always passed the same way, this */
2585 /* lax checking is ok (but may not be true for in future ports) */
2586 if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2589 //printf("argCnt = %d\n",argCnt);
2590 werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2593 if (IFFUNC_ISWPARAM (csym->type) != IFFUNC_ISWPARAM (sym->type))
2595 werror (E_PREV_DEF_CONFLICT, csym->name, "wparam");
2598 if (IFFUNC_ISSHADOWREGS (csym->type) != IFFUNC_ISSHADOWREGS (sym->type))
2600 werror (E_PREV_DEF_CONFLICT, csym->name, "shadowregs");
2604 /* compare expected args with actual args */
2605 exargs = FUNC_ARGS(csym->type);
2606 acargs = FUNC_ARGS(sym->type);
2608 /* for all the expected args do */
2611 exargs = exargs->next, acargs = acargs->next, argCnt++)
2613 if (getenv("DEBUG_SANITY")) {
2614 fprintf (stderr, "checkFunction: %s ", exargs->name);
2616 /* make sure the type is complete and sane */
2617 checkTypeSanity(exargs->etype, exargs->name);
2619 /* If the actual argument is an array, any prototype
2620 * will have modified it to a pointer. Duplicate that
2623 if (IS_AGGREGATE (acargs->type))
2625 checkValue = copyValue (acargs);
2626 aggregateToPointer (checkValue);
2630 checkValue = acargs;
2633 if (compareType (exargs->type, checkValue->type) <= 0)
2635 werror (E_ARG_TYPE, argCnt);
2636 printFromToType(exargs->type, checkValue->type);
2641 /* if one them ended we have a problem */
2642 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2643 (!exargs && acargs && !IS_VOID (acargs->type)))
2644 werror (E_ARG_COUNT);
2646 /* replace with this defition */
2647 sym->cdef = csym->cdef;
2648 deleteSym (SymbolTab, csym, csym->name);
2649 deleteFromSeg(csym);
2650 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2651 if (IS_EXTERN (csym->etype) && !
2652 IS_EXTERN (sym->etype))
2654 addSet (&publics, sym);
2659 /*------------------------------------------------------------------*/
2660 /* cdbStructBlock - calls struct printing for a blcks */
2661 /*------------------------------------------------------------------*/
2662 void cdbStructBlock (int block)
2665 bucket **table = StructTab;
2668 /* go thru the entire table */
2669 for (i = 0; i < 256; i++)
2671 for (chain = table[i]; chain; chain = chain->next)
2673 if (chain->block >= block)
2676 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2682 /*-----------------------------------------------------------------*/
2683 /* processFuncPtrArgs - does some processing with args of func ptrs*/
2684 /*-----------------------------------------------------------------*/
2686 processFuncPtrArgs (sym_link * funcType)
2688 value *val = FUNC_ARGS(funcType);
2690 /* if it is void then remove parameters */
2691 if (val && IS_VOID (val->type))
2693 FUNC_ARGS(funcType) = NULL;
2698 /*-----------------------------------------------------------------*/
2699 /* processFuncArgs - does some processing with function args */
2700 /*-----------------------------------------------------------------*/
2702 processFuncArgs (symbol * func)
2706 sym_link *funcType=func->type;
2708 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2709 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2711 /* find the function declaration within the type */
2712 while (funcType && !IS_FUNC(funcType))
2713 funcType=funcType->next;
2715 /* if this function has variable argument list */
2716 /* then make the function a reentrant one */
2717 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2718 FUNC_ISREENT(funcType)=1;
2720 /* check if this function is defined as calleeSaves
2721 then mark it as such */
2722 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2724 /* loop thru all the arguments */
2725 val = FUNC_ARGS(funcType);
2727 /* if it is void then remove parameters */
2728 if (val && IS_VOID (val->type))
2730 FUNC_ARGS(funcType) = NULL;
2734 /* reset regparm for the port */
2735 (*port->reset_regparms) ();
2737 /* if any of the arguments is an aggregate */
2738 /* change it to pointer to the same type */
2742 char buffer[SDCC_NAME_MAX+1];
2744 SNPRINTF (buffer, sizeof(buffer), "%s parameter %d", func->name, pNum);
2745 checkTypeSanity (val->etype, buffer);
2747 /* mark it as a register parameter if
2748 the function does not have VA_ARG
2749 and as port dictates */
2750 if (!IFFUNC_HASVARARGS(funcType) &&
2751 (argreg = (*port->reg_parm) (val->type, FUNC_ISREENT(funcType))))
2753 SPEC_REGPARM (val->etype) = 1;
2754 SPEC_ARGREG(val->etype) = argreg;
2755 } else if (IFFUNC_ISREENT(funcType)) {
2756 FUNC_HASSTACKPARM(funcType) = 1;
2759 if (IS_AGGREGATE (val->type))
2761 aggregateToPointer (val);
2768 /* if this is an internal generated function call */
2770 /* ignore --stack-auto for this one, we don't know how it is compiled */
2771 /* simply trust on --int-long-reent or --float-reent */
2772 if (IFFUNC_ISREENT(funcType)) {
2776 /* if this function is reentrant or */
2777 /* automatics r 2b stacked then nothing */
2778 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2782 val = FUNC_ARGS(funcType);
2787 /* if a symbolname is not given */
2788 /* synthesize a variable name */
2791 SNPRINTF (val->name, sizeof(val->name),
2792 "_%s_PARM_%d", func->name, pNum++);
2793 val->sym = newSymbol (val->name, 1);
2794 if (SPEC_SCLS(val->etype) == S_BIT)
2795 SPEC_OCLS (val->etype) = bit;
2797 SPEC_OCLS (val->etype) = port->mem.default_local_map;
2798 val->sym->type = copyLinkChain (val->type);
2799 val->sym->etype = getSpec (val->sym->type);
2800 val->sym->_isparm = 1;
2801 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2803 /* ?? static functions shouldn't imply static parameters - EEP */
2804 if (IS_SPEC(func->etype)) {
2805 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2806 SPEC_STAT (func->etype);
2809 addSymChain (&val->sym);
2812 else /* symbol name given create synth name */
2815 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2816 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2817 val->sym->_isparm = 1;
2818 if (SPEC_SCLS(val->etype) == S_BIT)
2819 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = bit;
2821 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2822 port->mem.default_local_map;
2825 /* ?? static functions shouldn't imply static parameters - EEP */
2826 if (IS_SPEC(func->etype)) {
2827 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2828 SPEC_STAT (func->etype);
2832 if (SPEC_OCLS (val->sym->etype) == pdata)
2833 val->sym->iaccess = 1;
2834 if (!isinSet(operKeyReset, val->sym)) {
2835 addSet (&operKeyReset, val->sym);
2836 applyToSet (operKeyReset, resetParmKey);
2842 /*-----------------------------------------------------------------*/
2843 /* isSymbolEqual - compares two symbols return 1 if they match */
2844 /*-----------------------------------------------------------------*/
2846 isSymbolEqual (symbol * dest, symbol * src)
2848 /* if pointers match then equal */
2852 /* if one of them is null then don't match */
2856 /* if both of them have rname match on rname */
2857 if (dest->rname[0] && src->rname[0])
2858 return (!strcmp (dest->rname, src->rname));
2860 /* otherwise match on name */
2861 return (!strcmp (dest->name, src->name));
2864 void PT(sym_link *type)
2866 printTypeChain(type,0);
2868 /*-----------------------------------------------------------------*/
2869 /* printTypeChain - prints the type chain in human readable form */
2870 /*-----------------------------------------------------------------*/
2872 printTypeChain (sym_link * start, FILE * of)
2883 dbuf_init (&dbuf, 1024);
2884 dbuf_printTypeChain (start, &dbuf);
2885 dbuf_write_and_destroy (&dbuf, of);
2892 dbuf_printTypeChain (sym_link * start, struct dbuf_s *dbuf)
2895 sym_link * type, * search;
2899 dbuf_append_str (dbuf, "void");
2903 /* Print the chain as it is written in the source: */
2904 /* start with the last entry. */
2905 /* However, the storage class at the end of the */
2906 /* chain reall applies to the first in the chain! */
2908 for (type = start; type && type->next; type = type->next)
2911 scls=SPEC_SCLS(type);
2919 case S_DATA: dbuf_append_str (dbuf, "data-"); break;
2920 case S_XDATA: dbuf_append_str (dbuf, "xdata-"); break;
2921 case S_SFR: dbuf_append_str (dbuf, "sfr-"); break;
2922 case S_SBIT: dbuf_append_str (dbuf, "sbit-"); break;
2923 case S_CODE: dbuf_append_str (dbuf, "code-"); break;
2924 case S_IDATA: dbuf_append_str (dbuf, "idata-"); break;
2925 case S_PDATA: dbuf_append_str (dbuf, "pdata-"); break;
2926 case S_LITERAL: dbuf_append_str (dbuf, "literal-"); break;
2927 case S_STACK: dbuf_append_str (dbuf, "stack-"); break;
2928 case S_XSTACK: dbuf_append_str (dbuf, "xstack-"); break;
2929 case S_BIT: dbuf_append_str (dbuf, "bit-"); break;
2930 case S_EEPROM: dbuf_append_str (dbuf, "eeprom-"); break;
2937 if (!IS_FUNC(type)) {
2938 if (DCL_PTR_VOLATILE (type)) {
2939 dbuf_append_str (dbuf, "volatile-");
2941 if (DCL_PTR_CONST (type)) {
2942 dbuf_append_str (dbuf, "const-");
2944 if (DCL_PTR_RESTRICT (type)) {
2945 dbuf_append_str (dbuf, "restrict-");
2948 switch (DCL_TYPE (type))
2951 dbuf_printf (dbuf, "function %s %s",
2952 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2953 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2954 dbuf_append_str (dbuf, "( ");
2955 for (args = FUNC_ARGS(type);
2958 dbuf_printTypeChain(args->type, dbuf);
2960 dbuf_append_str (dbuf, ", ");
2962 dbuf_append_str (dbuf, ") ");
2965 dbuf_append_str (dbuf, "generic* ");
2968 dbuf_append_str (dbuf, "code* ");
2971 dbuf_append_str (dbuf, "xdata* ");
2974 dbuf_append_str (dbuf, "eeprom* ");
2977 dbuf_append_str (dbuf, "near* ");
2980 dbuf_append_str (dbuf, "idata* ");
2983 dbuf_append_str (dbuf, "pdata* ");
2986 dbuf_append_str (dbuf, "unknown* ");
2989 if (DCL_ELEM(type)) {
2990 dbuf_printf (dbuf, "[%d] ", DCL_ELEM(type));
2992 dbuf_append_str (dbuf, "[] ");
2999 if (SPEC_VOLATILE (type))
3000 dbuf_append_str (dbuf, "volatile-");
3001 if (SPEC_CONST (type))
3002 dbuf_append_str (dbuf, "const-");
3003 if (SPEC_USIGN (type))
3004 dbuf_append_str (dbuf, "unsigned-");
3005 switch (SPEC_NOUN (type))
3009 dbuf_append_str (dbuf, "long-");
3010 dbuf_append_str (dbuf, "int");
3014 dbuf_append_str (dbuf, "char");
3018 dbuf_append_str (dbuf, "void");
3022 dbuf_append_str (dbuf, "float");
3026 dbuf_append_str (dbuf, "fixed16x16");
3030 dbuf_printf (dbuf, "struct %s", SPEC_STRUCT (type)->tag);
3034 dbuf_append_str (dbuf, "sbit");
3038 dbuf_append_str (dbuf, "bit");
3042 dbuf_printf (dbuf, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
3046 dbuf_append_str (dbuf, "double");
3050 dbuf_append_str (dbuf, "unknown type");
3054 /* search entry in list before "type" */
3055 for (search = start; search && search->next != type;)
3056 search = search->next;
3059 dbuf_append_char(dbuf, ' ');
3063 /*--------------------------------------------------------------------*/
3064 /* printTypeChainRaw - prints the type chain in human readable form */
3065 /* in the raw data structure ordering */
3066 /*--------------------------------------------------------------------*/
3068 printTypeChainRaw (sym_link * start, FILE * of)
3081 fprintf (of, "void");
3091 if (!IS_FUNC(type)) {
3092 if (DCL_PTR_VOLATILE (type)) {
3093 fprintf (of, "volatile-");
3095 if (DCL_PTR_CONST (type)) {
3096 fprintf (of, "const-");
3098 if (DCL_PTR_RESTRICT (type)) {
3099 fprintf (of, "restrict-");
3102 switch (DCL_TYPE (type))
3105 if (IFFUNC_ISINLINE(type)) {
3106 fprintf (of, "inline-");
3108 fprintf (of, "function %s %s",
3109 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
3110 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
3112 for (args = FUNC_ARGS(type);
3115 printTypeChain(args->type, of);
3122 fprintf (of, "generic* ");
3125 fprintf (of, "code* ");
3128 fprintf (of, "xdata* ");
3131 fprintf (of, "eeprom* ");
3134 fprintf (of, "near* ");
3137 fprintf (of, "idata* ");
3140 fprintf (of, "pdata* ");
3143 fprintf (of, "unknown* ");
3146 if (DCL_ELEM(type)) {
3147 fprintf (of, "[%d] ", DCL_ELEM(type));
3149 fprintf (of, "[] ");
3153 if (DCL_TSPEC(type))
3156 printTypeChainRaw(DCL_TSPEC(type), of);
3160 else if (IS_SPEC (type))
3162 switch (SPEC_SCLS (type))
3164 case S_DATA: fprintf (of, "data-"); break;
3165 case S_XDATA: fprintf (of, "xdata-"); break;
3166 case S_SFR: fprintf (of, "sfr-"); break;
3167 case S_SBIT: fprintf (of, "sbit-"); break;
3168 case S_CODE: fprintf (of, "code-"); break;
3169 case S_IDATA: fprintf (of, "idata-"); break;
3170 case S_PDATA: fprintf (of, "pdata-"); break;
3171 case S_LITERAL: fprintf (of, "literal-"); break;
3172 case S_STACK: fprintf (of, "stack-"); break;
3173 case S_XSTACK: fprintf (of, "xstack-"); break;
3174 case S_BIT: fprintf (of, "bit-"); break;
3175 case S_EEPROM: fprintf (of, "eeprom-"); break;
3178 if (SPEC_VOLATILE (type))
3179 fprintf (of, "volatile-");
3180 if (SPEC_CONST (type))
3181 fprintf (of, "const-");
3182 if (SPEC_USIGN (type))
3183 fprintf (of, "unsigned-");
3184 switch (SPEC_NOUN (type))
3188 fprintf (of, "long-");
3189 fprintf (of, "int");
3193 fprintf (of, "char");
3197 fprintf (of, "void");
3201 fprintf (of, "float");
3205 fprintf (of, "fixed16x16");
3209 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
3213 fprintf (of, "sbit");
3217 fprintf (of, "bit");
3221 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
3225 fprintf (of, "double");
3229 fprintf (of, "unknown type");
3234 fprintf (of, "NOT_SPEC_OR_DECL");
3244 /*-----------------------------------------------------------------*/
3245 /* powof2 - returns power of two for the number if number is pow 2 */
3246 /*-----------------------------------------------------------------*/
3248 powof2 (TYPE_TARGET_ULONG num)
3261 if (n1s > 1 || nshifts == 0)
3277 symbol *__fps16x16_add;
3278 symbol *__fps16x16_sub;
3279 symbol *__fps16x16_mul;
3280 symbol *__fps16x16_div;
3281 symbol *__fps16x16_eq;
3282 symbol *__fps16x16_neq;
3283 symbol *__fps16x16_lt;
3284 symbol *__fps16x16_lteq;
3285 symbol *__fps16x16_gt;
3286 symbol *__fps16x16_gteq;
3288 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3289 symbol *__muldiv[3][3][2];
3290 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
3291 sym_link *__multypes[3][2];
3292 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
3293 symbol *__conv[2][3][2];
3294 /* Dims: to/from fixed16x16, BYTE/WORD/DWORD/FLOAT, SIGNED/USIGNED */
3295 symbol *__fp16x16conv[2][4][2];
3296 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3297 symbol *__rlrr[2][3][2];
3299 sym_link *floatType;
3300 sym_link *fixed16x16Type;
3303 _mangleFunctionName(char *in)
3305 if (port->getMangledFunctionName)
3307 return port->getMangledFunctionName(in);
3315 /*-----------------------------------------------------------------*/
3316 /* typeFromStr - create a typechain from an encoded string */
3317 /* basic types - 'c' - char */
3322 /* 'q' - fixed16x16 */
3324 /* '*' - pointer - default (GPOINTER) */
3325 /* modifiers - 'u' - unsigned */
3326 /* pointer modifiers - 'g' - generic */
3330 /* 'F' - function */
3331 /* examples : "ig*" - generic int * */
3332 /* "cx*" - char xdata * */
3333 /* "ui" - unsigned int */
3334 /*-----------------------------------------------------------------*/
3335 sym_link *typeFromStr (char *s)
3337 sym_link *r = newLink(DECLARATOR);
3349 r->class = SPECIFIER;
3350 SPEC_NOUN(r) = V_CHAR;
3354 r->class = SPECIFIER;
3355 SPEC_NOUN(r) = V_INT;
3358 r->class = SPECIFIER;
3359 SPEC_NOUN(r) = V_INT;
3363 r->class = SPECIFIER;
3364 SPEC_NOUN(r) = V_FLOAT;
3367 r->class = SPECIFIER;
3368 SPEC_NOUN(r) = V_FIXED16X16;
3371 r->class = SPECIFIER;
3372 SPEC_NOUN(r) = V_VOID;
3375 DCL_TYPE(r) = port->unqualified_pointer;
3382 assert(*(s+1)=='*');
3383 nr = newLink(DECLARATOR);
3388 DCL_TYPE(r) = GPOINTER;
3391 DCL_TYPE(r) = FPOINTER;
3394 DCL_TYPE(r) = CPOINTER;
3397 DCL_TYPE(r) = POINTER;
3400 DCL_TYPE(r) = FUNCTION;
3401 nr = newLink(DECLARATOR);
3404 DCL_TYPE(r) = CPOINTER;
3410 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
3411 "typeFromStr: unknown type");
3414 if (IS_SPEC(r) && usign) {
3423 /*-----------------------------------------------------------------*/
3424 /* initCSupport - create functions for C support routines */
3425 /*-----------------------------------------------------------------*/
3429 const char *smuldivmod[] =
3433 const char *sbwd[] =
3435 "char", "int", "long", "fixed16x16",
3437 const char *fp16x16sbwd[] =
3439 "char", "int", "long", "float",
3445 const char *srlrr[] =
3450 int bwd, su, muldivmod, tofrom, rlrr;
3452 if (getenv("SDCC_NO_C_SUPPORT")) {
3453 /* for debugging only */
3457 floatType = newFloatLink ();
3458 fixed16x16Type = newFixed16x16Link ();
3460 for (bwd = 0; bwd < 3; bwd++)
3477 __multypes[bwd][0] = l;
3478 __multypes[bwd][1] = copyLinkChain (l);
3479 SPEC_USIGN (__multypes[bwd][1]) = 1;
3482 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
3483 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
3484 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
3485 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
3486 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
3487 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
3488 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
3489 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
3490 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
3491 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
3493 __fps16x16_add = funcOfType ("__fps16x16_add", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3494 __fps16x16_sub = funcOfType ("__fps16x16_sub", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3495 __fps16x16_mul = funcOfType ("__fps16x16_mul", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3496 __fps16x16_div = funcOfType ("__fps16x16_div", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3497 __fps16x16_eq = funcOfType ("__fps16x16_eq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3498 __fps16x16_neq = funcOfType ("__fps16x16_neq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3499 __fps16x16_lt = funcOfType ("__fps16x16_lt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3500 __fps16x16_lteq = funcOfType ("__fps16x16_lteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3501 __fps16x16_gt = funcOfType ("__fps16x16_gt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3502 __fps16x16_gteq = funcOfType ("__fps16x16_gteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3505 for (tofrom = 0; tofrom < 2; tofrom++)
3507 for (bwd = 0; bwd < 3; bwd++)
3509 for (su = 0; su < 2; su++)
3513 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
3514 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
3518 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
3519 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
3525 for (tofrom = 0; tofrom < 2; tofrom++)
3527 for (bwd = 0; bwd < 4; bwd++)
3529 for (su = 0; su < 2; su++)
3533 SNPRINTF (buffer, sizeof(buffer), "__fps16x162%s%s", ssu[su], fp16x16sbwd[bwd]);
3535 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, floatType, fixed16x16Type, 1, options.float_rent);
3537 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], fixed16x16Type, 1, options.float_rent);
3541 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fps16x16", ssu[su], fp16x16sbwd[bwd]);
3543 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, floatType, 1, options.float_rent);
3545 __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, __multypes[bwd][su], 1, options.float_rent);
3552 for (muldivmod = 0; muldivmod < 3; muldivmod++)
3554 for (bwd = 0; bwd < 3; bwd++)
3556 for (su = 0; su < 2; su++)
3558 SNPRINTF (buffer, sizeof(buffer),
3560 smuldivmod[muldivmod],
3563 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3564 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3569 muluint() and mulsint() resp. mululong() and mulslong() return the same result.
3570 Therefore they've been merged into mulint() and mullong().
3573 for (bwd = 0; bwd < 3; bwd++)
3575 for (su = 0; su < 2; su++)
3577 for (muldivmod = 1; muldivmod < 3; muldivmod++)
3579 /* div and mod : s8_t x s8_t -> s8_t should be s8_t x s8_t -> s16_t, see below */
3580 if (!TARGET_IS_PIC16 || muldivmod != 1 || bwd != 0 || su != 0)
3582 SNPRINTF (buffer, sizeof(buffer),
3584 smuldivmod[muldivmod],
3587 __muldiv[muldivmod][bwd][su] = funcOfType (
3588 _mangleFunctionName(buffer),
3589 __multypes[bwd][su],
3590 __multypes[bwd][su],
3592 options.intlong_rent);
3593 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3599 if (TARGET_IS_PIC16)
3601 /* PIC16 port wants __divschar/__modschar to return an int, so that both
3602 * 100 / -4 = -25 and -128 / -1 = 128 can be handled correctly
3603 * (first one would have to be sign extended, second one must not be).
3604 * Similarly, modschar should be handled, but the iCode introduces cast
3605 * here and forces '% : s8 x s8 -> s8' ... */
3607 for (muldivmod = 1; muldivmod < 2; muldivmod++) {
3608 SNPRINTF (buffer, sizeof(buffer),
3610 smuldivmod[muldivmod],
3613 __muldiv[muldivmod][bwd][su] = funcOfType (
3614 _mangleFunctionName(buffer),
3616 __multypes[bwd][su],
3618 options.intlong_rent);
3619 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3627 for (su = 0; su < 2; su++)
3629 /* muluchar and mulschar are still separate functions, because e.g. the z80
3630 port is sign/zero-extending to int before calling mulint() */
3631 SNPRINTF (buffer, sizeof(buffer),
3633 smuldivmod[muldivmod],
3636 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3637 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3641 /* word and doubleword */
3642 for (bwd = 1; bwd < 3; bwd++)
3645 SNPRINTF (buffer, sizeof(buffer),
3647 smuldivmod[muldivmod],
3649 __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3650 FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
3651 /* signed = unsigned */
3652 __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
3655 for (rlrr = 0; rlrr < 2; rlrr++)
3657 for (bwd = 0; bwd < 3; bwd++)
3659 for (su = 0; su < 2; su++)
3661 SNPRINTF (buffer, sizeof(buffer),
3666 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
3667 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
3673 /*-----------------------------------------------------------------*/
3674 /* initBuiltIns - create prototypes for builtin functions */
3675 /*-----------------------------------------------------------------*/
3681 if (!port->builtintable) return ;
3683 for (i = 0 ; port->builtintable[i].name ; i++) {
3684 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
3685 port->builtintable[i].nParms,port->builtintable[i].parm_types);
3686 FUNC_ISBUILTIN(sym->type) = 1;
3687 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
3691 sym_link *validateLink(sym_link *l,
3698 if (l && l->class==select)
3703 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
3704 " expected %s, got %s\n",
3705 macro, args, file, line,
3706 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
3708 return l; // never reached, makes compiler happy.
3711 /*--------------------------------------------------------------------*/
3712 /* newEnumType - create an integer type compatible with enumerations */
3713 /*--------------------------------------------------------------------*/
3715 newEnumType (symbol *enumlist)
3723 type = newLink (SPECIFIER);
3724 SPEC_NOUN (type) = V_INT;
3728 /* Determine the range of the enumerated values */
3730 min = max = (int) ulFromVal (valFromType (sym->type));
3731 for (sym = sym->next; sym; sym = sym->next)
3733 v = (int) ulFromVal (valFromType (sym->type));
3740 /* Determine the smallest integer type that is compatible with this range */
3741 type = newLink (SPECIFIER);
3742 if (min>=0 && max<=255)
3744 SPEC_NOUN (type) = V_CHAR;
3745 SPEC_USIGN (type) = 1;
3747 else if (min>=-128 && max<=127)
3749 SPEC_NOUN (type) = V_CHAR;
3751 else if (min>=0 && max<=65535)
3753 SPEC_NOUN (type) = V_INT;
3754 SPEC_USIGN (type) = 1;
3756 else if (min>=-32768 && max<=32767)
3758 SPEC_NOUN (type) = V_INT;
3762 SPEC_NOUN (type) = V_INT;
3763 SPEC_LONG (type) = 1;
3765 SPEC_USIGN (type) = 1;