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 DCL_PTR_CONST (sym->type) = SPEC_CONST (DCL_TSPEC (p));
476 DCL_PTR_VOLATILE (sym->type) = SPEC_VOLATILE (DCL_TSPEC (p));
477 DCL_TSPEC (p) = NULL;
480 // if there is a function in this type chain
481 if (p && funcInChain(sym->type)) {
482 processFuncArgs (sym);
488 /*------------------------------------------------------------------
489 checkTypeSanity: prevent the user from doing e.g.:
491 ------------------------------------------------------------------*/
492 void checkTypeSanity(sym_link *etype, char *name) {
496 if (getenv("DEBUG_SANITY")) {
497 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
502 if (!IS_SPEC(etype)) {
503 if (getenv("DEBUG_SANITY")) {
504 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
509 noun=nounName(etype);
511 if (getenv("DEBUG_SANITY")) {
512 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
515 if ((SPEC_NOUN(etype)==V_CHAR ||
516 SPEC_NOUN(etype)==V_FLOAT ||
517 SPEC_NOUN(etype)==V_DOUBLE ||
518 SPEC_NOUN(etype)==V_VOID) &&
519 (etype->select.s._short || SPEC_LONG(etype))) {
520 // long or short for char float double or void
521 werror (E_LONG_OR_SHORT_INVALID, noun, name);
523 if ((SPEC_NOUN(etype)==V_FLOAT ||
524 SPEC_NOUN(etype)==V_DOUBLE ||
525 SPEC_NOUN(etype)==V_VOID) &&
526 (etype->select.s._signed || SPEC_USIGN(etype))) {
527 // signed or unsigned for float double or void
528 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
531 // special case for "short"
532 if (etype->select.s._short) {
533 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
534 etype->select.s._short = 0;
538 "const a;" or "data b;" or "signed s" or "long l"
540 if (!SPEC_NOUN(etype)) {
541 SPEC_NOUN(etype)=V_INT;
544 if (etype->select.s._signed && SPEC_USIGN(etype)) {
545 // signed AND unsigned
546 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
548 if (etype->select.s._short && SPEC_LONG(etype)) {
550 werror (E_LONG_AND_SHORT_INVALID, noun, name);
555 /*------------------------------------------------------------------*/
556 /* mergeSpec - merges two specifiers and returns the new one */
557 /*------------------------------------------------------------------*/
559 mergeSpec (sym_link * dest, sym_link * src, char *name)
561 sym_link *symlink=dest;
563 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
565 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
568 werror (E_SYNTAX_ERROR, yytext);
569 // the show must go on
574 if (SPEC_NOUN(src)) {
575 if (!SPEC_NOUN(dest)) {
576 SPEC_NOUN(dest)=SPEC_NOUN(src);
578 /* we shouldn't redeclare the type */
579 if (getenv("DEBUG_SANITY")) {
580 fprintf (stderr, "mergeSpec: ");
582 werror(E_TWO_OR_MORE_DATA_TYPES, name);
586 if (SPEC_SCLS(src)) {
587 /* if destination has no storage class */
588 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
589 SPEC_SCLS (dest) = SPEC_SCLS (src);
591 if (getenv("DEBUG_SANITY")) {
592 fprintf (stderr, "mergeSpec: ");
594 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
598 /* copy all the specifications */
600 // we really should do:
602 if (SPEC_what(src)) {
603 if (SPEC_what(dest)) {
604 werror(W_DUPLICATE_SPEC, "what");
606 SPEC_what(dst)|=SPEC_what(src);
609 // but there are more important thing right now
611 SPEC_LONG (dest) |= SPEC_LONG (src);
612 dest->select.s._short|=src->select.s._short;
613 SPEC_USIGN (dest) |= SPEC_USIGN (src);
614 dest->select.s._signed|=src->select.s._signed;
615 SPEC_STAT (dest) |= SPEC_STAT (src);
616 SPEC_EXTR (dest) |= SPEC_EXTR (src);
617 SPEC_CONST(dest) |= SPEC_CONST (src);
618 SPEC_ABSA (dest) |= SPEC_ABSA (src);
619 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
620 SPEC_ADDR (dest) |= SPEC_ADDR (src);
621 SPEC_OCLS (dest) = SPEC_OCLS (src);
622 SPEC_BLEN (dest) |= SPEC_BLEN (src);
623 SPEC_BSTR (dest) |= SPEC_BSTR (src);
624 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
625 SPEC_ENUM (dest) |= SPEC_ENUM (src);
626 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
627 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
629 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
630 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
632 /* these are the only function attributes that will be set
633 in a specifier while parsing */
634 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
635 FUNC_BANKED(dest) |= FUNC_BANKED(src);
636 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
637 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
638 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
639 FUNC_ISISR(dest) |= FUNC_ISISR(src);
640 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
641 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
642 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
643 FUNC_INTNO(dest) |= FUNC_INTNO(src);
644 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
649 /*------------------------------------------------------------------*/
650 /* genSymName - generates and returns a name used for anonymous vars */
651 /*------------------------------------------------------------------*/
653 genSymName (int level)
655 static int gCount = 0;
656 static char gname[SDCC_NAME_MAX + 1];
658 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
662 /*------------------------------------------------------------------*/
663 /* getSpec - returns the specifier part from a declaration chain */
664 /*------------------------------------------------------------------*/
666 getSpec (sym_link * p)
671 while (p && !(IS_SPEC (p)))
677 /*------------------------------------------------------------------*/
678 /* newCharLink() - creates an char type */
679 /*------------------------------------------------------------------*/
685 p = newLink (SPECIFIER);
686 SPEC_NOUN (p) = V_CHAR;
691 /*------------------------------------------------------------------*/
692 /* newFloatLink - a new Float type */
693 /*------------------------------------------------------------------*/
699 p = newLink (SPECIFIER);
700 SPEC_NOUN (p) = V_FLOAT;
705 /*------------------------------------------------------------------*/
706 /* newLongLink() - new long type */
707 /*------------------------------------------------------------------*/
713 p = newLink (SPECIFIER);
714 SPEC_NOUN (p) = V_INT;
720 /*------------------------------------------------------------------*/
721 /* newIntLink() - creates an int type */
722 /*------------------------------------------------------------------*/
728 p = newLink (SPECIFIER);
729 SPEC_NOUN (p) = V_INT;
734 /*------------------------------------------------------------------*/
735 /* getSize - returns size of a type chain in bits */
736 /*------------------------------------------------------------------*/
738 getSize (sym_link * p)
740 /* if nothing return 0 */
744 { /* if this is the specifier then */
745 switch (SPEC_NOUN (p))
746 { /* depending on the specifier type */
748 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
756 return SPEC_STRUCT (p)->size;
762 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
768 /* this is a specifier */
769 switch (DCL_TYPE (p))
773 return DCL_ELEM (p) * getSize (p->next);
775 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
776 // "can not tell the size of an array[]");
796 /*------------------------------------------------------------------*/
797 /* bitsForType - returns # of bits required to store this type */
798 /*------------------------------------------------------------------*/
800 bitsForType (sym_link * p)
802 /* if nothing return 0 */
807 { /* if this is the specifier then */
809 switch (SPEC_NOUN (p))
810 { /* depending on the specifier type */
812 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
814 return FLOATSIZE * 8;
820 return SPEC_STRUCT (p)->size * 8;
826 return SPEC_BLEN (p);
832 /* this is a specifier */
833 switch (DCL_TYPE (p))
836 return DCL_ELEM (p) * getSize (p->next) * 8;
840 return (PTRSIZE * 8);
845 return (FPTRSIZE * 8);
847 return (GPTRSIZE * 8);
854 /*------------------------------------------------------------------*/
855 /* copySymbolChain - copies a symbol chain */
856 /*------------------------------------------------------------------*/
858 copySymbolChain (symbol * src)
865 dest = copySymbol (src);
866 dest->next = copySymbolChain (src->next);
870 /*------------------------------------------------------------------*/
871 /* copySymbol - makes a copy of a symbol */
872 /*------------------------------------------------------------------*/
874 copySymbol (symbol * src)
881 dest = newSymbol (src->name, src->level);
882 memcpy (dest, src, sizeof (symbol));
883 dest->level = src->level;
884 dest->block = src->block;
885 dest->ival = copyIlist (src->ival);
886 dest->type = copyLinkChain (src->type);
887 dest->etype = getSpec (dest->type);
889 dest->key = src->key;
890 dest->allocreq = src->allocreq;
894 /*------------------------------------------------------------------*/
895 /* reverseSyms - reverses the links for a symbol chain */
896 /*------------------------------------------------------------------*/
898 reverseSyms (symbol * sym)
900 symbol *prev, *curr, *next;
915 sym->next = (void *) NULL;
919 /*------------------------------------------------------------------*/
920 /* reverseLink - reverses the links for a type chain */
921 /*------------------------------------------------------------------*/
923 reverseLink (sym_link * type)
925 sym_link *prev, *curr, *next;
940 type->next = (void *) NULL;
944 /*------------------------------------------------------------------*/
945 /* addSymChain - adds a symbol chain to the symboltable */
946 /*------------------------------------------------------------------*/
948 addSymChain (symbol * symHead)
950 symbol *sym = symHead;
953 for (; sym != NULL; sym = sym->next)
956 checkTypeSanity(sym->etype, sym->name);
958 /* if already exists in the symbol table then check if
959 one of them is an extern definition if yes then
960 then check if the type match, if the types match then
961 delete the current entry and add the new entry */
962 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
963 csym->level == sym->level) {
965 /* one definition extern ? */
966 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) {
967 /* do types match ? */
968 if (compareType (csym->type, sym->type) != 1) {
970 werror (E_EXTERN_MISMATCH, csym->name);
975 if (compareType (csym->type, sym->type) != 1) {
976 werror (E_DUPLICATE, sym->name);
980 /* delete current entry */
981 deleteSym (SymbolTab, csym, csym->name);
986 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
991 /*------------------------------------------------------------------*/
992 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
993 /*------------------------------------------------------------------*/
995 funcInChain (sym_link * lnk)
1006 /*------------------------------------------------------------------*/
1007 /* structElemType - returns the type info of a sturct member */
1008 /*------------------------------------------------------------------*/
1010 structElemType (sym_link * stype, value * id)
1012 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1013 sym_link *type, *etype;
1014 sym_link *petype = getSpec (stype);
1018 /* look for the id */
1021 if (strcmp (fields->rname, id->name) == 0)
1023 type = copyLinkChain (fields->type);
1024 etype = getSpec (type);
1025 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1026 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1029 fields = fields->next;
1033 werror (E_NOT_MEMBER, id->name);
1035 // the show must go on
1036 return newIntLink();
1039 /*------------------------------------------------------------------*/
1040 /* getStructElement - returns element of a tructure definition */
1041 /*------------------------------------------------------------------*/
1043 getStructElement (structdef * sdef, symbol * sym)
1047 for (field = sdef->fields; field; field = field->next)
1048 if (strcmp (field->name, sym->name) == 0)
1051 werror (E_NOT_MEMBER, sym->name);
1053 return sdef->fields;
1056 /*------------------------------------------------------------------*/
1057 /* compStructSize - computes the size of a structure */
1058 /*------------------------------------------------------------------*/
1060 compStructSize (int su, structdef * sdef)
1062 int sum = 0, usum = 0;
1066 /* for the identifiers */
1067 loop = sdef->fields;
1070 /* create the internal name for this variable */
1071 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1072 loop->offset = (su == UNION ? sum = 0 : sum);
1073 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1075 /* if this is a bit field */
1078 /* change it to a unsigned bit */
1079 SPEC_NOUN (loop->etype) = V_BIT;
1080 SPEC_USIGN (loop->etype) = 1;
1081 /* check if this fit into the remaining */
1082 /* bits of this byte else align it to the */
1083 /* next byte boundary */
1084 if ((SPEC_BLEN (loop->etype) = loop->bitVar) <= (8 - bitOffset)) {
1085 SPEC_BSTR (loop->etype) = bitOffset;
1086 if ((bitOffset += (loop->bitVar % 8)) == 8)
1089 else /* does not fit */ {
1091 SPEC_BSTR (loop->etype) = bitOffset;
1092 sum += (loop->bitVar / 8);
1093 bitOffset += (loop->bitVar % 8);
1095 /* if this is the last field then pad */
1096 if (!loop->next && bitOffset && bitOffset != 8) {
1102 checkDecl (loop, 1);
1103 sum += getSize (loop->type);
1108 /* if this is not a bitfield but the */
1109 /* previous one was and did not take */
1110 /* the whole byte then pad the rest */
1111 if ((loop && !loop->bitVar) && bitOffset) {
1116 /* if union then size = sizeof larget field */
1118 usum = max (usum, sum);
1122 return (su == UNION ? usum : sum);
1125 /*------------------------------------------------------------------*/
1126 /* checkSClass - check the storage class specification */
1127 /*------------------------------------------------------------------*/
1129 checkSClass (symbol * sym, int isProto)
1131 if (getenv("DEBUG_SANITY")) {
1132 fprintf (stderr, "checkSClass: %s \n", sym->name);
1135 /* type is literal can happen foe enums change
1137 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1138 SPEC_SCLS (sym->etype) = S_AUTO;
1140 /* if sfr or sbit then must also be */
1141 /* volatile the initial value will be xlated */
1142 /* to an absolute address */
1143 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1144 SPEC_SCLS (sym->etype) == S_SFR)
1146 SPEC_VOLATILE (sym->etype) = 1;
1147 /* if initial value given */
1150 SPEC_ABSA (sym->etype) = 1;
1151 SPEC_ADDR (sym->etype) =
1152 (int) list2int (sym->ival);
1157 /* if absolute address given then it mark it as
1158 volatile -- except in the PIC port */
1160 #if !OPT_DISABLE_PIC
1161 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1165 if (IS_ABSOLUTE (sym->etype))
1166 SPEC_VOLATILE (sym->etype) = 1;
1169 /* global variables declared const put into code */
1170 /* if no other storage class specified */
1171 if (sym->level == 0 &&
1172 SPEC_CONST (sym->etype) &&
1173 SPEC_SCLS(sym->etype) == S_FIXED &&
1174 !IS_FUNC(sym->type)) {
1175 SPEC_SCLS (sym->etype) = S_CODE;
1178 /* global variable in code space is a constant */
1179 if (sym->level == 0 &&
1180 SPEC_SCLS (sym->etype) == S_CODE &&
1182 SPEC_CONST (sym->etype) = 1;
1185 /* if bit variable then no storage class can be */
1186 /* specified since bit is already a storage */
1187 if (IS_BITVAR (sym->etype) &&
1188 (SPEC_SCLS (sym->etype) != S_FIXED &&
1189 SPEC_SCLS (sym->etype) != S_SBIT &&
1190 SPEC_SCLS (sym->etype) != S_BIT)
1193 werror (E_BITVAR_STORAGE, sym->name);
1194 SPEC_SCLS (sym->etype) = S_FIXED;
1197 /* extern variables cannot be initialized */
1198 if (IS_EXTERN (sym->etype) && sym->ival)
1200 werror (E_EXTERN_INIT, sym->name);
1204 /* if this is an atomatic symbol */
1205 if (sym->level && (options.stackAuto || reentrant)) {
1206 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1207 SPEC_SCLS (sym->etype) == S_FIXED ||
1208 SPEC_SCLS (sym->etype) == S_REGISTER ||
1209 SPEC_SCLS (sym->etype) == S_STACK ||
1210 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1211 SPEC_SCLS (sym->etype) = S_AUTO;
1213 /* storage class may only be specified for statics */
1214 if (!IS_STATIC(sym->etype)) {
1215 werror (E_AUTO_ASSUMED, sym->name);
1220 /* automatic symbols cannot be given */
1221 /* an absolute address ignore it */
1223 SPEC_ABSA (sym->etype) &&
1224 (options.stackAuto || reentrant))
1226 werror (E_AUTO_ABSA, sym->name);
1227 SPEC_ABSA (sym->etype) = 0;
1230 /* arrays & pointers cannot be defined for bits */
1231 /* SBITS or SFRs or BIT */
1232 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1233 (SPEC_NOUN (sym->etype) == V_BIT ||
1234 SPEC_NOUN (sym->etype) == V_SBIT ||
1235 SPEC_SCLS (sym->etype) == S_SFR))
1236 werror (E_BIT_ARRAY, sym->name);
1238 /* if this is a bit|sbit then set length & start */
1239 if (SPEC_NOUN (sym->etype) == V_BIT ||
1240 SPEC_NOUN (sym->etype) == V_SBIT)
1242 SPEC_BLEN (sym->etype) = 1;
1243 SPEC_BSTR (sym->etype) = 0;
1247 /* variables declared in CODE space must have */
1248 /* initializers if not an extern */
1249 if (SPEC_SCLS (sym->etype) == S_CODE &&
1250 sym->ival == NULL &&
1252 port->mem.code_ro &&
1253 !IS_EXTERN (sym->etype) &&
1254 !funcInChain (sym->type))
1255 werror (E_CODE_NO_INIT, sym->name);
1258 /* if parameter or local variable then change */
1259 /* the storage class to reflect where the var will go */
1260 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1261 !IS_STATIC(sym->etype))
1263 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1265 SPEC_SCLS (sym->etype) = (options.useXstack ?
1266 S_XSTACK : S_STACK);
1270 /* hack-o-matic! I see no reason why the useXstack option should ever
1271 * control this allcoation, but the code was originally that way, and
1272 * changing it for non-390 ports breaks the compiler badly.
1274 bool useXdata = TARGET_IS_DS390 ? 1 : options.useXstack;
1275 SPEC_SCLS (sym->etype) = (useXdata ?
1281 /*------------------------------------------------------------------*/
1282 /* changePointer - change pointer to functions */
1283 /*------------------------------------------------------------------*/
1285 changePointer (symbol * sym)
1289 /* go thru the chain of declarations */
1290 /* if we find a pointer to a function */
1291 /* unconditionally change it to a ptr */
1293 for (p = sym->type; p; p = p->next)
1295 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1296 DCL_TYPE (p) = port->unqualified_pointer;
1297 if (IS_PTR (p) && IS_FUNC (p->next))
1298 DCL_TYPE (p) = CPOINTER;
1302 /*------------------------------------------------------------------*/
1303 /* checkDecl - does semantic validation of a declaration */
1304 /*------------------------------------------------------------------*/
1306 checkDecl (symbol * sym, int isProto)
1309 checkSClass (sym, isProto); /* check the storage class */
1310 changePointer (sym); /* change pointers if required */
1312 /* if this is an array without any dimension
1313 then update the dimension from the initial value */
1314 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1315 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1320 /*------------------------------------------------------------------*/
1321 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1322 /*------------------------------------------------------------------*/
1324 copyLinkChain (sym_link * p)
1326 sym_link *head, *curr, *loop;
1329 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1332 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1333 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1342 /*------------------------------------------------------------------*/
1343 /* cleanUpBlock - cleansup the symbol table specified for all the */
1344 /* symbols in the given block */
1345 /*------------------------------------------------------------------*/
1347 cleanUpBlock (bucket ** table, int block)
1352 /* go thru the entire table */
1353 for (i = 0; i < 256; i++)
1355 for (chain = table[i]; chain; chain = chain->next)
1357 if (chain->block >= block)
1359 deleteSym (table, chain->sym, chain->name);
1365 /*------------------------------------------------------------------*/
1366 /* cleanUpLevel - cleansup the symbol table specified for all the */
1367 /* symbols in the given level */
1368 /*------------------------------------------------------------------*/
1370 cleanUpLevel (bucket ** table, int level)
1375 /* go thru the entire table */
1376 for (i = 0; i < 256; i++)
1378 for (chain = table[i]; chain; chain = chain->next)
1380 if (chain->level >= level)
1382 deleteSym (table, chain->sym, chain->name);
1388 /*------------------------------------------------------------------*/
1389 /* computeType - computes the resultant type from two types */
1390 /*------------------------------------------------------------------*/
1392 computeType (sym_link * type1, sym_link * type2)
1396 sym_link *etype1 = getSpec (type1);
1397 sym_link *etype2 = getSpec (type2);
1399 /* if one of them is a float then result is a float */
1400 /* here we assume that the types passed are okay */
1401 /* and can be cast to one another */
1402 /* which ever is greater in size */
1403 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1404 rType = newFloatLink ();
1406 /* if only one of them is a bit variable
1407 then the other one prevails */
1408 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1409 rType = copyLinkChain (type2);
1410 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1411 rType = copyLinkChain (type1);
1413 /* if one of them is a pointer or array then that
1415 if (IS_PTR (type1) || IS_ARRAY (type1))
1416 rType = copyLinkChain (type1);
1417 else if (IS_PTR (type2) || IS_ARRAY (type2))
1418 rType = copyLinkChain (type2);
1419 else if (getSize (type1) > getSize (type2))
1420 rType = copyLinkChain (type1);
1422 rType = copyLinkChain (type2);
1424 reType = getSpec (rType);
1426 /* if either of them unsigned but not val then make this unsigned */
1427 if (((!IS_LITERAL(type1) && SPEC_USIGN (etype1)) ||
1428 (!IS_LITERAL(type2) && SPEC_USIGN (etype2))) &&
1430 SPEC_USIGN (reType) = 1;
1432 SPEC_USIGN (reType) = 0;
1434 /* if result is a literal then make not so */
1435 if (IS_LITERAL (reType))
1436 SPEC_SCLS (reType) = S_REGISTER;
1441 /*--------------------------------------------------------------------*/
1442 /* compareType - will do type check return 1 if match, -1 if castable */
1443 /*--------------------------------------------------------------------*/
1445 compareType (sym_link * dest, sym_link * src)
1456 /* if dest is a declarator then */
1461 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1463 //checkFunction(src,dest);
1465 return compareType (dest->next, src->next);
1467 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1470 if (IS_PTR (src) && IS_GENPTR (dest))
1472 if (IS_PTR (dest) && IS_ARRAY (src)) {
1473 value *val=aggregateToPointer (valFromType(src));
1474 int res=compareType (dest, val->type);
1475 Safe_free(val->type);
1479 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1480 return compareType (dest->next, src);
1483 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1489 /* if one is a specifier and the other is not */
1490 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1491 (IS_SPEC (dest) && !IS_SPEC (src)))
1494 /* if one of them is a void then ok */
1495 if (SPEC_NOUN (dest) == V_VOID &&
1496 SPEC_NOUN (src) != V_VOID)
1499 if (SPEC_NOUN (dest) != V_VOID &&
1500 SPEC_NOUN (src) == V_VOID)
1503 /* if they are both bitfields then if the lengths
1504 and starts don't match */
1505 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1506 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1507 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1510 /* it is a specifier */
1511 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1513 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1514 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1515 getSize (dest) == getSize (src))
1517 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1522 else if (IS_STRUCT (dest))
1524 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1529 if (SPEC_LONG (dest) != SPEC_LONG (src))
1532 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1538 /*------------------------------------------------------------------*/
1539 /* inCalleeSaveList - return 1 if found in callee save list */
1540 /*------------------------------------------------------------------*/
1542 inCalleeSaveList (char *s)
1546 if (options.all_callee_saves) return 1;
1547 for (i = 0; options.calleeSaves[i]; i++)
1548 if (strcmp (options.calleeSaves[i], s) == 0)
1554 /*-----------------------------------------------------------------*/
1555 /* aggregateToPointer: change an agggregate type function */
1556 /* argument to a pointer to that type. */
1557 /*-----------------------------------------------------------------*/
1559 aggregateToPointer (value * val)
1561 if (IS_AGGREGATE (val->type))
1563 /* if this is a structure */
1564 /* then we need to add a new link */
1565 if (IS_STRUCT (val->type))
1567 /* first lets add DECLARATOR type */
1568 sym_link *p = val->type;
1570 werror (W_STRUCT_AS_ARG, val->name);
1571 val->type = newLink (DECLARATOR);
1572 val->type->next = p;
1575 /* change to a pointer depending on the */
1576 /* storage class specified */
1577 switch (SPEC_SCLS (val->etype))
1580 DCL_TYPE (val->type) = IPOINTER;
1583 DCL_TYPE (val->type) = PPOINTER;
1586 if (SPEC_OCLS(val->etype)) {
1587 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1589 // this happens for (external) function parameters
1590 DCL_TYPE (val->type) = port->unqualified_pointer;
1596 DCL_TYPE (val->type) = POINTER;
1599 DCL_TYPE (val->type) = CPOINTER;
1602 DCL_TYPE (val->type) = FPOINTER;
1605 DCL_TYPE (val->type) = EEPPOINTER;
1608 DCL_TYPE (val->type) = port->unqualified_pointer;
1611 /* is there is a symbol associated then */
1612 /* change the type of the symbol as well */
1615 val->sym->type = copyLinkChain (val->type);
1616 val->sym->etype = getSpec (val->sym->type);
1621 /*------------------------------------------------------------------*/
1622 /* checkFunction - does all kinds of check on a function */
1623 /*------------------------------------------------------------------*/
1625 checkFunction (symbol * sym, symbol *csym)
1627 value *exargs, *acargs;
1631 if (getenv("DEBUG_SANITY")) {
1632 fprintf (stderr, "checkFunction: %s ", sym->name);
1635 /* make sure the type is complete and sane */
1636 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1638 /* if not type then some kind of error */
1642 /* if the function has no type then make it return int */
1643 if (!sym->type->next)
1644 sym->type->next = sym->etype = newIntLink ();
1646 /* function cannot return aggregate */
1647 if (IS_AGGREGATE (sym->type->next))
1649 werror (E_FUNC_AGGR, sym->name);
1653 /* function cannot return bit */
1654 if (IS_BITVAR (sym->type->next))
1656 werror (E_FUNC_BIT, sym->name);
1660 /* check if this function is defined as calleeSaves
1661 then mark it as such */
1662 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1664 /* if interrupt service routine */
1665 /* then it cannot have arguments */
1666 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1668 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1669 werror (E_INT_ARGS, sym->name);
1670 FUNC_ARGS(sym->type)=NULL;
1674 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
1676 acargs=acargs->next, argCnt++) {
1678 // this can happen for reentrant functions
1679 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1680 // the show must go on: synthesize a name and symbol
1681 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
1682 acargs->sym = newSymbol (acargs->name, 1);
1683 SPEC_OCLS (acargs->etype) = istack;
1684 acargs->sym->type = copyLinkChain (acargs->type);
1685 acargs->sym->etype = getSpec (acargs->sym->type);
1686 acargs->sym->_isparm = 1;
1687 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
1688 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
1690 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1694 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
1695 return 1; /* not defined nothing more to check */
1697 /* check if body already present */
1698 if (csym && IFFUNC_HASBODY(csym->type))
1700 werror (E_FUNC_BODY, sym->name);
1704 /* check the return value type */
1705 if (compareType (csym->type, sym->type) <= 0)
1707 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1708 printFromToType(csym->type, sym->type);
1712 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
1714 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1717 if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
1719 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1722 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
1724 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
1727 /* compare expected args with actual args */
1728 exargs = FUNC_ARGS(csym->type);
1729 acargs = FUNC_ARGS(sym->type);
1731 /* for all the expected args do */
1734 exargs = exargs->next, acargs = acargs->next, argCnt++)
1736 if (getenv("DEBUG_SANITY")) {
1737 fprintf (stderr, "checkFunction: %s ", exargs->name);
1739 /* make sure the type is complete and sane */
1740 checkTypeSanity(exargs->etype, exargs->name);
1742 /* If the actual argument is an array, any prototype
1743 * will have modified it to a pointer. Duplicate that
1746 if (IS_AGGREGATE (acargs->type))
1748 checkValue = copyValue (acargs);
1749 aggregateToPointer (checkValue);
1753 checkValue = acargs;
1756 if (compareType (exargs->type, checkValue->type) <= 0)
1758 werror (E_ARG_TYPE, argCnt);
1759 printFromToType(exargs->type, checkValue->type);
1764 /* if one them ended we have a problem */
1765 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1766 (!exargs && acargs && !IS_VOID (acargs->type)))
1767 werror (E_ARG_COUNT);
1769 /* replace with this defition */
1770 sym->cdef = csym->cdef;
1771 deleteSym (SymbolTab, csym, csym->name);
1772 deleteFromSeg(csym);
1773 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1774 if (IS_EXTERN (csym->etype) && !
1775 IS_EXTERN (sym->etype))
1777 addSet (&publics, sym);
1782 /*-----------------------------------------------------------------*/
1783 /* processFuncArgs - does some processing with function args */
1784 /*-----------------------------------------------------------------*/
1786 processFuncArgs (symbol * func)
1790 sym_link *funcType=func->type;
1792 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
1793 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
1795 // if this is a pointer to a function
1796 if (IS_PTR(funcType)) {
1797 funcType=funcType->next;
1800 /* if this function has variable argument list */
1801 /* then make the function a reentrant one */
1802 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
1803 FUNC_ISREENT(funcType)=1;
1805 /* check if this function is defined as calleeSaves
1806 then mark it as such */
1807 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
1809 /* loop thru all the arguments */
1810 val = FUNC_ARGS(funcType);
1812 /* if it is void then remove parameters */
1813 if (val && IS_VOID (val->type))
1815 FUNC_ARGS(funcType) = NULL;
1819 /* reset regparm for the port */
1820 (*port->reset_regparms) ();
1821 /* if any of the arguments is an aggregate */
1822 /* change it to pointer to the same type */
1826 /* mark it as a register parameter if
1827 the function does not have VA_ARG
1828 and as port dictates */
1829 if (!IFFUNC_HASVARARGS(funcType) &&
1830 (argreg = (*port->reg_parm) (val->type)))
1832 SPEC_REGPARM (val->etype) = 1;
1833 SPEC_ARGREG(val->etype) = argreg;
1834 } else if (IFFUNC_ISREENT(funcType)) {
1835 FUNC_HASSTACKPARM(funcType) = 1;
1838 if (IS_AGGREGATE (val->type))
1840 aggregateToPointer (val);
1847 /* if this is an internal generated function call */
1849 /* ignore --stack-auto for this one, we don't know how it is compiled */
1850 /* simply trust on --int-long-reent or --float-reent */
1851 if (IFFUNC_ISREENT(funcType)) {
1855 /* if this function is reentrant or */
1856 /* automatics r 2b stacked then nothing */
1857 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
1861 val = FUNC_ARGS(funcType);
1866 /* if a symbolname is not given */
1867 /* synthesize a variable name */
1870 SNPRINTF (val->name, sizeof(val->name),
1871 "_%s_PARM_%d", func->name, pNum++);
1872 val->sym = newSymbol (val->name, 1);
1873 SPEC_OCLS (val->etype) = port->mem.default_local_map;
1874 val->sym->type = copyLinkChain (val->type);
1875 val->sym->etype = getSpec (val->sym->type);
1876 val->sym->_isparm = 1;
1877 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1878 if (IS_SPEC(func->etype)) {
1879 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1880 SPEC_STAT (func->etype);
1882 addSymChain (val->sym);
1885 else /* symbol name given create synth name */
1888 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
1889 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1890 val->sym->_isparm = 1;
1891 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
1892 (options.model != MODEL_SMALL ? xdata : data);
1893 if (IS_SPEC(func->etype)) {
1894 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1895 SPEC_STAT (func->etype);
1898 if (!isinSet(operKeyReset, val->sym)) {
1899 addSet (&operKeyReset, val->sym);
1900 applyToSet (operKeyReset, resetParmKey);
1906 /*-----------------------------------------------------------------*/
1907 /* isSymbolEqual - compares two symbols return 1 if they match */
1908 /*-----------------------------------------------------------------*/
1910 isSymbolEqual (symbol * dest, symbol * src)
1912 /* if pointers match then equal */
1916 /* if one of them is null then don't match */
1920 /* if both of them have rname match on rname */
1921 if (dest->rname[0] && src->rname[0])
1922 return (!strcmp (dest->rname, src->rname));
1924 /* otherwise match on name */
1925 return (!strcmp (dest->name, src->name));
1928 void PT(sym_link *type)
1930 printTypeChain(type,0);
1932 /*-----------------------------------------------------------------*/
1933 /* printTypeChain - prints the type chain in human readable form */
1934 /*-----------------------------------------------------------------*/
1936 printTypeChain (sym_link * start, FILE * of)
1939 sym_link * type, * search;
1948 fprintf (of, "void");
1952 /* print the chain as it is written in the source: */
1953 /* start with the last entry */
1954 for (type = start; type && type->next; type = type->next)
1960 if (DCL_PTR_VOLATILE (type)) {
1961 fprintf (of, "volatile ");
1963 switch (DCL_TYPE (type))
1966 fprintf (of, "function %s %s",
1967 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
1968 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
1971 if (DCL_PTR_CONST (type))
1972 fprintf (of, "const ");
1973 fprintf (of, "generic * ");
1976 if (DCL_PTR_CONST (type))
1977 fprintf (of, "const ");
1978 fprintf (of, "code * ");
1981 if (DCL_PTR_CONST (type))
1982 fprintf (of, "const ");
1983 fprintf (of, "xdata * ");
1986 if (DCL_PTR_CONST (type))
1987 fprintf (of, "const ");
1988 fprintf (of, "eeprom * ");
1992 if (DCL_PTR_CONST (type))
1993 fprintf (of, "const ");
1994 fprintf (of, "near *");
1997 if (DCL_PTR_CONST (type))
1998 fprintf (of, "const ");
1999 fprintf (of, "idata * ");
2002 if (DCL_PTR_CONST (type))
2003 fprintf (of, "const ");
2004 fprintf (of, "pdata * ");
2007 if (DCL_PTR_CONST (type))
2008 fprintf (of, "const ");
2009 fprintf (of, "unkown * ");
2012 if (DCL_ELEM(type)) {
2013 fprintf (of, "[%d] ", DCL_ELEM(type));
2015 fprintf (of, "[] ");
2022 switch (SPEC_SCLS(type))
2024 case S_DATA: fprintf (of, "data "); break;
2025 case S_XDATA: fprintf (of, "xdata "); break;
2026 case S_SFR: fprintf (of, "sfr "); break;
2027 case S_SBIT: fprintf (of, "sbit "); break;
2028 case S_CODE: fprintf (of, "code "); break;
2029 case S_IDATA: fprintf (of, "idata "); break;
2030 case S_PDATA: fprintf (of, "pdata "); break;
2031 case S_LITERAL: fprintf (of, "literal "); break;
2032 case S_STACK: fprintf (of, "stack "); break;
2033 case S_XSTACK: fprintf (of, "xstack "); break;
2034 case S_BIT: fprintf (of, "bit "); break;
2035 case S_EEPROM: fprintf (of, "eeprom "); break;
2039 if (SPEC_VOLATILE (type))
2040 fprintf (of, "volatile ");
2041 if (SPEC_USIGN (type))
2042 fprintf (of, "unsigned ");
2043 if (SPEC_CONST (type))
2044 fprintf (of, "const ");
2045 switch (SPEC_NOUN (type))
2049 fprintf (of, "long ");
2050 fprintf (of, "int");
2054 fprintf (of, "char");
2058 fprintf (of, "void");
2062 fprintf (of, "float");
2066 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2070 fprintf (of, "sbit");
2074 fprintf (of, "bit {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2078 fprintf (of, "double");
2082 fprintf (of, "unknown type");
2086 /* search entry in list before "type" */
2087 for (search = start; search && search->next != type;)
2088 search = search->next;
2097 /*-----------------------------------------------------------------*/
2098 /* cdbTypeInfo - print the type information for debugger */
2099 /*-----------------------------------------------------------------*/
2101 cdbTypeInfo (sym_link * type, FILE * of)
2103 fprintf (of, "{%d}", getSize (type));
2108 switch (DCL_TYPE (type))
2111 fprintf (of, "DF,");
2114 fprintf (of, "DG,");
2117 fprintf (of, "DC,");
2120 fprintf (of, "DX,");
2123 fprintf (of, "DD,");
2126 fprintf (of, "DI,");
2129 fprintf (of, "DP,");
2132 fprintf (of, "DA,");
2135 fprintf (of, "DA%d,", DCL_ELEM (type));
2143 switch (SPEC_NOUN (type))
2165 fprintf (of, "ST%s", SPEC_STRUCT (type)->tag);
2173 fprintf (of, "SB%d$%d", SPEC_BSTR (type), SPEC_BLEN (type));
2180 if (SPEC_USIGN (type))
2188 /*-----------------------------------------------------------------*/
2189 /* cdbSymbol - prints a symbol & its type information for debugger */
2190 /*-----------------------------------------------------------------*/
2192 cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc)
2204 fprintf (of, "S:"); /* symbol record */
2205 /* if this is not a structure symbol then
2206 we need to figure out the scope information */
2212 if (IS_STATIC (sym->etype))
2213 fprintf (of, "F%s$", moduleName); /* scope is file */
2215 fprintf (of, "G$"); /* scope is global */
2218 /* symbol is local */
2219 fprintf (of, "L%s$", (sym->localof ? sym->localof->name : "-null-"));
2222 fprintf (of, "S$"); /* scope is structure */
2224 /* print the name, & mangled name */
2225 fprintf (of, "%s$%d$%d(", sym->name,
2226 sym->level, sym->block);
2228 cdbTypeInfo (sym->type, of);
2231 /* print the address space */
2232 map = SPEC_OCLS (sym->etype);
2233 fprintf (of, "%c,%d,%d",
2234 (map ? map->dbName : 'Z'), sym->onStack, SPEC_STAK (sym->etype));
2236 /* if assigned to registers then output register names */
2237 /* if this is a function then print
2238 if is it an interrupt routine & interrupt number
2239 and the register bank it is using */
2241 fprintf (of, ",%d,%d,%d", FUNC_ISISR (sym->type),
2242 FUNC_INTNO (sym->type), FUNC_REGBANK (sym->type));
2243 /* alternate location to find this symbol @ : eg registers
2250 /*-----------------------------------------------------------------*/
2251 /* cdbStruct - print a structure for debugger */
2252 /*-----------------------------------------------------------------*/
2254 cdbStruct (structdef * sdef, int block, FILE * of,
2255 int inStruct, char *tag)
2260 /* if block # then must have function scope */
2261 fprintf (of, "F%s$", moduleName);
2262 fprintf (of, "%s[", (tag ? tag : sdef->tag));
2263 for (sym = sdef->fields; sym; sym = sym->next)
2265 fprintf (of, "({%d}", sym->offset);
2266 cdbSymbol (sym, of, TRUE, FALSE);
2274 /*------------------------------------------------------------------*/
2275 /* cdbStructBlock - calls struct printing for a blcks */
2276 /*------------------------------------------------------------------*/
2278 cdbStructBlock (int block, FILE * of)
2281 bucket **table = StructTab;
2285 /* go thru the entire table */
2286 for (i = 0; i < 256; i++)
2288 for (chain = table[i]; chain; chain = chain->next)
2290 if (chain->block >= block)
2292 cdbStruct ((structdef *) chain->sym, chain->block, of, 0, NULL);
2298 /*-----------------------------------------------------------------*/
2299 /* powof2 - returns power of two for the number if number is pow 2 */
2300 /*-----------------------------------------------------------------*/
2302 powof2 (unsigned long num)
2315 if (n1s > 1 || nshifts == 0)
2331 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2332 symbol *__muldiv[3][3][2];
2333 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2334 sym_link *__multypes[3][2];
2335 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2336 symbol *__conv[2][3][2];
2337 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2338 symbol *__rlrr[2][3][2];
2340 sym_link *floatType;
2343 _mangleFunctionName(char *in)
2345 if (port->getMangledFunctionName)
2347 return port->getMangledFunctionName(in);
2355 /*-----------------------------------------------------------------*/
2356 /* typeFromStr - create a typechain from an encoded string */
2357 /* basic types - 'c' - char */
2363 /* '*' - pointer - default (GPOINTER) */
2364 /* modifiers - 'u' - unsigned */
2365 /* pointer modifiers - 'g' - generic */
2369 /* 'F' - function */
2370 /* examples : "ig*" - generic int * */
2371 /* "cx*" - char xdata * */
2372 /* "ui" - unsigned int */
2373 /*-----------------------------------------------------------------*/
2374 sym_link *typeFromStr (char *s)
2376 sym_link *r = newLink(DECLARATOR);
2388 r->class = SPECIFIER;
2389 SPEC_NOUN(r) = V_CHAR;
2393 r->class = SPECIFIER;
2394 SPEC_NOUN(r) = V_INT;
2397 r->class = SPECIFIER;
2398 SPEC_NOUN(r) = V_INT;
2402 r->class = SPECIFIER;
2403 SPEC_NOUN(r) = V_FLOAT;
2406 r->class = SPECIFIER;
2407 SPEC_NOUN(r) = V_VOID;
2410 DCL_TYPE(r) = port->unqualified_pointer;
2417 assert(*(s+1)=='*');
2418 nr = newLink(DECLARATOR);
2423 DCL_TYPE(r) = GPOINTER;
2426 DCL_TYPE(r) = FPOINTER;
2429 DCL_TYPE(r) = CPOINTER;
2432 DCL_TYPE(r) = POINTER;
2435 DCL_TYPE(r) = FUNCTION;
2436 nr = newLink(DECLARATOR);
2439 DCL_TYPE(r) = CPOINTER;
2445 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
2446 "typeFromStr: unknown type");
2449 if (IS_SPEC(r) && usign) {
2458 /*-----------------------------------------------------------------*/
2459 /* initCSupport - create functions for C support routines */
2460 /*-----------------------------------------------------------------*/
2464 const char *smuldivmod[] =
2468 const char *sbwd[] =
2470 "char", "int", "long"
2476 const char *srlrr[] =
2481 int bwd, su, muldivmod, tofrom, rlrr;
2483 if (getenv("SDCC_NO_C_SUPPORT")) {
2484 /* for debugging only */
2488 floatType = newFloatLink ();
2490 for (bwd = 0; bwd < 3; bwd++)
2507 __multypes[bwd][0] = l;
2508 __multypes[bwd][1] = copyLinkChain (l);
2509 SPEC_USIGN (__multypes[bwd][1]) = 1;
2512 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2513 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2514 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2515 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2516 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2517 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2518 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2519 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2520 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2521 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2523 for (tofrom = 0; tofrom < 2; tofrom++)
2525 for (bwd = 0; bwd < 3; bwd++)
2527 for (su = 0; su < 2; su++)
2531 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
2532 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2536 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
2537 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2543 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2545 for (bwd = 0; bwd < 3; bwd++)
2547 for (su = 0; su < 2; su++)
2549 SNPRINTF (buffer, sizeof(buffer),
2551 smuldivmod[muldivmod],
2554 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2555 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2560 for (rlrr = 0; rlrr < 2; rlrr++)
2562 for (bwd = 0; bwd < 3; bwd++)
2564 for (su = 0; su < 2; su++)
2566 SNPRINTF (buffer, sizeof(buffer),
2571 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2572 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
2578 /*-----------------------------------------------------------------*/
2579 /* initBuiltIns - create prototypes for builtin functions */
2580 /*-----------------------------------------------------------------*/
2586 if (!port->builtintable) return ;
2588 for (i = 0 ; port->builtintable[i].name ; i++) {
2589 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
2590 port->builtintable[i].nParms,port->builtintable[i].parm_types);
2591 FUNC_ISBUILTIN(sym->type) = 1;
2592 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
2596 sym_link *validateLink(sym_link *l,
2603 if (l && l->class==select)
2608 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
2609 " expected %s, got %s\n",
2610 macro, args, file, line,
2611 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
2613 return l; // never reached, makes compiler happy.