1 /*-------------------------------------------------------------------------
2 SDCCsymt.c - Code file for Symbols table related structures and MACRO's.
3 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 In other words, you are welcome to use, share and improve this program.
20 You are forbidden to forbid anyone else to use, share and improve
21 what you give them. Help stamp out software-hoarding!
22 -------------------------------------------------------------------------*/
27 value *aggregateToPointer (value *val);
29 void printFromToType(sym_link *from, sym_link *to) {
30 fprintf (stderr, "from type '");
31 printTypeChain (from, stderr);
32 fprintf (stderr, "'\nto type '");
33 printTypeChain (to, stderr);
34 fprintf (stderr, "'\n");
38 char *nounName(sym_link *sl) {
39 switch (SPEC_NOUN(sl))
42 if (SPEC_LONG(sl)) return "long";
43 if (sl->select.s._short) return "short";
46 case V_FLOAT: return "float";
47 case V_CHAR: return "char";
48 case V_VOID: return "void";
49 case V_STRUCT: return "struct";
50 case V_LABEL: return "label";
51 case V_BIT: return "bit";
52 case V_SBIT: return "sbit";
53 case V_DOUBLE: return "double";
58 bucket *SymbolTab[256]; /* the symbol table */
59 bucket *StructTab[256]; /* the structure table */
60 bucket *TypedefTab[256]; /* the typedef table */
61 bucket *LabelTab[256]; /* the Label table */
62 bucket *enumTab[256]; /* enumerated table */
64 /*------------------------------------------------------------------*/
65 /* initSymt () - initialises symbol table related stuff */
66 /*------------------------------------------------------------------*/
72 for (i = 0; i < 256; i++)
73 SymbolTab[i] = StructTab[i] = (void *) NULL;
77 /*-----------------------------------------------------------------*/
78 /* newBucket - allocates & returns a new bucket */
79 /*-----------------------------------------------------------------*/
85 bp = Safe_alloc ( sizeof (bucket));
90 /*-----------------------------------------------------------------*/
91 /* hashKey - computes the hashkey given a symbol name */
92 /*-----------------------------------------------------------------*/
94 hashKey (const char *s)
96 unsigned long key = 0;
103 /*-----------------------------------------------------------------*/
104 /* addSym - adds a symbol to the hash Table */
105 /*-----------------------------------------------------------------*/
107 addSym (bucket ** stab,
114 int i; /* index into the hash Table */
115 bucket *bp; /* temp bucket * */
118 symbol *csym = (symbol *)sym;
120 if (getenv("DEBUG_SANITY")) {
121 fprintf (stderr, "addSym: %s ", sname);
123 /* make sure the type is complete and sane */
124 checkTypeSanity(csym->etype, csym->name);
127 /* prevent overflow of the (r)name buffers */
128 if (strlen(sname)>SDCC_SYMNAME_MAX) {
129 werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
130 sname[SDCC_SYMNAME_MAX]='\0';
133 /* the symbols are always added at the head of the list */
135 /* get a free entry */
136 bp = Safe_alloc ( sizeof (bucket));
138 bp->sym = sym; /* update the symbol pointer */
139 bp->level = level; /* update the nest level */
141 strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
143 /* if this is the first entry */
146 bp->prev = bp->next = (void *) NULL; /* point to nothing */
149 /* not first entry then add @ head of list */
159 /*-----------------------------------------------------------------*/
160 /* deleteSym - deletes a symbol from the hash Table entry */
161 /*-----------------------------------------------------------------*/
163 deleteSym (bucket ** stab, void *sym, char *sname)
171 /* find the symbol */
174 if (bp->sym == sym) /* found it then break out */
175 break; /* of the loop */
179 if (!bp) /* did not find it */
181 /* if this is the first one in the chain */
185 if (stab[i]) /* if chain ! empty */
186 stab[i]->prev = (void *) NULL;
188 /* middle || end of chain */
191 if (bp->next) /* if not end of chain */
192 bp->next->prev = bp->prev;
194 bp->prev->next = bp->next;
199 /*-----------------------------------------------------------------*/
200 /* findSym - finds a symbol in a table */
201 /*-----------------------------------------------------------------*/
203 findSym (bucket ** stab, void *sym, const char *sname)
207 bp = stab[hashKey (sname)];
210 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
215 return (bp ? bp->sym : (void *) NULL);
218 /*-----------------------------------------------------------------*/
219 /* findSymWithLevel - finds a symbol with a name & level */
220 /*-----------------------------------------------------------------*/
222 findSymWithLevel (bucket ** stab, symbol * sym)
226 bp = stab[hashKey (sym->name)];
229 ** do the search from the head of the list since the
230 ** elements are added at the head it is ensured that
231 ** we will find the deeper definitions before we find
232 ** the global ones. we need to check for symbols with
233 ** level <= to the level given, if levels match then block
234 ** numbers need to match as well
238 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
240 /* if this is parameter then nothing else need to be checked */
241 if (((symbol *) (bp->sym))->_isparm)
243 /* if levels match then block numbers should also match */
244 if (bp->level && bp->level == sym->level && bp->block == sym->block)
246 /* if levels don't match then we are okay */
247 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
249 /* if this is a global variable then we are ok too */
257 return (void *) NULL;
260 /*-----------------------------------------------------------------*/
261 /* findSymWithBlock - finds a symbol with name in with a block */
262 /*-----------------------------------------------------------------*/
264 findSymWithBlock (bucket ** stab, symbol * sym, int block)
268 bp = stab[hashKey (sym->name)];
271 if (strcmp (bp->name, sym->name) == 0 &&
277 return (bp ? bp->sym : (void *) NULL);
280 /*------------------------------------------------------------------*/
281 /* newSymbol () - returns a new pointer to a symbol */
282 /*------------------------------------------------------------------*/
284 newSymbol (char *name, int scope)
288 sym = Safe_alloc ( sizeof (symbol));
290 strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */
291 sym->level = scope; /* set the level */
292 sym->block = currBlockno;
293 sym->lineDef = yylineno; /* set the line number */
297 /*------------------------------------------------------------------*/
298 /* newLink - creates a new link (declarator,specifier) */
299 /*------------------------------------------------------------------*/
301 newLink (SYM_LINK_CLASS select)
305 p = Safe_alloc ( sizeof (sym_link));
311 /*------------------------------------------------------------------*/
312 /* newStruct - creats a new structdef from the free list */
313 /*------------------------------------------------------------------*/
315 newStruct (char *tag)
319 s = Safe_alloc ( sizeof (structdef));
321 strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
325 /*------------------------------------------------------------------*/
326 /* pointerTypes - do the computation for the pointer types */
327 /*------------------------------------------------------------------*/
329 pointerTypes (sym_link * ptr, sym_link * type)
334 /* find the first pointer type */
335 while (ptr && !IS_PTR (ptr))
338 /* could not find it */
339 if (!ptr || IS_SPEC (ptr))
342 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
343 pointerTypes (ptr->next, type);
347 /* change the pointer type depending on the
348 storage class of the type */
351 DCL_PTR_CONST (ptr) = SPEC_CONST (type);
352 DCL_PTR_VOLATILE (ptr) = SPEC_VOLATILE (type);
353 switch (SPEC_SCLS (type))
356 DCL_TYPE (ptr) = FPOINTER;
359 DCL_TYPE (ptr) = IPOINTER;
362 DCL_TYPE (ptr) = PPOINTER;
365 DCL_TYPE (ptr) = POINTER;
368 DCL_PTR_CONST (ptr) = port->mem.code_ro;
369 DCL_TYPE (ptr) = CPOINTER;
372 DCL_TYPE (ptr) = EEPPOINTER;
375 DCL_TYPE (ptr) = port->unqualified_pointer;
378 /* the storage class of type ends here */
381 SPEC_VOLATILE (type) = 0;
384 /* now change all the remaining unknown pointers
385 to generic pointers */
388 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
389 DCL_TYPE (ptr) = port->unqualified_pointer;
393 /* same for the type although it is highly unlikely that
394 type will have a pointer */
397 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
398 DCL_TYPE (type) = port->unqualified_pointer;
404 /*------------------------------------------------------------------*/
405 /* addDecl - adds a declarator @ the end of a chain */
406 /*------------------------------------------------------------------*/
408 addDecl (symbol * sym, int type, sym_link * p)
414 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
415 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
417 /* if we are passed a link then set head & tail */
426 head = tail = newLink (DECLARATOR);
427 DCL_TYPE (head) = type;
430 /* if this is the first entry */
438 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
440 sym->etype = mergeSpec (sym->etype, head, sym->name);
444 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
447 while (t->next != sym->etype)
450 tail->next = sym->etype;
454 sym->etype->next = head;
460 /* if the type is an unknown pointer and has
461 a tspec then take the storage class const & volatile
462 attribute from the tspec & make it those of this
466 //DCL_TYPE (p) == UPOINTER &&
469 if (!IS_SPEC (sym->etype))
471 sym->etype = sym->etype->next = newLink (SPECIFIER);
473 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
474 SPEC_CONST (sym->etype) = SPEC_CONST (DCL_TSPEC (p));
475 SPEC_VOLATILE (sym->etype) = SPEC_VOLATILE (DCL_TSPEC (p));
476 DCL_TSPEC (p) = NULL;
479 // if there is a function in this type chain
480 if (p && funcInChain(sym->type)) {
481 processFuncArgs (sym);
487 /*------------------------------------------------------------------
488 checkTypeSanity: prevent the user from doing e.g.:
490 ------------------------------------------------------------------*/
491 void checkTypeSanity(sym_link *etype, char *name) {
495 if (getenv("DEBUG_SANITY")) {
496 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
501 if (!IS_SPEC(etype)) {
502 if (getenv("DEBUG_SANITY")) {
503 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
508 noun=nounName(etype);
510 if (getenv("DEBUG_SANITY")) {
511 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
514 if ((SPEC_NOUN(etype)==V_CHAR ||
515 SPEC_NOUN(etype)==V_FLOAT ||
516 SPEC_NOUN(etype)==V_DOUBLE ||
517 SPEC_NOUN(etype)==V_VOID) &&
518 (etype->select.s._short || SPEC_LONG(etype))) {
519 // long or short for char float double or void
520 werror (E_LONG_OR_SHORT_INVALID, noun, name);
522 if ((SPEC_NOUN(etype)==V_FLOAT ||
523 SPEC_NOUN(etype)==V_DOUBLE ||
524 SPEC_NOUN(etype)==V_VOID) &&
525 (etype->select.s._signed || SPEC_USIGN(etype))) {
526 // signed or unsigned for float double or void
527 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
530 // special case for "short"
531 if (etype->select.s._short) {
532 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
533 etype->select.s._short = 0;
537 "const a;" or "data b;" or "signed s" or "long l"
539 if (!SPEC_NOUN(etype)) {
540 SPEC_NOUN(etype)=V_INT;
543 if (etype->select.s._signed && SPEC_USIGN(etype)) {
544 // signed AND unsigned
545 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
547 if (etype->select.s._short && SPEC_LONG(etype)) {
549 werror (E_LONG_AND_SHORT_INVALID, noun, name);
554 /*------------------------------------------------------------------*/
555 /* mergeSpec - merges two specifiers and returns the new one */
556 /*------------------------------------------------------------------*/
558 mergeSpec (sym_link * dest, sym_link * src, char *name)
560 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
562 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
565 werror (E_SYNTAX_ERROR, yytext);
566 // the show must go on
571 if (SPEC_NOUN(src)) {
572 if (!SPEC_NOUN(dest)) {
573 SPEC_NOUN(dest)=SPEC_NOUN(src);
575 /* we shouldn't redeclare the type */
576 if (getenv("DEBUG_SANITY")) {
577 fprintf (stderr, "mergeSpec: ");
579 werror(E_TWO_OR_MORE_DATA_TYPES, name);
583 if (SPEC_SCLS(src)) {
584 /* if destination has no storage class */
585 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
586 SPEC_SCLS (dest) = SPEC_SCLS (src);
588 if (getenv("DEBUG_SANITY")) {
589 fprintf (stderr, "mergeSpec: ");
591 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
595 /* copy all the specifications */
597 // we really should do:
599 if (SPEC_what(src)) {
600 if (SPEC_what(dest)) {
601 werror(W_DUPLICATE_SPEC, "what");
603 SPEC_what(dst)|=SPEC_what(src);
606 // but there are more important thing right now
608 SPEC_LONG (dest) |= SPEC_LONG (src);
609 dest->select.s._short|=src->select.s._short;
610 SPEC_USIGN (dest) |= SPEC_USIGN (src);
611 dest->select.s._signed|=src->select.s._signed;
612 SPEC_STAT (dest) |= SPEC_STAT (src);
613 SPEC_EXTR (dest) |= SPEC_EXTR (src);
614 SPEC_CONST(dest) |= SPEC_CONST (src);
615 SPEC_ABSA (dest) |= SPEC_ABSA (src);
616 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
617 SPEC_ADDR (dest) |= SPEC_ADDR (src);
618 SPEC_OCLS (dest) = SPEC_OCLS (src);
619 SPEC_BLEN (dest) |= SPEC_BLEN (src);
620 SPEC_BSTR (dest) |= SPEC_BSTR (src);
621 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
622 SPEC_ENUM (dest) |= SPEC_ENUM (src);
623 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
624 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
626 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
627 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
629 /* these are the only function attributes that will be set
630 in a specifier while parsing */
631 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
632 FUNC_BANKED(dest) |= FUNC_BANKED(src);
633 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
634 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
635 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
636 FUNC_ISISR(dest) |= FUNC_ISISR(src);
637 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
638 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
639 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
640 FUNC_INTNO(dest) |= FUNC_INTNO(src);
641 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
646 /*------------------------------------------------------------------*/
647 /* genSymName - generates and returns a name used for anonymous vars */
648 /*------------------------------------------------------------------*/
650 genSymName (int level)
652 static int gCount = 0;
653 static char gname[SDCC_NAME_MAX + 1];
655 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
659 /*------------------------------------------------------------------*/
660 /* getSpec - returns the specifier part from a declaration chain */
661 /*------------------------------------------------------------------*/
663 getSpec (sym_link * p)
668 while (p && !(IS_SPEC (p)))
674 /*------------------------------------------------------------------*/
675 /* newCharLink() - creates an char type */
676 /*------------------------------------------------------------------*/
682 p = newLink (SPECIFIER);
683 SPEC_NOUN (p) = V_CHAR;
688 /*------------------------------------------------------------------*/
689 /* newFloatLink - a new Float type */
690 /*------------------------------------------------------------------*/
696 p = newLink (SPECIFIER);
697 SPEC_NOUN (p) = V_FLOAT;
702 /*------------------------------------------------------------------*/
703 /* newLongLink() - new long type */
704 /*------------------------------------------------------------------*/
710 p = newLink (SPECIFIER);
711 SPEC_NOUN (p) = V_INT;
717 /*------------------------------------------------------------------*/
718 /* newIntLink() - creates an int type */
719 /*------------------------------------------------------------------*/
725 p = newLink (SPECIFIER);
726 SPEC_NOUN (p) = V_INT;
731 /*------------------------------------------------------------------*/
732 /* getSize - returns size of a type chain in bits */
733 /*------------------------------------------------------------------*/
735 getSize (sym_link * p)
737 /* if nothing return 0 */
741 { /* if this is the specifier then */
742 switch (SPEC_NOUN (p))
743 { /* depending on the specifier type */
745 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
753 return SPEC_STRUCT (p)->size;
759 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
765 /* this is a specifier */
766 switch (DCL_TYPE (p))
770 return DCL_ELEM (p) * getSize (p->next);
772 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
773 // "can not tell the size of an array[]");
793 /*------------------------------------------------------------------*/
794 /* bitsForType - returns # of bits required to store this type */
795 /*------------------------------------------------------------------*/
797 bitsForType (sym_link * p)
799 /* if nothing return 0 */
804 { /* if this is the specifier then */
806 switch (SPEC_NOUN (p))
807 { /* depending on the specifier type */
809 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
811 return FLOATSIZE * 8;
817 return SPEC_STRUCT (p)->size * 8;
823 return SPEC_BLEN (p);
829 /* this is a specifier */
830 switch (DCL_TYPE (p))
833 return DCL_ELEM (p) * getSize (p->next) * 8;
837 return (PTRSIZE * 8);
842 return (FPTRSIZE * 8);
844 return (GPTRSIZE * 8);
851 /*------------------------------------------------------------------*/
852 /* copySymbolChain - copies a symbol chain */
853 /*------------------------------------------------------------------*/
855 copySymbolChain (symbol * src)
862 dest = copySymbol (src);
863 dest->next = copySymbolChain (src->next);
867 /*------------------------------------------------------------------*/
868 /* copySymbol - makes a copy of a symbol */
869 /*------------------------------------------------------------------*/
871 copySymbol (symbol * src)
878 dest = newSymbol (src->name, src->level);
879 memcpy (dest, src, sizeof (symbol));
880 dest->level = src->level;
881 dest->block = src->block;
882 dest->ival = copyIlist (src->ival);
883 dest->type = copyLinkChain (src->type);
884 dest->etype = getSpec (dest->type);
886 dest->key = src->key;
887 dest->allocreq = src->allocreq;
891 /*------------------------------------------------------------------*/
892 /* reverseSyms - reverses the links for a symbol chain */
893 /*------------------------------------------------------------------*/
895 reverseSyms (symbol * sym)
897 symbol *prev, *curr, *next;
912 sym->next = (void *) NULL;
916 /*------------------------------------------------------------------*/
917 /* reverseLink - reverses the links for a type chain */
918 /*------------------------------------------------------------------*/
920 reverseLink (sym_link * type)
922 sym_link *prev, *curr, *next;
937 type->next = (void *) NULL;
941 /*------------------------------------------------------------------*/
942 /* addSymChain - adds a symbol chain to the symboltable */
943 /*------------------------------------------------------------------*/
945 addSymChain (symbol * symHead)
947 symbol *sym = symHead;
950 for (; sym != NULL; sym = sym->next)
953 checkTypeSanity(sym->etype, sym->name);
955 /* if already exists in the symbol table then check if
956 one of them is an extern definition if yes then
957 then check if the type match, if the types match then
958 delete the current entry and add the new entry */
959 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
960 csym->level == sym->level) {
962 /* one definition extern ? */
963 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) {
964 /* do types match ? */
965 if (compareType (csym->type, sym->type) != 1) {
967 werror (E_EXTERN_MISMATCH, csym->name);
972 if (compareType (csym->type, sym->type) != 1) {
973 werror (E_DUPLICATE, sym->name);
977 /* delete current entry */
978 deleteSym (SymbolTab, csym, csym->name);
983 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
988 /*------------------------------------------------------------------*/
989 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
990 /*------------------------------------------------------------------*/
992 funcInChain (sym_link * lnk)
1003 /*------------------------------------------------------------------*/
1004 /* structElemType - returns the type info of a sturct member */
1005 /*------------------------------------------------------------------*/
1007 structElemType (sym_link * stype, value * id)
1009 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1010 sym_link *type, *etype;
1011 sym_link *petype = getSpec (stype);
1015 /* look for the id */
1018 if (strcmp (fields->rname, id->name) == 0)
1020 type = copyLinkChain (fields->type);
1021 etype = getSpec (type);
1022 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1023 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1026 fields = fields->next;
1030 werror (E_NOT_MEMBER, id->name);
1032 // the show must go on
1033 return newIntLink();
1036 /*------------------------------------------------------------------*/
1037 /* getStructElement - returns element of a tructure definition */
1038 /*------------------------------------------------------------------*/
1040 getStructElement (structdef * sdef, symbol * sym)
1044 for (field = sdef->fields; field; field = field->next)
1045 if (strcmp (field->name, sym->name) == 0)
1048 werror (E_NOT_MEMBER, sym->name);
1050 return sdef->fields;
1053 /*------------------------------------------------------------------*/
1054 /* compStructSize - computes the size of a structure */
1055 /*------------------------------------------------------------------*/
1057 compStructSize (int su, structdef * sdef)
1059 int sum = 0, usum = 0;
1063 /* for the identifiers */
1064 loop = sdef->fields;
1067 /* create the internal name for this variable */
1068 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1069 loop->offset = (su == UNION ? sum = 0 : sum);
1070 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1072 /* if this is a bit field */
1075 /* change it to a unsigned bit */
1076 SPEC_NOUN (loop->etype) = V_BIT;
1077 SPEC_USIGN (loop->etype) = 1;
1078 /* check if this fit into the remaining */
1079 /* bits of this byte else align it to the */
1080 /* next byte boundary */
1081 if ((SPEC_BLEN (loop->etype) = loop->bitVar) <= (8 - bitOffset)) {
1082 SPEC_BSTR (loop->etype) = bitOffset;
1083 if ((bitOffset += (loop->bitVar % 8)) == 8)
1086 else /* does not fit */ {
1088 SPEC_BSTR (loop->etype) = bitOffset;
1089 sum += (loop->bitVar / 8);
1090 bitOffset += (loop->bitVar % 8);
1092 /* if this is the last field then pad */
1093 if (!loop->next && bitOffset && bitOffset != 8) {
1099 checkDecl (loop, 1);
1100 sum += getSize (loop->type);
1105 /* if this is not a bitfield but the */
1106 /* previous one was and did not take */
1107 /* the whole byte then pad the rest */
1108 if ((loop && !loop->bitVar) && bitOffset) {
1113 /* if union then size = sizeof larget field */
1115 usum = max (usum, sum);
1119 return (su == UNION ? usum : sum);
1122 /*------------------------------------------------------------------*/
1123 /* checkSClass - check the storage class specification */
1124 /*------------------------------------------------------------------*/
1126 checkSClass (symbol * sym, int isProto)
1128 if (getenv("DEBUG_SANITY")) {
1129 fprintf (stderr, "checkSClass: %s \n", sym->name);
1132 /* type is literal can happen foe enums change
1134 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1135 SPEC_SCLS (sym->etype) = S_AUTO;
1137 /* if sfr or sbit then must also be volatile */
1138 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1139 SPEC_SCLS (sym->etype) == S_SFR)
1141 SPEC_VOLATILE (sym->etype) = 1;
1144 /* if absolute address given then it mark it as
1145 volatile -- except in the PIC port */
1147 #if !OPT_DISABLE_PIC
1148 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1152 if (IS_ABSOLUTE (sym->etype))
1153 SPEC_VOLATILE (sym->etype) = 1;
1156 /* global variables declared const put into code */
1157 /* if no other storage class specified */
1158 if (sym->level == 0 &&
1159 SPEC_CONST (sym->etype) &&
1160 SPEC_SCLS(sym->etype) == S_FIXED &&
1161 !IS_FUNC(sym->type)) {
1162 SPEC_SCLS (sym->etype) = S_CODE;
1165 /* global variable in code space is a constant */
1166 if (sym->level == 0 &&
1167 SPEC_SCLS (sym->etype) == S_CODE &&
1168 port->mem.code_ro) {
1169 if (IS_SPEC(sym->type)) {
1170 SPEC_CONST (sym->type) = 1;
1172 DCL_PTR_CONST (sym->type) = 1;
1176 /* if bit variable then no storage class can be */
1177 /* specified since bit is already a storage */
1178 if (IS_BITVAR (sym->etype) &&
1179 (SPEC_SCLS (sym->etype) != S_FIXED &&
1180 SPEC_SCLS (sym->etype) != S_SBIT &&
1181 SPEC_SCLS (sym->etype) != S_BIT)
1184 werror (E_BITVAR_STORAGE, sym->name);
1185 SPEC_SCLS (sym->etype) = S_FIXED;
1188 /* extern variables cannot be initialized */
1189 if (IS_EXTERN (sym->etype) && sym->ival)
1191 werror (E_EXTERN_INIT, sym->name);
1195 /* if this is an atomatic symbol */
1196 if (sym->level && (options.stackAuto || reentrant)) {
1197 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1198 SPEC_SCLS (sym->etype) == S_FIXED ||
1199 SPEC_SCLS (sym->etype) == S_REGISTER ||
1200 SPEC_SCLS (sym->etype) == S_STACK ||
1201 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1202 SPEC_SCLS (sym->etype) = S_AUTO;
1204 /* storage class may only be specified for statics */
1205 if (!IS_STATIC(sym->etype)) {
1206 werror (E_AUTO_ASSUMED, sym->name);
1211 /* automatic symbols cannot be given */
1212 /* an absolute address ignore it */
1214 SPEC_ABSA (sym->etype) &&
1215 (options.stackAuto || reentrant))
1217 werror (E_AUTO_ABSA, sym->name);
1218 SPEC_ABSA (sym->etype) = 0;
1221 /* arrays & pointers cannot be defined for bits */
1222 /* SBITS or SFRs or BIT */
1223 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1224 (SPEC_NOUN (sym->etype) == V_BIT ||
1225 SPEC_NOUN (sym->etype) == V_SBIT ||
1226 SPEC_SCLS (sym->etype) == S_SFR))
1227 werror (E_BIT_ARRAY, sym->name);
1229 /* if this is a bit|sbit then set length & start */
1230 if (SPEC_NOUN (sym->etype) == V_BIT ||
1231 SPEC_NOUN (sym->etype) == V_SBIT)
1233 SPEC_BLEN (sym->etype) = 1;
1234 SPEC_BSTR (sym->etype) = 0;
1238 /* variables declared in CODE space must have */
1239 /* initializers if not an extern */
1240 if (SPEC_SCLS (sym->etype) == S_CODE &&
1241 sym->ival == NULL &&
1243 port->mem.code_ro &&
1244 !IS_EXTERN (sym->etype) &&
1245 !funcInChain (sym->type))
1246 werror (E_CODE_NO_INIT, sym->name);
1249 /* if parameter or local variable then change */
1250 /* the storage class to reflect where the var will go */
1251 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1252 !IS_STATIC(sym->etype))
1254 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1256 SPEC_SCLS (sym->etype) = (options.useXstack ?
1257 S_XSTACK : S_STACK);
1261 /* hack-o-matic! I see no reason why the useXstack option should ever
1262 * control this allcoation, but the code was originally that way, and
1263 * changing it for non-390 ports breaks the compiler badly.
1265 bool useXdata = TARGET_IS_DS390 ? 1 : options.useXstack;
1266 SPEC_SCLS (sym->etype) = (useXdata ?
1272 /*------------------------------------------------------------------*/
1273 /* changePointer - change pointer to functions */
1274 /*------------------------------------------------------------------*/
1276 changePointer (symbol * sym)
1280 /* go thru the chain of declarations */
1281 /* if we find a pointer to a function */
1282 /* unconditionally change it to a ptr */
1284 for (p = sym->type; p; p = p->next)
1286 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1287 DCL_TYPE (p) = port->unqualified_pointer;
1288 if (IS_PTR (p) && IS_FUNC (p->next))
1289 DCL_TYPE (p) = CPOINTER;
1293 /*------------------------------------------------------------------*/
1294 /* checkDecl - does semantic validation of a declaration */
1295 /*------------------------------------------------------------------*/
1297 checkDecl (symbol * sym, int isProto)
1300 checkSClass (sym, isProto); /* check the storage class */
1301 changePointer (sym); /* change pointers if required */
1303 /* if this is an array without any dimension
1304 then update the dimension from the initial value */
1305 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1306 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1311 /*------------------------------------------------------------------*/
1312 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1313 /*------------------------------------------------------------------*/
1315 copyLinkChain (sym_link * p)
1317 sym_link *head, *curr, *loop;
1320 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1323 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1324 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1333 /*------------------------------------------------------------------*/
1334 /* cleanUpBlock - cleansup the symbol table specified for all the */
1335 /* symbols in the given block */
1336 /*------------------------------------------------------------------*/
1338 cleanUpBlock (bucket ** table, int block)
1343 /* go thru the entire table */
1344 for (i = 0; i < 256; i++)
1346 for (chain = table[i]; chain; chain = chain->next)
1348 if (chain->block >= block)
1350 deleteSym (table, chain->sym, chain->name);
1356 /*------------------------------------------------------------------*/
1357 /* cleanUpLevel - cleansup the symbol table specified for all the */
1358 /* symbols in the given level */
1359 /*------------------------------------------------------------------*/
1361 cleanUpLevel (bucket ** table, int level)
1366 /* go thru the entire table */
1367 for (i = 0; i < 256; i++)
1369 for (chain = table[i]; chain; chain = chain->next)
1371 if (chain->level >= level)
1373 deleteSym (table, chain->sym, chain->name);
1379 /*------------------------------------------------------------------*/
1380 /* computeType - computes the resultant type from two types */
1381 /*------------------------------------------------------------------*/
1383 computeType (sym_link * type1, sym_link * type2)
1387 sym_link *etype1 = getSpec (type1);
1388 sym_link *etype2 = getSpec (type2);
1390 /* if one of them is a float then result is a float */
1391 /* here we assume that the types passed are okay */
1392 /* and can be cast to one another */
1393 /* which ever is greater in size */
1394 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1395 rType = newFloatLink ();
1397 /* if only one of them is a bit variable
1398 then the other one prevails */
1399 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1400 rType = copyLinkChain (type2);
1401 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1402 rType = copyLinkChain (type1);
1404 /* if one of them is a pointer or array then that
1406 if (IS_PTR (type1) || IS_ARRAY (type1))
1407 rType = copyLinkChain (type1);
1408 else if (IS_PTR (type2) || IS_ARRAY (type2))
1409 rType = copyLinkChain (type2);
1410 else if (getSize (type1) > getSize (type2))
1411 rType = copyLinkChain (type1);
1413 rType = copyLinkChain (type2);
1415 reType = getSpec (rType);
1417 /* if either of them unsigned but not val then make this unsigned */
1418 if (((!IS_LITERAL(type1) && SPEC_USIGN (etype1)) ||
1419 (!IS_LITERAL(type2) && SPEC_USIGN (etype2))) &&
1421 SPEC_USIGN (reType) = 1;
1423 SPEC_USIGN (reType) = 0;
1425 /* if result is a literal then make not so */
1426 if (IS_LITERAL (reType))
1427 SPEC_SCLS (reType) = S_REGISTER;
1432 /*--------------------------------------------------------------------*/
1433 /* compareType - will do type check return 1 if match, -1 if castable */
1434 /*--------------------------------------------------------------------*/
1436 compareType (sym_link * dest, sym_link * src)
1447 /* if dest is a declarator then */
1452 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1454 //checkFunction(src,dest);
1456 return compareType (dest->next, src->next);
1458 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1461 if (IS_PTR (src) && IS_GENPTR (dest))
1463 if (IS_PTR (dest) && IS_ARRAY (src)) {
1464 value *val=aggregateToPointer (valFromType(src));
1465 int res=compareType (dest, val->type);
1466 Safe_free(val->type);
1470 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1471 return compareType (dest->next, src);
1474 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1480 /* if one is a specifier and the other is not */
1481 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1482 (IS_SPEC (dest) && !IS_SPEC (src)))
1485 /* if one of them is a void then ok */
1486 if (SPEC_NOUN (dest) == V_VOID &&
1487 SPEC_NOUN (src) != V_VOID)
1490 if (SPEC_NOUN (dest) != V_VOID &&
1491 SPEC_NOUN (src) == V_VOID)
1494 /* if they are both bitfields then if the lengths
1495 and starts don't match */
1496 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1497 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1498 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1501 /* it is a specifier */
1502 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1504 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1505 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1506 getSize (dest) == getSize (src))
1508 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1513 else if (IS_STRUCT (dest))
1515 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1520 if (SPEC_LONG (dest) != SPEC_LONG (src))
1523 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1529 /*------------------------------------------------------------------*/
1530 /* inCalleeSaveList - return 1 if found in callee save list */
1531 /*------------------------------------------------------------------*/
1533 inCalleeSaveList (char *s)
1537 if (options.all_callee_saves) return 1;
1538 for (i = 0; options.calleeSaves[i]; i++)
1539 if (strcmp (options.calleeSaves[i], s) == 0)
1545 /*-----------------------------------------------------------------*/
1546 /* aggregateToPointer: change an agggregate type function */
1547 /* argument to a pointer to that type. */
1548 /*-----------------------------------------------------------------*/
1550 aggregateToPointer (value * val)
1552 if (IS_AGGREGATE (val->type))
1554 /* if this is a structure */
1555 /* then we need to add a new link */
1556 if (IS_STRUCT (val->type))
1558 /* first lets add DECLARATOR type */
1559 sym_link *p = val->type;
1561 werror (W_STRUCT_AS_ARG, val->name);
1562 val->type = newLink (DECLARATOR);
1563 val->type->next = p;
1566 /* change to a pointer depending on the */
1567 /* storage class specified */
1568 switch (SPEC_SCLS (val->etype))
1571 DCL_TYPE (val->type) = IPOINTER;
1574 DCL_TYPE (val->type) = PPOINTER;
1577 if (SPEC_OCLS(val->etype)) {
1578 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1580 // this happens for (external) function parameters
1581 DCL_TYPE (val->type) = port->unqualified_pointer;
1587 DCL_TYPE (val->type) = POINTER;
1590 DCL_TYPE (val->type) = CPOINTER;
1593 DCL_TYPE (val->type) = FPOINTER;
1596 DCL_TYPE (val->type) = EEPPOINTER;
1599 DCL_TYPE (val->type) = port->unqualified_pointer;
1602 /* is there is a symbol associated then */
1603 /* change the type of the symbol as well */
1606 val->sym->type = copyLinkChain (val->type);
1607 val->sym->etype = getSpec (val->sym->type);
1612 /*------------------------------------------------------------------*/
1613 /* checkFunction - does all kinds of check on a function */
1614 /*------------------------------------------------------------------*/
1616 checkFunction (symbol * sym, symbol *csym)
1618 value *exargs, *acargs;
1622 if (getenv("DEBUG_SANITY")) {
1623 fprintf (stderr, "checkFunction: %s ", sym->name);
1626 /* make sure the type is complete and sane */
1627 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1629 /* if not type then some kind of error */
1633 /* if the function has no type then make it return int */
1634 if (!sym->type->next)
1635 sym->type->next = sym->etype = newIntLink ();
1637 /* function cannot return aggregate */
1638 if (IS_AGGREGATE (sym->type->next))
1640 werror (E_FUNC_AGGR, sym->name);
1644 /* function cannot return bit */
1645 if (IS_BITVAR (sym->type->next))
1647 werror (E_FUNC_BIT, sym->name);
1651 /* check if this function is defined as calleeSaves
1652 then mark it as such */
1653 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1655 /* if interrupt service routine */
1656 /* then it cannot have arguments */
1657 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1659 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1660 werror (E_INT_ARGS, sym->name);
1661 FUNC_ARGS(sym->type)=NULL;
1665 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
1667 acargs=acargs->next, argCnt++) {
1669 // this can happen for reentrant functions
1670 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1671 // the show must go on: synthesize a name and symbol
1672 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
1673 acargs->sym = newSymbol (acargs->name, 1);
1674 SPEC_OCLS (acargs->etype) = istack;
1675 acargs->sym->type = copyLinkChain (acargs->type);
1676 acargs->sym->etype = getSpec (acargs->sym->type);
1677 acargs->sym->_isparm = 1;
1678 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
1679 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
1681 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1685 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
1686 return 1; /* not defined nothing more to check */
1688 /* check if body already present */
1689 if (csym && IFFUNC_HASBODY(csym->type))
1691 werror (E_FUNC_BODY, sym->name);
1695 /* check the return value type */
1696 if (compareType (csym->type, sym->type) <= 0)
1698 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1699 printFromToType(csym->type, sym->type);
1703 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
1705 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1708 if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
1710 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1713 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
1715 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
1718 /* compare expected args with actual args */
1719 exargs = FUNC_ARGS(csym->type);
1720 acargs = FUNC_ARGS(sym->type);
1722 /* for all the expected args do */
1725 exargs = exargs->next, acargs = acargs->next, argCnt++)
1727 if (getenv("DEBUG_SANITY")) {
1728 fprintf (stderr, "checkFunction: %s ", exargs->name);
1730 /* make sure the type is complete and sane */
1731 checkTypeSanity(exargs->etype, exargs->name);
1733 /* If the actual argument is an array, any prototype
1734 * will have modified it to a pointer. Duplicate that
1737 if (IS_AGGREGATE (acargs->type))
1739 checkValue = copyValue (acargs);
1740 aggregateToPointer (checkValue);
1744 checkValue = acargs;
1747 if (compareType (exargs->type, checkValue->type) <= 0)
1749 werror (E_ARG_TYPE, argCnt);
1750 printFromToType(exargs->type, checkValue->type);
1755 /* if one them ended we have a problem */
1756 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1757 (!exargs && acargs && !IS_VOID (acargs->type)))
1758 werror (E_ARG_COUNT);
1760 /* replace with this defition */
1761 sym->cdef = csym->cdef;
1762 deleteSym (SymbolTab, csym, csym->name);
1763 deleteFromSeg(csym);
1764 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1765 if (IS_EXTERN (csym->etype) && !
1766 IS_EXTERN (sym->etype))
1768 addSet (&publics, sym);
1773 /*------------------------------------------------------------------*/
1774 /* cdbStructBlock - calls struct printing for a blcks */
1775 /*------------------------------------------------------------------*/
1776 void cdbStructBlock (int block)
1779 bucket **table = StructTab;
1782 /* go thru the entire table */
1783 for (i = 0; i < 256; i++)
1785 for (chain = table[i]; chain; chain = chain->next)
1787 if (chain->block >= block)
1790 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
1796 /*-----------------------------------------------------------------*/
1797 /* processFuncArgs - does some processing with function args */
1798 /*-----------------------------------------------------------------*/
1800 processFuncArgs (symbol * func)
1804 sym_link *funcType=func->type;
1806 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
1807 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
1809 // if this is a pointer to a function
1810 if (IS_PTR(funcType)) {
1811 funcType=funcType->next;
1814 /* if this function has variable argument list */
1815 /* then make the function a reentrant one */
1816 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
1817 FUNC_ISREENT(funcType)=1;
1819 /* check if this function is defined as calleeSaves
1820 then mark it as such */
1821 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
1823 /* loop thru all the arguments */
1824 val = FUNC_ARGS(funcType);
1826 /* if it is void then remove parameters */
1827 if (val && IS_VOID (val->type))
1829 FUNC_ARGS(funcType) = NULL;
1833 /* reset regparm for the port */
1834 (*port->reset_regparms) ();
1835 /* if any of the arguments is an aggregate */
1836 /* change it to pointer to the same type */
1840 /* mark it as a register parameter if
1841 the function does not have VA_ARG
1842 and as port dictates */
1843 if (!IFFUNC_HASVARARGS(funcType) &&
1844 (argreg = (*port->reg_parm) (val->type)))
1846 SPEC_REGPARM (val->etype) = 1;
1847 SPEC_ARGREG(val->etype) = argreg;
1848 } else if (IFFUNC_ISREENT(funcType)) {
1849 FUNC_HASSTACKPARM(funcType) = 1;
1852 if (IS_AGGREGATE (val->type))
1854 aggregateToPointer (val);
1861 /* if this is an internal generated function call */
1863 /* ignore --stack-auto for this one, we don't know how it is compiled */
1864 /* simply trust on --int-long-reent or --float-reent */
1865 if (IFFUNC_ISREENT(funcType)) {
1869 /* if this function is reentrant or */
1870 /* automatics r 2b stacked then nothing */
1871 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
1875 val = FUNC_ARGS(funcType);
1880 /* if a symbolname is not given */
1881 /* synthesize a variable name */
1884 SNPRINTF (val->name, sizeof(val->name),
1885 "_%s_PARM_%d", func->name, pNum++);
1886 val->sym = newSymbol (val->name, 1);
1887 SPEC_OCLS (val->etype) = port->mem.default_local_map;
1888 val->sym->type = copyLinkChain (val->type);
1889 val->sym->etype = getSpec (val->sym->type);
1890 val->sym->_isparm = 1;
1891 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1892 if (IS_SPEC(func->etype)) {
1893 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1894 SPEC_STAT (func->etype);
1896 addSymChain (val->sym);
1899 else /* symbol name given create synth name */
1902 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
1903 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1904 val->sym->_isparm = 1;
1905 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
1906 (options.model != MODEL_SMALL ? xdata : data);
1907 if (IS_SPEC(func->etype)) {
1908 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1909 SPEC_STAT (func->etype);
1912 if (!isinSet(operKeyReset, val->sym)) {
1913 addSet (&operKeyReset, val->sym);
1914 applyToSet (operKeyReset, resetParmKey);
1920 /*-----------------------------------------------------------------*/
1921 /* isSymbolEqual - compares two symbols return 1 if they match */
1922 /*-----------------------------------------------------------------*/
1924 isSymbolEqual (symbol * dest, symbol * src)
1926 /* if pointers match then equal */
1930 /* if one of them is null then don't match */
1934 /* if both of them have rname match on rname */
1935 if (dest->rname[0] && src->rname[0])
1936 return (!strcmp (dest->rname, src->rname));
1938 /* otherwise match on name */
1939 return (!strcmp (dest->name, src->name));
1942 void PT(sym_link *type)
1944 printTypeChain(type,0);
1946 /*-----------------------------------------------------------------*/
1947 /* printTypeChain - prints the type chain in human readable form */
1948 /*-----------------------------------------------------------------*/
1950 printTypeChain (sym_link * start, FILE * of)
1953 sym_link * type, * search;
1963 fprintf (of, "void");
1967 /* Print the chain as it is written in the source: */
1968 /* start with the last entry. */
1969 /* However, the storage class at the end of the */
1970 /* chain reall applies to the first in the chain! */
1972 for (type = start; type && type->next; type = type->next)
1974 scls=SPEC_SCLS(type);
1980 case S_DATA: fprintf (of, "data-"); break;
1981 case S_XDATA: fprintf (of, "xdata-"); break;
1982 case S_SFR: fprintf (of, "sfr-"); break;
1983 case S_SBIT: fprintf (of, "sbit-"); break;
1984 case S_CODE: fprintf (of, "code-"); break;
1985 case S_IDATA: fprintf (of, "idata-"); break;
1986 case S_PDATA: fprintf (of, "pdata-"); break;
1987 case S_LITERAL: fprintf (of, "literal-"); break;
1988 case S_STACK: fprintf (of, "stack-"); break;
1989 case S_XSTACK: fprintf (of, "xstack-"); break;
1990 case S_BIT: fprintf (of, "bit-"); break;
1991 case S_EEPROM: fprintf (of, "eeprom-"); break;
1998 if (!IS_FUNC(type)) {
1999 if (DCL_PTR_VOLATILE (type)) {
2000 fprintf (of, "volatile-");
2002 if (DCL_PTR_CONST (type)) {
2003 fprintf (of, "const-");
2006 switch (DCL_TYPE (type))
2009 fprintf (of, "function %s %s",
2010 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2011 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2014 fprintf (of, "generic* ");
2017 fprintf (of, "code* ");
2020 fprintf (of, "xdata* ");
2023 fprintf (of, "eeprom* ");
2026 fprintf (of, "near* ");
2029 fprintf (of, "idata* ");
2032 fprintf (of, "pdata* ");
2035 fprintf (of, "unkown* ");
2038 if (DCL_ELEM(type)) {
2039 fprintf (of, "[%d] ", DCL_ELEM(type));
2041 fprintf (of, "[] ");
2048 if (SPEC_VOLATILE (type))
2049 fprintf (of, "volatile-");
2050 if (SPEC_CONST (type))
2051 fprintf (of, "const-");
2052 if (SPEC_USIGN (type))
2053 fprintf (of, "unsigned-");
2054 switch (SPEC_NOUN (type))
2058 fprintf (of, "long-");
2059 fprintf (of, "int");
2063 fprintf (of, "char");
2067 fprintf (of, "void");
2071 fprintf (of, "float");
2075 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2079 fprintf (of, "sbit");
2083 fprintf (of, "bit {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2087 fprintf (of, "double");
2091 fprintf (of, "unknown type");
2095 /* search entry in list before "type" */
2096 for (search = start; search && search->next != type;)
2097 search = search->next;
2107 /*-----------------------------------------------------------------*/
2108 /* powof2 - returns power of two for the number if number is pow 2 */
2109 /*-----------------------------------------------------------------*/
2111 powof2 (unsigned long num)
2124 if (n1s > 1 || nshifts == 0)
2140 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2141 symbol *__muldiv[3][3][2];
2142 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2143 sym_link *__multypes[3][2];
2144 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2145 symbol *__conv[2][3][2];
2146 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2147 symbol *__rlrr[2][3][2];
2149 sym_link *floatType;
2152 _mangleFunctionName(char *in)
2154 if (port->getMangledFunctionName)
2156 return port->getMangledFunctionName(in);
2164 /*-----------------------------------------------------------------*/
2165 /* typeFromStr - create a typechain from an encoded string */
2166 /* basic types - 'c' - char */
2172 /* '*' - pointer - default (GPOINTER) */
2173 /* modifiers - 'u' - unsigned */
2174 /* pointer modifiers - 'g' - generic */
2178 /* 'F' - function */
2179 /* examples : "ig*" - generic int * */
2180 /* "cx*" - char xdata * */
2181 /* "ui" - unsigned int */
2182 /*-----------------------------------------------------------------*/
2183 sym_link *typeFromStr (char *s)
2185 sym_link *r = newLink(DECLARATOR);
2197 r->class = SPECIFIER;
2198 SPEC_NOUN(r) = V_CHAR;
2202 r->class = SPECIFIER;
2203 SPEC_NOUN(r) = V_INT;
2206 r->class = SPECIFIER;
2207 SPEC_NOUN(r) = V_INT;
2211 r->class = SPECIFIER;
2212 SPEC_NOUN(r) = V_FLOAT;
2215 r->class = SPECIFIER;
2216 SPEC_NOUN(r) = V_VOID;
2219 DCL_TYPE(r) = port->unqualified_pointer;
2226 assert(*(s+1)=='*');
2227 nr = newLink(DECLARATOR);
2232 DCL_TYPE(r) = GPOINTER;
2235 DCL_TYPE(r) = FPOINTER;
2238 DCL_TYPE(r) = CPOINTER;
2241 DCL_TYPE(r) = POINTER;
2244 DCL_TYPE(r) = FUNCTION;
2245 nr = newLink(DECLARATOR);
2248 DCL_TYPE(r) = CPOINTER;
2254 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
2255 "typeFromStr: unknown type");
2258 if (IS_SPEC(r) && usign) {
2267 /*-----------------------------------------------------------------*/
2268 /* initCSupport - create functions for C support routines */
2269 /*-----------------------------------------------------------------*/
2273 const char *smuldivmod[] =
2277 const char *sbwd[] =
2279 "char", "int", "long"
2285 const char *srlrr[] =
2290 int bwd, su, muldivmod, tofrom, rlrr;
2292 if (getenv("SDCC_NO_C_SUPPORT")) {
2293 /* for debugging only */
2297 floatType = newFloatLink ();
2299 for (bwd = 0; bwd < 3; bwd++)
2316 __multypes[bwd][0] = l;
2317 __multypes[bwd][1] = copyLinkChain (l);
2318 SPEC_USIGN (__multypes[bwd][1]) = 1;
2321 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2322 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2323 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2324 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2325 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2326 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2327 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2328 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2329 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2330 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2332 for (tofrom = 0; tofrom < 2; tofrom++)
2334 for (bwd = 0; bwd < 3; bwd++)
2336 for (su = 0; su < 2; su++)
2340 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
2341 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2345 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
2346 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2352 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2354 for (bwd = 0; bwd < 3; bwd++)
2356 for (su = 0; su < 2; su++)
2358 SNPRINTF (buffer, sizeof(buffer),
2360 smuldivmod[muldivmod],
2363 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2364 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2369 for (rlrr = 0; rlrr < 2; rlrr++)
2371 for (bwd = 0; bwd < 3; bwd++)
2373 for (su = 0; su < 2; su++)
2375 SNPRINTF (buffer, sizeof(buffer),
2380 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2381 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
2387 /*-----------------------------------------------------------------*/
2388 /* initBuiltIns - create prototypes for builtin functions */
2389 /*-----------------------------------------------------------------*/
2395 if (!port->builtintable) return ;
2397 for (i = 0 ; port->builtintable[i].name ; i++) {
2398 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
2399 port->builtintable[i].nParms,port->builtintable[i].parm_types);
2400 FUNC_ISBUILTIN(sym->type) = 1;
2401 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
2405 sym_link *validateLink(sym_link *l,
2412 if (l && l->class==select)
2417 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
2418 " expected %s, got %s\n",
2419 macro, args, file, line,
2420 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
2422 return l; // never reached, makes compiler happy.