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 switch (SPEC_SCLS (type))
354 DCL_TYPE (ptr) = FPOINTER;
357 DCL_TYPE (ptr) = IPOINTER;
360 DCL_TYPE (ptr) = PPOINTER;
363 DCL_TYPE (ptr) = POINTER;
366 DCL_TYPE (ptr) = CPOINTER;
369 DCL_TYPE (ptr) = EEPPOINTER;
372 DCL_TYPE (ptr) = port->unqualified_pointer;
375 /* the storage class of type ends here */
378 SPEC_VOLATILE (type) = 0;
381 /* now change all the remaining unknown pointers
382 to generic pointers */
385 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
386 DCL_TYPE (ptr) = port->unqualified_pointer;
390 /* same for the type although it is highly unlikely that
391 type will have a pointer */
394 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
395 DCL_TYPE (type) = port->unqualified_pointer;
401 /*------------------------------------------------------------------*/
402 /* addDecl - adds a declarator @ the end of a chain */
403 /*------------------------------------------------------------------*/
405 addDecl (symbol * sym, int type, sym_link * p)
411 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
412 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
414 /* if we are passed a link then set head & tail */
423 head = tail = newLink (DECLARATOR);
424 DCL_TYPE (head) = type;
427 /* if this is the first entry */
435 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
437 sym->etype = mergeSpec (sym->etype, head, sym->name);
441 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
444 while (t->next != sym->etype)
447 tail->next = sym->etype;
451 sym->etype->next = head;
457 /* if the type is an unknown pointer and has
458 a tspec then take the const & volatile
459 attribute from the tspec & make it those of this
464 DCL_TYPE (p) == UPOINTER &&
467 // only for declarators
468 wassert (IS_DECL(sym->type));
470 if (!IS_SPEC (sym->etype))
472 sym->etype = sym->etype->next = newLink (SPECIFIER);
475 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
476 DCL_PTR_CONST (sym->type) = SPEC_CONST (DCL_TSPEC (p));
477 DCL_PTR_VOLATILE (sym->type) = SPEC_VOLATILE (DCL_TSPEC (p));
478 DCL_TSPEC (p) = NULL;
481 // if there is a function in this type chain
482 if (p && funcInChain(sym->type)) {
483 processFuncArgs (sym);
489 /*------------------------------------------------------------------
490 checkTypeSanity: prevent the user from doing e.g.:
492 ------------------------------------------------------------------*/
493 void checkTypeSanity(sym_link *etype, char *name) {
497 if (getenv("DEBUG_SANITY")) {
498 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
503 if (!IS_SPEC(etype)) {
504 if (getenv("DEBUG_SANITY")) {
505 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
510 noun=nounName(etype);
512 if (getenv("DEBUG_SANITY")) {
513 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
516 if ((SPEC_NOUN(etype)==V_CHAR ||
517 SPEC_NOUN(etype)==V_FLOAT ||
518 SPEC_NOUN(etype)==V_DOUBLE ||
519 SPEC_NOUN(etype)==V_VOID) &&
520 (etype->select.s._short || SPEC_LONG(etype))) {
521 // long or short for char float double or void
522 werror (E_LONG_OR_SHORT_INVALID, noun, name);
524 if ((SPEC_NOUN(etype)==V_FLOAT ||
525 SPEC_NOUN(etype)==V_DOUBLE ||
526 SPEC_NOUN(etype)==V_VOID) &&
527 (etype->select.s._signed || SPEC_USIGN(etype))) {
528 // signed or unsigned for float double or void
529 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
532 // special case for "short"
533 if (etype->select.s._short) {
534 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
535 etype->select.s._short = 0;
539 "const a;" or "data b;" or "signed s" or "long l"
541 if (!SPEC_NOUN(etype)) {
542 SPEC_NOUN(etype)=V_INT;
545 if (etype->select.s._signed && SPEC_USIGN(etype)) {
546 // signed AND unsigned
547 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
549 if (etype->select.s._short && SPEC_LONG(etype)) {
551 werror (E_LONG_AND_SHORT_INVALID, noun, name);
556 /*------------------------------------------------------------------*/
557 /* mergeSpec - merges two specifiers and returns the new one */
558 /*------------------------------------------------------------------*/
560 mergeSpec (sym_link * dest, sym_link * src, char *name)
562 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
563 werror (E_SYNTAX_ERROR, yytext);
566 if (SPEC_NOUN(src)) {
567 if (!SPEC_NOUN(dest)) {
568 SPEC_NOUN(dest)=SPEC_NOUN(src);
570 /* we shouldn't redeclare the type */
571 if (getenv("DEBUG_SANITY")) {
572 fprintf (stderr, "mergeSpec: ");
574 werror(E_TWO_OR_MORE_DATA_TYPES, name);
578 if (SPEC_SCLS(src)) {
579 /* if destination has no storage class */
580 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
581 SPEC_SCLS (dest) = SPEC_SCLS (src);
583 if (getenv("DEBUG_SANITY")) {
584 fprintf (stderr, "mergeSpec: ");
586 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
590 /* copy all the specifications */
592 SPEC_LONG (dest) |= SPEC_LONG (src);
593 dest->select.s._short|=src->select.s._short;
594 SPEC_USIGN (dest) |= SPEC_USIGN (src);
595 dest->select.s._signed|=src->select.s._signed;
596 SPEC_STAT (dest) |= SPEC_STAT (src);
597 SPEC_EXTR (dest) |= SPEC_EXTR (src);
598 SPEC_CONST(dest) |= SPEC_CONST (src);
599 SPEC_ABSA (dest) |= SPEC_ABSA (src);
600 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
601 SPEC_ADDR (dest) |= SPEC_ADDR (src);
602 SPEC_OCLS (dest) = SPEC_OCLS (src);
603 SPEC_BLEN (dest) |= SPEC_BLEN (src);
604 SPEC_BSTR (dest) |= SPEC_BSTR (src);
605 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
606 SPEC_ENUM (dest) |= SPEC_ENUM (src);
607 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
608 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
610 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
611 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
613 /* these are the only function attributes that will be set
614 in a specifier while parsing */
615 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
616 FUNC_BANKED(dest) |= FUNC_BANKED(src);
617 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
618 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
619 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
620 FUNC_ISISR(dest) |= FUNC_ISISR(src);
621 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
622 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
623 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
624 FUNC_INTNO(dest) |= FUNC_INTNO(src);
625 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
630 /*------------------------------------------------------------------*/
631 /* genSymName - generates and returns a name used for anonymous vars */
632 /*------------------------------------------------------------------*/
634 genSymName (int level)
636 static int gCount = 0;
637 static char gname[SDCC_NAME_MAX + 1];
639 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
643 /*------------------------------------------------------------------*/
644 /* getSpec - returns the specifier part from a declaration chain */
645 /*------------------------------------------------------------------*/
647 getSpec (sym_link * p)
652 while (p && !(IS_SPEC (p)))
658 /*------------------------------------------------------------------*/
659 /* newCharLink() - creates an char type */
660 /*------------------------------------------------------------------*/
666 p = newLink (SPECIFIER);
667 SPEC_NOUN (p) = V_CHAR;
672 /*------------------------------------------------------------------*/
673 /* newFloatLink - a new Float type */
674 /*------------------------------------------------------------------*/
680 p = newLink (SPECIFIER);
681 SPEC_NOUN (p) = V_FLOAT;
686 /*------------------------------------------------------------------*/
687 /* newLongLink() - new long type */
688 /*------------------------------------------------------------------*/
694 p = newLink (SPECIFIER);
695 SPEC_NOUN (p) = V_INT;
701 /*------------------------------------------------------------------*/
702 /* newIntLink() - creates an int type */
703 /*------------------------------------------------------------------*/
709 p = newLink (SPECIFIER);
710 SPEC_NOUN (p) = V_INT;
715 /*------------------------------------------------------------------*/
716 /* getSize - returns size of a type chain in bits */
717 /*------------------------------------------------------------------*/
719 getSize (sym_link * p)
721 /* if nothing return 0 */
725 { /* if this is the specifier then */
726 switch (SPEC_NOUN (p))
727 { /* depending on the specifier type */
729 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
737 return SPEC_STRUCT (p)->size;
743 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
749 /* this is a specifier */
750 switch (DCL_TYPE (p))
754 return DCL_ELEM (p) * getSize (p->next);
756 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
757 // "can not tell the size of an array[]");
777 /*------------------------------------------------------------------*/
778 /* bitsForType - returns # of bits required to store this type */
779 /*------------------------------------------------------------------*/
781 bitsForType (sym_link * p)
783 /* if nothing return 0 */
788 { /* if this is the specifier then */
790 switch (SPEC_NOUN (p))
791 { /* depending on the specifier type */
793 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
795 return FLOATSIZE * 8;
801 return SPEC_STRUCT (p)->size * 8;
807 return SPEC_BLEN (p);
813 /* this is a specifier */
814 switch (DCL_TYPE (p))
817 return DCL_ELEM (p) * getSize (p->next) * 8;
821 return (PTRSIZE * 8);
826 return (FPTRSIZE * 8);
828 return (GPTRSIZE * 8);
835 /*------------------------------------------------------------------*/
836 /* copySymbolChain - copies a symbol chain */
837 /*------------------------------------------------------------------*/
839 copySymbolChain (symbol * src)
846 dest = copySymbol (src);
847 dest->next = copySymbolChain (src->next);
851 /*------------------------------------------------------------------*/
852 /* copySymbol - makes a copy of a symbol */
853 /*------------------------------------------------------------------*/
855 copySymbol (symbol * src)
862 dest = newSymbol (src->name, src->level);
863 memcpy (dest, src, sizeof (symbol));
864 dest->level = src->level;
865 dest->block = src->block;
866 dest->ival = copyIlist (src->ival);
867 dest->type = copyLinkChain (src->type);
868 dest->etype = getSpec (dest->type);
870 dest->key = src->key;
871 dest->allocreq = src->allocreq;
875 /*------------------------------------------------------------------*/
876 /* reverseSyms - reverses the links for a symbol chain */
877 /*------------------------------------------------------------------*/
879 reverseSyms (symbol * sym)
881 symbol *prev, *curr, *next;
896 sym->next = (void *) NULL;
900 /*------------------------------------------------------------------*/
901 /* reverseLink - reverses the links for a type chain */
902 /*------------------------------------------------------------------*/
904 reverseLink (sym_link * type)
906 sym_link *prev, *curr, *next;
921 type->next = (void *) NULL;
925 /*------------------------------------------------------------------*/
926 /* addSymChain - adds a symbol chain to the symboltable */
927 /*------------------------------------------------------------------*/
929 addSymChain (symbol * symHead)
931 symbol *sym = symHead;
934 for (; sym != NULL; sym = sym->next)
937 checkTypeSanity(sym->etype, sym->name);
939 /* if already exists in the symbol table then check if
940 one of them is an extern definition if yes then
941 then check if the type match, if the types match then
942 delete the current entry and add the new entry */
943 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
944 csym->level == sym->level) {
946 /* one definition extern ? */
947 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) {
948 /* do types match ? */
949 if (compareType (csym->type, sym->type) != 1) {
951 werror (E_EXTERN_MISMATCH, csym->name);
956 if (compareType (csym->type, sym->type) != 1) {
957 werror (E_DUPLICATE, sym->name);
961 /* delete current entry */
962 deleteSym (SymbolTab, csym, csym->name);
967 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
972 /*------------------------------------------------------------------*/
973 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
974 /*------------------------------------------------------------------*/
976 funcInChain (sym_link * lnk)
987 /*------------------------------------------------------------------*/
988 /* structElemType - returns the type info of a sturct member */
989 /*------------------------------------------------------------------*/
991 structElemType (sym_link * stype, value * id)
993 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
994 sym_link *type, *etype;
995 sym_link *petype = getSpec (stype);
999 /* look for the id */
1002 if (strcmp (fields->rname, id->name) == 0)
1004 type = copyLinkChain (fields->type);
1005 etype = getSpec (type);
1006 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1007 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1010 fields = fields->next;
1014 werror (E_NOT_MEMBER, id->name);
1016 // the show must go on
1017 return newIntLink();
1020 /*------------------------------------------------------------------*/
1021 /* getStructElement - returns element of a tructure definition */
1022 /*------------------------------------------------------------------*/
1024 getStructElement (structdef * sdef, symbol * sym)
1028 for (field = sdef->fields; field; field = field->next)
1029 if (strcmp (field->name, sym->name) == 0)
1032 werror (E_NOT_MEMBER, sym->name);
1034 return sdef->fields;
1037 /*------------------------------------------------------------------*/
1038 /* compStructSize - computes the size of a structure */
1039 /*------------------------------------------------------------------*/
1041 compStructSize (int su, structdef * sdef)
1043 int sum = 0, usum = 0;
1047 /* for the identifiers */
1048 loop = sdef->fields;
1051 /* create the internal name for this variable */
1052 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1053 loop->offset = (su == UNION ? sum = 0 : sum);
1054 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1056 /* if this is a bit field */
1059 /* change it to a unsigned bit */
1060 SPEC_NOUN (loop->etype) = V_BIT;
1061 SPEC_USIGN (loop->etype) = 1;
1062 /* check if this fit into the remaining */
1063 /* bits of this byte else align it to the */
1064 /* next byte boundary */
1065 if ((SPEC_BLEN (loop->etype) = loop->bitVar) <= (8 - bitOffset)) {
1066 SPEC_BSTR (loop->etype) = bitOffset;
1067 if ((bitOffset += (loop->bitVar % 8)) == 8)
1070 else /* does not fit */ {
1072 SPEC_BSTR (loop->etype) = bitOffset;
1073 sum += (loop->bitVar / 8);
1074 bitOffset += (loop->bitVar % 8);
1076 /* if this is the last field then pad */
1077 if (!loop->next && bitOffset && bitOffset != 8) {
1083 checkDecl (loop, 1);
1084 sum += getSize (loop->type);
1089 /* if this is not a bitfield but the */
1090 /* previous one was and did not take */
1091 /* the whole byte then pad the rest */
1092 if ((loop && !loop->bitVar) && bitOffset) {
1097 /* if union then size = sizeof larget field */
1099 usum = max (usum, sum);
1103 return (su == UNION ? usum : sum);
1106 /*------------------------------------------------------------------*/
1107 /* checkSClass - check the storage class specification */
1108 /*------------------------------------------------------------------*/
1110 checkSClass (symbol * sym, int isProto)
1112 if (getenv("DEBUG_SANITY")) {
1113 fprintf (stderr, "checkSClass: %s \n", sym->name);
1116 /* type is literal can happen foe enums change
1118 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1119 SPEC_SCLS (sym->etype) = S_AUTO;
1121 /* if sfr or sbit then must also be */
1122 /* volatile the initial value will be xlated */
1123 /* to an absolute address */
1124 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1125 SPEC_SCLS (sym->etype) == S_SFR)
1127 SPEC_VOLATILE (sym->etype) = 1;
1128 /* if initial value given */
1131 SPEC_ABSA (sym->etype) = 1;
1132 SPEC_ADDR (sym->etype) =
1133 (int) list2int (sym->ival);
1138 /* if absolute address given then it mark it as
1139 volatile -- except in the PIC port */
1141 #if !OPT_DISABLE_PIC
1142 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1146 if (IS_ABSOLUTE (sym->etype))
1147 SPEC_VOLATILE (sym->etype) = 1;
1150 /* global variables declared const put into code */
1151 /* if no other storage class specified */
1152 if (sym->level == 0 &&
1153 SPEC_CONST (sym->etype) &&
1154 SPEC_SCLS(sym->etype) == S_FIXED &&
1155 !IS_FUNC(sym->type)) {
1156 SPEC_SCLS (sym->etype) = S_CODE;
1159 /* global variable in code space is a constant */
1160 if (sym->level == 0 &&
1161 SPEC_SCLS (sym->etype) == S_CODE &&
1162 port->mem.code_ro) {
1163 if (IS_SPEC(sym->type)) {
1164 SPEC_CONST (sym->type) = 1;
1166 DCL_PTR_CONST (sym->type) = 1;
1170 /* if bit variable then no storage class can be */
1171 /* specified since bit is already a storage */
1172 if (IS_BITVAR (sym->etype) &&
1173 (SPEC_SCLS (sym->etype) != S_FIXED &&
1174 SPEC_SCLS (sym->etype) != S_SBIT &&
1175 SPEC_SCLS (sym->etype) != S_BIT)
1178 werror (E_BITVAR_STORAGE, sym->name);
1179 SPEC_SCLS (sym->etype) = S_FIXED;
1182 /* extern variables cannot be initialized */
1183 if (IS_EXTERN (sym->etype) && sym->ival)
1185 werror (E_EXTERN_INIT, sym->name);
1189 /* if this is an atomatic symbol */
1190 if (sym->level && (options.stackAuto || reentrant)) {
1191 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1192 SPEC_SCLS (sym->etype) == S_FIXED ||
1193 SPEC_SCLS (sym->etype) == S_REGISTER ||
1194 SPEC_SCLS (sym->etype) == S_STACK ||
1195 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1196 SPEC_SCLS (sym->etype) = S_AUTO;
1198 /* storage class may only be specified for statics */
1199 if (!IS_STATIC(sym->etype)) {
1200 werror (E_AUTO_ASSUMED, sym->name);
1205 /* automatic symbols cannot be given */
1206 /* an absolute address ignore it */
1208 SPEC_ABSA (sym->etype) &&
1209 (options.stackAuto || reentrant))
1211 werror (E_AUTO_ABSA, sym->name);
1212 SPEC_ABSA (sym->etype) = 0;
1215 /* arrays & pointers cannot be defined for bits */
1216 /* SBITS or SFRs or BIT */
1217 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1218 (SPEC_NOUN (sym->etype) == V_BIT ||
1219 SPEC_NOUN (sym->etype) == V_SBIT ||
1220 SPEC_SCLS (sym->etype) == S_SFR))
1221 werror (E_BIT_ARRAY, sym->name);
1223 /* if this is a bit|sbit then set length & start */
1224 if (SPEC_NOUN (sym->etype) == V_BIT ||
1225 SPEC_NOUN (sym->etype) == V_SBIT)
1227 SPEC_BLEN (sym->etype) = 1;
1228 SPEC_BSTR (sym->etype) = 0;
1232 /* variables declared in CODE space must have */
1233 /* initializers if not an extern */
1234 if (SPEC_SCLS (sym->etype) == S_CODE &&
1235 sym->ival == NULL &&
1237 port->mem.code_ro &&
1238 !IS_EXTERN (sym->etype) &&
1239 !funcInChain (sym->type))
1240 werror (E_CODE_NO_INIT, sym->name);
1243 /* if parameter or local variable then change */
1244 /* the storage class to reflect where the var will go */
1245 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1246 !IS_STATIC(sym->etype))
1248 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1250 SPEC_SCLS (sym->etype) = (options.useXstack ?
1251 S_XSTACK : S_STACK);
1255 /* hack-o-matic! I see no reason why the useXstack option should ever
1256 * control this allcoation, but the code was originally that way, and
1257 * changing it for non-390 ports breaks the compiler badly.
1259 bool useXdata = TARGET_IS_DS390 ? 1 : options.useXstack;
1260 SPEC_SCLS (sym->etype) = (useXdata ?
1266 /*------------------------------------------------------------------*/
1267 /* changePointer - change pointer to functions */
1268 /*------------------------------------------------------------------*/
1270 changePointer (symbol * sym)
1274 /* go thru the chain of declarations */
1275 /* if we find a pointer to a function */
1276 /* unconditionally change it to a ptr */
1278 for (p = sym->type; p; p = p->next)
1280 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1281 DCL_TYPE (p) = port->unqualified_pointer;
1282 if (IS_PTR (p) && IS_FUNC (p->next))
1283 DCL_TYPE (p) = CPOINTER;
1287 /*------------------------------------------------------------------*/
1288 /* checkDecl - does semantic validation of a declaration */
1289 /*------------------------------------------------------------------*/
1291 checkDecl (symbol * sym, int isProto)
1294 checkSClass (sym, isProto); /* check the storage class */
1295 changePointer (sym); /* change pointers if required */
1297 /* if this is an array without any dimension
1298 then update the dimension from the initial value */
1299 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1300 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1305 /*------------------------------------------------------------------*/
1306 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1307 /*------------------------------------------------------------------*/
1309 copyLinkChain (sym_link * p)
1311 sym_link *head, *curr, *loop;
1314 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1317 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1318 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1327 /*------------------------------------------------------------------*/
1328 /* cleanUpBlock - cleansup the symbol table specified for all the */
1329 /* symbols in the given block */
1330 /*------------------------------------------------------------------*/
1332 cleanUpBlock (bucket ** table, int block)
1337 /* go thru the entire table */
1338 for (i = 0; i < 256; i++)
1340 for (chain = table[i]; chain; chain = chain->next)
1342 if (chain->block >= block)
1344 deleteSym (table, chain->sym, chain->name);
1350 /*------------------------------------------------------------------*/
1351 /* cleanUpLevel - cleansup the symbol table specified for all the */
1352 /* symbols in the given level */
1353 /*------------------------------------------------------------------*/
1355 cleanUpLevel (bucket ** table, int level)
1360 /* go thru the entire table */
1361 for (i = 0; i < 256; i++)
1363 for (chain = table[i]; chain; chain = chain->next)
1365 if (chain->level >= level)
1367 deleteSym (table, chain->sym, chain->name);
1373 /*------------------------------------------------------------------*/
1374 /* computeType - computes the resultant type from two types */
1375 /*------------------------------------------------------------------*/
1377 computeType (sym_link * type1, sym_link * type2)
1381 sym_link *etype1 = getSpec (type1);
1382 sym_link *etype2 = getSpec (type2);
1384 /* if one of them is a float then result is a float */
1385 /* here we assume that the types passed are okay */
1386 /* and can be cast to one another */
1387 /* which ever is greater in size */
1388 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1389 rType = newFloatLink ();
1391 /* if only one of them is a bit variable
1392 then the other one prevails */
1393 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1394 rType = copyLinkChain (type2);
1395 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1396 rType = copyLinkChain (type1);
1398 /* if one of them is a pointer or array then that
1400 if (IS_PTR (type1) || IS_ARRAY (type1))
1401 rType = copyLinkChain (type1);
1402 else if (IS_PTR (type2) || IS_ARRAY (type2))
1403 rType = copyLinkChain (type2);
1404 else if (getSize (type1) > getSize (type2))
1405 rType = copyLinkChain (type1);
1407 rType = copyLinkChain (type2);
1409 reType = getSpec (rType);
1411 /* if either of them unsigned but not val then make this unsigned */
1412 if (((!IS_LITERAL(type1) && SPEC_USIGN (etype1)) ||
1413 (!IS_LITERAL(type2) && SPEC_USIGN (etype2))) &&
1415 SPEC_USIGN (reType) = 1;
1417 SPEC_USIGN (reType) = 0;
1419 /* if result is a literal then make not so */
1420 if (IS_LITERAL (reType))
1421 SPEC_SCLS (reType) = S_REGISTER;
1426 /*--------------------------------------------------------------------*/
1427 /* compareType - will do type check return 1 if match, -1 if castable */
1428 /*--------------------------------------------------------------------*/
1430 compareType (sym_link * dest, sym_link * src)
1441 /* if dest is a declarator then */
1446 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1448 //checkFunction(src,dest);
1450 return compareType (dest->next, src->next);
1452 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1455 if (IS_PTR (src) && IS_GENPTR (dest))
1457 if (IS_PTR (dest) && IS_ARRAY (src)) {
1458 value *val=aggregateToPointer (valFromType(src));
1459 int res=compareType (dest, val->type);
1460 Safe_free(val->type);
1464 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1465 return compareType (dest->next, src);
1468 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1474 /* if one is a specifier and the other is not */
1475 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1476 (IS_SPEC (dest) && !IS_SPEC (src)))
1479 /* if one of them is a void then ok */
1480 if (SPEC_NOUN (dest) == V_VOID &&
1481 SPEC_NOUN (src) != V_VOID)
1484 if (SPEC_NOUN (dest) != V_VOID &&
1485 SPEC_NOUN (src) == V_VOID)
1488 /* if they are both bitfields then if the lengths
1489 and starts don't match */
1490 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1491 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1492 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1495 /* it is a specifier */
1496 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1498 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1499 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1500 getSize (dest) == getSize (src))
1502 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1507 else if (IS_STRUCT (dest))
1509 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1514 if (SPEC_LONG (dest) != SPEC_LONG (src))
1517 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1523 /*------------------------------------------------------------------*/
1524 /* inCalleeSaveList - return 1 if found in callee save list */
1525 /*------------------------------------------------------------------*/
1527 inCalleeSaveList (char *s)
1531 if (options.all_callee_saves) return 1;
1532 for (i = 0; options.calleeSaves[i]; i++)
1533 if (strcmp (options.calleeSaves[i], s) == 0)
1539 /*-----------------------------------------------------------------*/
1540 /* aggregateToPointer: change an agggregate type function */
1541 /* argument to a pointer to that type. */
1542 /*-----------------------------------------------------------------*/
1544 aggregateToPointer (value * val)
1546 if (IS_AGGREGATE (val->type))
1548 /* if this is a structure */
1549 /* then we need to add a new link */
1550 if (IS_STRUCT (val->type))
1552 /* first lets add DECLARATOR type */
1553 sym_link *p = val->type;
1555 werror (W_STRUCT_AS_ARG, val->name);
1556 val->type = newLink (DECLARATOR);
1557 val->type->next = p;
1560 /* change to a pointer depending on the */
1561 /* storage class specified */
1562 switch (SPEC_SCLS (val->etype))
1565 DCL_TYPE (val->type) = IPOINTER;
1568 DCL_TYPE (val->type) = PPOINTER;
1571 if (SPEC_OCLS(val->etype)) {
1572 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1574 // this happens for (external) function parameters
1575 DCL_TYPE (val->type) = port->unqualified_pointer;
1581 DCL_TYPE (val->type) = POINTER;
1584 DCL_TYPE (val->type) = CPOINTER;
1587 DCL_TYPE (val->type) = FPOINTER;
1590 DCL_TYPE (val->type) = EEPPOINTER;
1593 DCL_TYPE (val->type) = port->unqualified_pointer;
1596 /* is there is a symbol associated then */
1597 /* change the type of the symbol as well */
1600 val->sym->type = copyLinkChain (val->type);
1601 val->sym->etype = getSpec (val->sym->type);
1606 /*------------------------------------------------------------------*/
1607 /* checkFunction - does all kinds of check on a function */
1608 /*------------------------------------------------------------------*/
1610 checkFunction (symbol * sym, symbol *csym)
1612 value *exargs, *acargs;
1616 if (getenv("DEBUG_SANITY")) {
1617 fprintf (stderr, "checkFunction: %s ", sym->name);
1620 /* make sure the type is complete and sane */
1621 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1623 /* if not type then some kind of error */
1627 /* if the function has no type then make it return int */
1628 if (!sym->type->next)
1629 sym->type->next = sym->etype = newIntLink ();
1631 /* function cannot return aggregate */
1632 if (IS_AGGREGATE (sym->type->next))
1634 werror (E_FUNC_AGGR, sym->name);
1638 /* function cannot return bit */
1639 if (IS_BITVAR (sym->type->next))
1641 werror (E_FUNC_BIT, sym->name);
1645 /* check if this function is defined as calleeSaves
1646 then mark it as such */
1647 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1649 /* if interrupt service routine */
1650 /* then it cannot have arguments */
1651 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1653 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1654 werror (E_INT_ARGS, sym->name);
1655 FUNC_ARGS(sym->type)=NULL;
1659 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
1661 acargs=acargs->next, argCnt++) {
1663 // this can happen for reentrant functions
1664 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1665 // the show must go on: synthesize a name and symbol
1666 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
1667 acargs->sym = newSymbol (acargs->name, 1);
1668 SPEC_OCLS (acargs->etype) = istack;
1669 acargs->sym->type = copyLinkChain (acargs->type);
1670 acargs->sym->etype = getSpec (acargs->sym->type);
1671 acargs->sym->_isparm = 1;
1672 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
1673 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
1675 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1679 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
1680 return 1; /* not defined nothing more to check */
1682 /* check if body already present */
1683 if (csym && IFFUNC_HASBODY(csym->type))
1685 werror (E_FUNC_BODY, sym->name);
1689 /* check the return value type */
1690 if (compareType (csym->type, sym->type) <= 0)
1692 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1693 printFromToType(csym->type, sym->type);
1697 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
1699 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1702 if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
1704 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1707 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
1709 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
1712 /* compare expected args with actual args */
1713 exargs = FUNC_ARGS(csym->type);
1714 acargs = FUNC_ARGS(sym->type);
1716 /* for all the expected args do */
1719 exargs = exargs->next, acargs = acargs->next, argCnt++)
1721 if (getenv("DEBUG_SANITY")) {
1722 fprintf (stderr, "checkFunction: %s ", exargs->name);
1724 /* make sure the type is complete and sane */
1725 checkTypeSanity(exargs->etype, exargs->name);
1727 /* If the actual argument is an array, any prototype
1728 * will have modified it to a pointer. Duplicate that
1731 if (IS_AGGREGATE (acargs->type))
1733 checkValue = copyValue (acargs);
1734 aggregateToPointer (checkValue);
1738 checkValue = acargs;
1741 if (compareType (exargs->type, checkValue->type) <= 0)
1743 werror (E_ARG_TYPE, argCnt);
1744 printFromToType(exargs->type, checkValue->type);
1749 /* if one them ended we have a problem */
1750 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1751 (!exargs && acargs && !IS_VOID (acargs->type)))
1752 werror (E_ARG_COUNT);
1754 /* replace with this defition */
1755 sym->cdef = csym->cdef;
1756 deleteSym (SymbolTab, csym, csym->name);
1757 deleteFromSeg(csym);
1758 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1759 if (IS_EXTERN (csym->etype) && !
1760 IS_EXTERN (sym->etype))
1762 addSet (&publics, sym);
1767 /*-----------------------------------------------------------------*/
1768 /* processFuncArgs - does some processing with function args */
1769 /*-----------------------------------------------------------------*/
1771 processFuncArgs (symbol * func)
1775 sym_link *funcType=func->type;
1777 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
1778 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
1780 // if this is a pointer to a function
1781 if (IS_PTR(funcType)) {
1782 funcType=funcType->next;
1785 /* if this function has variable argument list */
1786 /* then make the function a reentrant one */
1787 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
1788 FUNC_ISREENT(funcType)=1;
1790 /* check if this function is defined as calleeSaves
1791 then mark it as such */
1792 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
1794 /* loop thru all the arguments */
1795 val = FUNC_ARGS(funcType);
1797 /* if it is void then remove parameters */
1798 if (val && IS_VOID (val->type))
1800 FUNC_ARGS(funcType) = NULL;
1804 /* reset regparm for the port */
1805 (*port->reset_regparms) ();
1806 /* if any of the arguments is an aggregate */
1807 /* change it to pointer to the same type */
1811 /* mark it as a register parameter if
1812 the function does not have VA_ARG
1813 and as port dictates */
1814 if (!IFFUNC_HASVARARGS(funcType) &&
1815 (argreg = (*port->reg_parm) (val->type)))
1817 SPEC_REGPARM (val->etype) = 1;
1818 SPEC_ARGREG(val->etype) = argreg;
1819 } else if (IFFUNC_ISREENT(funcType)) {
1820 FUNC_HASSTACKPARM(funcType) = 1;
1823 if (IS_AGGREGATE (val->type))
1825 aggregateToPointer (val);
1832 /* if this is an internal generated function call */
1834 /* ignore --stack-auto for this one, we don't know how it is compiled */
1835 /* simply trust on --int-long-reent or --float-reent */
1836 if (IFFUNC_ISREENT(funcType)) {
1840 /* if this function is reentrant or */
1841 /* automatics r 2b stacked then nothing */
1842 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
1846 val = FUNC_ARGS(funcType);
1851 /* if a symbolname is not given */
1852 /* synthesize a variable name */
1855 SNPRINTF (val->name, sizeof(val->name),
1856 "_%s_PARM_%d", func->name, pNum++);
1857 val->sym = newSymbol (val->name, 1);
1858 SPEC_OCLS (val->etype) = port->mem.default_local_map;
1859 val->sym->type = copyLinkChain (val->type);
1860 val->sym->etype = getSpec (val->sym->type);
1861 val->sym->_isparm = 1;
1862 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1863 if (IS_SPEC(func->etype)) {
1864 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1865 SPEC_STAT (func->etype);
1867 addSymChain (val->sym);
1870 else /* symbol name given create synth name */
1873 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
1874 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1875 val->sym->_isparm = 1;
1876 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
1877 (options.model != MODEL_SMALL ? xdata : data);
1878 if (IS_SPEC(func->etype)) {
1879 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1880 SPEC_STAT (func->etype);
1883 if (!isinSet(operKeyReset, val->sym)) {
1884 addSet (&operKeyReset, val->sym);
1885 applyToSet (operKeyReset, resetParmKey);
1891 /*-----------------------------------------------------------------*/
1892 /* isSymbolEqual - compares two symbols return 1 if they match */
1893 /*-----------------------------------------------------------------*/
1895 isSymbolEqual (symbol * dest, symbol * src)
1897 /* if pointers match then equal */
1901 /* if one of them is null then don't match */
1905 /* if both of them have rname match on rname */
1906 if (dest->rname[0] && src->rname[0])
1907 return (!strcmp (dest->rname, src->rname));
1909 /* otherwise match on name */
1910 return (!strcmp (dest->name, src->name));
1913 void PT(sym_link *type)
1915 printTypeChain(type,0);
1917 /*-----------------------------------------------------------------*/
1918 /* printTypeChain - prints the type chain in human readable form */
1919 /*-----------------------------------------------------------------*/
1921 printTypeChain (sym_link * start, FILE * of)
1924 sym_link * type, * search;
1934 fprintf (of, "void");
1938 /* Print the chain as it is written in the source: */
1939 /* start with the last entry. */
1940 /* However, the storage class at the end of the */
1941 /* chain reall applies to the first in the chain! */
1943 for (type = start; type && type->next; type = type->next)
1945 scls=SPEC_SCLS(type);
1951 case S_DATA: fprintf (of, "data-"); break;
1952 case S_XDATA: fprintf (of, "xdata-"); break;
1953 case S_SFR: fprintf (of, "sfr-"); break;
1954 case S_SBIT: fprintf (of, "sbit-"); break;
1955 case S_CODE: fprintf (of, "code-"); break;
1956 case S_IDATA: fprintf (of, "idata-"); break;
1957 case S_PDATA: fprintf (of, "pdata-"); break;
1958 case S_LITERAL: fprintf (of, "literal-"); break;
1959 case S_STACK: fprintf (of, "stack-"); break;
1960 case S_XSTACK: fprintf (of, "xstack-"); break;
1961 case S_BIT: fprintf (of, "bit-"); break;
1962 case S_EEPROM: fprintf (of, "eeprom-"); break;
1969 if (!IS_FUNC(type)) {
1970 if (DCL_PTR_VOLATILE (type)) {
1971 fprintf (of, "volatile-");
1973 if (DCL_PTR_CONST (type)) {
1974 fprintf (of, "const-");
1977 switch (DCL_TYPE (type))
1980 fprintf (of, "function %s %s",
1981 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
1982 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
1985 fprintf (of, "generic* ");
1988 fprintf (of, "code* ");
1991 fprintf (of, "xdata* ");
1994 fprintf (of, "eeprom* ");
1997 fprintf (of, "near* ");
2000 fprintf (of, "idata* ");
2003 fprintf (of, "pdata* ");
2006 fprintf (of, "unkown* ");
2009 if (DCL_ELEM(type)) {
2010 fprintf (of, "[%d] ", DCL_ELEM(type));
2012 fprintf (of, "[] ");
2019 if (SPEC_VOLATILE (type))
2020 fprintf (of, "volatile-");
2021 if (SPEC_CONST (type))
2022 fprintf (of, "const-");
2023 if (SPEC_USIGN (type))
2024 fprintf (of, "unsigned-");
2025 switch (SPEC_NOUN (type))
2029 fprintf (of, "long-");
2030 fprintf (of, "int");
2034 fprintf (of, "char");
2038 fprintf (of, "void");
2042 fprintf (of, "float");
2046 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2050 fprintf (of, "sbit");
2054 fprintf (of, "bit {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2058 fprintf (of, "double");
2062 fprintf (of, "unknown type");
2066 /* search entry in list before "type" */
2067 for (search = start; search && search->next != type;)
2068 search = search->next;
2077 /*-----------------------------------------------------------------*/
2078 /* cdbTypeInfo - print the type information for debugger */
2079 /*-----------------------------------------------------------------*/
2081 cdbTypeInfo (sym_link * type, FILE * of)
2083 fprintf (of, "{%d}", getSize (type));
2088 switch (DCL_TYPE (type))
2091 fprintf (of, "DF,");
2094 fprintf (of, "DG,");
2097 fprintf (of, "DC,");
2100 fprintf (of, "DX,");
2103 fprintf (of, "DD,");
2106 fprintf (of, "DI,");
2109 fprintf (of, "DP,");
2112 fprintf (of, "DA,");
2115 fprintf (of, "DA%d,", DCL_ELEM (type));
2123 switch (SPEC_NOUN (type))
2145 fprintf (of, "ST%s", SPEC_STRUCT (type)->tag);
2153 fprintf (of, "SB%d$%d", SPEC_BSTR (type), SPEC_BLEN (type));
2160 if (SPEC_USIGN (type))
2168 /*-----------------------------------------------------------------*/
2169 /* cdbSymbol - prints a symbol & its type information for debugger */
2170 /*-----------------------------------------------------------------*/
2172 cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc)
2184 fprintf (of, "S:"); /* symbol record */
2185 /* if this is not a structure symbol then
2186 we need to figure out the scope information */
2192 if (IS_STATIC (sym->etype))
2193 fprintf (of, "F%s$", moduleName); /* scope is file */
2195 fprintf (of, "G$"); /* scope is global */
2198 /* symbol is local */
2199 fprintf (of, "L%s$", (sym->localof ? sym->localof->name : "-null-"));
2202 fprintf (of, "S$"); /* scope is structure */
2204 /* print the name, & mangled name */
2205 fprintf (of, "%s$%d$%d(", sym->name,
2206 sym->level, sym->block);
2208 cdbTypeInfo (sym->type, of);
2211 /* print the address space */
2212 map = SPEC_OCLS (sym->etype);
2213 fprintf (of, "%c,%d,%d",
2214 (map ? map->dbName : 'Z'), sym->onStack, SPEC_STAK (sym->etype));
2216 /* if assigned to registers then output register names */
2217 /* if this is a function then print
2218 if is it an interrupt routine & interrupt number
2219 and the register bank it is using */
2221 fprintf (of, ",%d,%d,%d", FUNC_ISISR (sym->type),
2222 FUNC_INTNO (sym->type), FUNC_REGBANK (sym->type));
2223 /* alternate location to find this symbol @ : eg registers
2230 /*-----------------------------------------------------------------*/
2231 /* cdbStruct - print a structure for debugger */
2232 /*-----------------------------------------------------------------*/
2234 cdbStruct (structdef * sdef, int block, FILE * of,
2235 int inStruct, char *tag)
2240 /* if block # then must have function scope */
2241 fprintf (of, "F%s$", moduleName);
2242 fprintf (of, "%s[", (tag ? tag : sdef->tag));
2243 for (sym = sdef->fields; sym; sym = sym->next)
2245 fprintf (of, "({%d}", sym->offset);
2246 cdbSymbol (sym, of, TRUE, FALSE);
2254 /*------------------------------------------------------------------*/
2255 /* cdbStructBlock - calls struct printing for a blcks */
2256 /*------------------------------------------------------------------*/
2258 cdbStructBlock (int block, FILE * of)
2261 bucket **table = StructTab;
2265 /* go thru the entire table */
2266 for (i = 0; i < 256; i++)
2268 for (chain = table[i]; chain; chain = chain->next)
2270 if (chain->block >= block)
2272 cdbStruct ((structdef *) chain->sym, chain->block, of, 0, NULL);
2278 /*-----------------------------------------------------------------*/
2279 /* powof2 - returns power of two for the number if number is pow 2 */
2280 /*-----------------------------------------------------------------*/
2282 powof2 (unsigned long num)
2295 if (n1s > 1 || nshifts == 0)
2311 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2312 symbol *__muldiv[3][3][2];
2313 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2314 sym_link *__multypes[3][2];
2315 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2316 symbol *__conv[2][3][2];
2317 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2318 symbol *__rlrr[2][3][2];
2320 sym_link *floatType;
2323 _mangleFunctionName(char *in)
2325 if (port->getMangledFunctionName)
2327 return port->getMangledFunctionName(in);
2335 /*-----------------------------------------------------------------*/
2336 /* typeFromStr - create a typechain from an encoded string */
2337 /* basic types - 'c' - char */
2343 /* '*' - pointer - default (GPOINTER) */
2344 /* modifiers - 'u' - unsigned */
2345 /* pointer modifiers - 'g' - generic */
2349 /* 'F' - function */
2350 /* examples : "ig*" - generic int * */
2351 /* "cx*" - char xdata * */
2352 /* "ui" - unsigned int */
2353 /*-----------------------------------------------------------------*/
2354 sym_link *typeFromStr (char *s)
2356 sym_link *r = newLink(DECLARATOR);
2368 r->class = SPECIFIER;
2369 SPEC_NOUN(r) = V_CHAR;
2373 r->class = SPECIFIER;
2374 SPEC_NOUN(r) = V_INT;
2377 r->class = SPECIFIER;
2378 SPEC_NOUN(r) = V_INT;
2382 r->class = SPECIFIER;
2383 SPEC_NOUN(r) = V_FLOAT;
2386 r->class = SPECIFIER;
2387 SPEC_NOUN(r) = V_VOID;
2390 DCL_TYPE(r) = port->unqualified_pointer;
2397 assert(*(s+1)=='*');
2398 nr = newLink(DECLARATOR);
2403 DCL_TYPE(r) = GPOINTER;
2406 DCL_TYPE(r) = FPOINTER;
2409 DCL_TYPE(r) = CPOINTER;
2412 DCL_TYPE(r) = POINTER;
2415 DCL_TYPE(r) = FUNCTION;
2416 nr = newLink(DECLARATOR);
2419 DCL_TYPE(r) = CPOINTER;
2425 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
2426 "typeFromStr: unknown type");
2429 if (IS_SPEC(r) && usign) {
2438 /*-----------------------------------------------------------------*/
2439 /* initCSupport - create functions for C support routines */
2440 /*-----------------------------------------------------------------*/
2444 const char *smuldivmod[] =
2448 const char *sbwd[] =
2450 "char", "int", "long"
2456 const char *srlrr[] =
2461 int bwd, su, muldivmod, tofrom, rlrr;
2463 if (getenv("SDCC_NO_C_SUPPORT")) {
2464 /* for debugging only */
2468 floatType = newFloatLink ();
2470 for (bwd = 0; bwd < 3; bwd++)
2487 __multypes[bwd][0] = l;
2488 __multypes[bwd][1] = copyLinkChain (l);
2489 SPEC_USIGN (__multypes[bwd][1]) = 1;
2492 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2493 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2494 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2495 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2496 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2497 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2498 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2499 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2500 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2501 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2503 for (tofrom = 0; tofrom < 2; tofrom++)
2505 for (bwd = 0; bwd < 3; bwd++)
2507 for (su = 0; su < 2; su++)
2511 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
2512 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2516 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
2517 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2523 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2525 for (bwd = 0; bwd < 3; bwd++)
2527 for (su = 0; su < 2; su++)
2529 SNPRINTF (buffer, sizeof(buffer),
2531 smuldivmod[muldivmod],
2534 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2535 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2540 for (rlrr = 0; rlrr < 2; rlrr++)
2542 for (bwd = 0; bwd < 3; bwd++)
2544 for (su = 0; su < 2; su++)
2546 SNPRINTF (buffer, sizeof(buffer),
2551 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2552 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
2558 /*-----------------------------------------------------------------*/
2559 /* initBuiltIns - create prototypes for builtin functions */
2560 /*-----------------------------------------------------------------*/
2566 if (!port->builtintable) return ;
2568 for (i = 0 ; port->builtintable[i].name ; i++) {
2569 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
2570 port->builtintable[i].nParms,port->builtintable[i].parm_types);
2571 FUNC_ISBUILTIN(sym->type) = 1;
2572 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
2576 sym_link *validateLink(sym_link *l,
2583 if (l && l->class==select)
2588 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
2589 " expected %s, got %s\n",
2590 macro, args, file, line,
2591 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
2593 return l; // never reached, makes compiler happy.