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 /*------------------------------------------------------------------*/
305 p = Safe_alloc ( sizeof (sym_link));
310 /*------------------------------------------------------------------*/
311 /* newStruct - creats a new structdef from the free list */
312 /*------------------------------------------------------------------*/
314 newStruct (char *tag)
318 s = Safe_alloc ( sizeof (structdef));
320 strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
324 /*------------------------------------------------------------------*/
325 /* pointerTypes - do the computation for the pointer types */
326 /*------------------------------------------------------------------*/
328 pointerTypes (sym_link * ptr, sym_link * type)
333 /* find the first pointer type */
334 while (ptr && !IS_PTR (ptr))
337 /* could not find it */
338 if (!ptr || IS_SPEC (ptr))
341 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
342 pointerTypes (ptr->next, type);
346 /* change the pointer type depending on the
347 storage class of the type */
350 switch (SPEC_SCLS (type))
353 DCL_TYPE (ptr) = FPOINTER;
356 DCL_TYPE (ptr) = IPOINTER;
359 DCL_TYPE (ptr) = PPOINTER;
362 DCL_TYPE (ptr) = POINTER;
365 DCL_TYPE (ptr) = CPOINTER;
368 DCL_TYPE (ptr) = EEPPOINTER;
371 DCL_TYPE (ptr) = port->unqualified_pointer;
374 /* the storage class of type ends here */
377 SPEC_VOLATILE (type) = 0;
380 /* now change all the remaining unknown pointers
381 to generic pointers */
384 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
385 DCL_TYPE (ptr) = port->unqualified_pointer;
389 /* same for the type although it is highly unlikely that
390 type will have a pointer */
393 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
394 DCL_TYPE (type) = port->unqualified_pointer;
400 /*------------------------------------------------------------------*/
401 /* addDecl - adds a declarator @ the end of a chain */
402 /*------------------------------------------------------------------*/
404 addDecl (symbol * sym, int type, sym_link * p)
410 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
411 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
413 /* if we are passed a link then set head & tail */
422 head = tail = newLink ();
423 DCL_TYPE (head) = type;
426 /* if this is the first entry */
434 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
436 sym->etype = mergeSpec (sym->etype, head, sym->name);
440 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
443 while (t->next != sym->etype)
446 tail->next = sym->etype;
450 sym->etype->next = head;
456 /* if the type is an unknown pointer and has
457 a tspec then take the const & volatile
458 attribute from the tspec & make it those of this
463 DCL_TYPE (p) == UPOINTER &&
466 // only for declarators
467 wassert (IS_DECL(sym->type));
469 if (!IS_SPEC (sym->etype))
471 sym->etype = sym->etype->next = newLink ();
472 sym->etype->class = 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 /*------------------------------------------------------------------*/
686 p->class = SPECIFIER;
687 SPEC_NOUN (p) = V_CHAR;
692 /*------------------------------------------------------------------*/
693 /* newFloatLink - a new Float type */
694 /*------------------------------------------------------------------*/
701 p->class = SPECIFIER;
702 SPEC_NOUN (p) = V_FLOAT;
707 /*------------------------------------------------------------------*/
708 /* newLongLink() - new long type */
709 /*------------------------------------------------------------------*/
716 p->class = SPECIFIER;
717 SPEC_NOUN (p) = V_INT;
723 /*------------------------------------------------------------------*/
724 /* newIntLink() - creates an int type */
725 /*------------------------------------------------------------------*/
732 p->class = SPECIFIER;
733 SPEC_NOUN (p) = V_INT;
738 /*------------------------------------------------------------------*/
739 /* getSize - returns size of a type chain in bits */
740 /*------------------------------------------------------------------*/
742 getSize (sym_link * p)
744 /* if nothing return 0 */
748 { /* if this is the specifier then */
749 switch (SPEC_NOUN (p))
750 { /* depending on the specifier type */
752 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
760 return SPEC_STRUCT (p)->size;
766 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
772 /* this is a specifier */
773 switch (DCL_TYPE (p))
777 return DCL_ELEM (p) * getSize (p->next);
779 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
780 // "can not tell the size of an array[]");
800 /*------------------------------------------------------------------*/
801 /* bitsForType - returns # of bits required to store this type */
802 /*------------------------------------------------------------------*/
804 bitsForType (sym_link * p)
806 /* if nothing return 0 */
811 { /* if this is the specifier then */
813 switch (SPEC_NOUN (p))
814 { /* depending on the specifier type */
816 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
818 return FLOATSIZE * 8;
824 return SPEC_STRUCT (p)->size * 8;
830 return SPEC_BLEN (p);
836 /* this is a specifier */
837 switch (DCL_TYPE (p))
840 return DCL_ELEM (p) * getSize (p->next) * 8;
844 return (PTRSIZE * 8);
849 return (FPTRSIZE * 8);
851 return (GPTRSIZE * 8);
858 /*------------------------------------------------------------------*/
859 /* copySymbolChain - copies a symbol chain */
860 /*------------------------------------------------------------------*/
862 copySymbolChain (symbol * src)
869 dest = copySymbol (src);
870 dest->next = copySymbolChain (src->next);
874 /*------------------------------------------------------------------*/
875 /* copySymbol - makes a copy of a symbol */
876 /*------------------------------------------------------------------*/
878 copySymbol (symbol * src)
885 dest = newSymbol (src->name, src->level);
886 memcpy (dest, src, sizeof (symbol));
887 dest->level = src->level;
888 dest->block = src->block;
889 dest->ival = copyIlist (src->ival);
890 dest->type = copyLinkChain (src->type);
891 dest->etype = getSpec (dest->type);
893 dest->key = src->key;
894 dest->allocreq = src->allocreq;
898 /*------------------------------------------------------------------*/
899 /* reverseSyms - reverses the links for a symbol chain */
900 /*------------------------------------------------------------------*/
902 reverseSyms (symbol * sym)
904 symbol *prev, *curr, *next;
919 sym->next = (void *) NULL;
923 /*------------------------------------------------------------------*/
924 /* reverseLink - reverses the links for a type chain */
925 /*------------------------------------------------------------------*/
927 reverseLink (sym_link * type)
929 sym_link *prev, *curr, *next;
944 type->next = (void *) NULL;
948 /*------------------------------------------------------------------*/
949 /* addSymChain - adds a symbol chain to the symboltable */
950 /*------------------------------------------------------------------*/
952 addSymChain (symbol * symHead)
954 symbol *sym = symHead;
957 for (; sym != NULL; sym = sym->next)
960 checkTypeSanity(sym->etype, sym->name);
962 /* if already exists in the symbol table then check if
963 one of them is an extern definition if yes then
964 then check if the type match, if the types match then
965 delete the current entry and add the new entry */
966 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
967 csym->level == sym->level) {
969 /* one definition extern ? */
970 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) {
971 /* do types match ? */
972 if (compareType (csym->type, sym->type) != 1) {
974 werror (E_EXTERN_MISMATCH, csym->name);
979 if (compareType (csym->type, sym->type) != 1) {
980 werror (E_DUPLICATE, sym->name);
984 /* delete current entry */
985 deleteSym (SymbolTab, csym, csym->name);
990 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
995 /*------------------------------------------------------------------*/
996 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
997 /*------------------------------------------------------------------*/
999 funcInChain (sym_link * lnk)
1010 /*------------------------------------------------------------------*/
1011 /* structElemType - returns the type info of a sturct member */
1012 /*------------------------------------------------------------------*/
1014 structElemType (sym_link * stype, value * id)
1016 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1017 sym_link *type, *etype;
1018 sym_link *petype = getSpec (stype);
1022 /* look for the id */
1025 if (strcmp (fields->rname, id->name) == 0)
1027 type = copyLinkChain (fields->type);
1028 etype = getSpec (type);
1029 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1030 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1033 fields = fields->next;
1037 werror (E_NOT_MEMBER, id->name);
1039 // the show must go on
1040 return newIntLink();
1043 /*------------------------------------------------------------------*/
1044 /* getStructElement - returns element of a tructure definition */
1045 /*------------------------------------------------------------------*/
1047 getStructElement (structdef * sdef, symbol * sym)
1051 for (field = sdef->fields; field; field = field->next)
1052 if (strcmp (field->name, sym->name) == 0)
1055 werror (E_NOT_MEMBER, sym->name);
1057 return sdef->fields;
1060 /*------------------------------------------------------------------*/
1061 /* compStructSize - computes the size of a structure */
1062 /*------------------------------------------------------------------*/
1064 compStructSize (int su, structdef * sdef)
1066 int sum = 0, usum = 0;
1070 /* for the identifiers */
1071 loop = sdef->fields;
1074 /* create the internal name for this variable */
1075 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1076 loop->offset = (su == UNION ? sum = 0 : sum);
1077 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1079 /* if this is a bit field */
1082 /* change it to a unsigned bit */
1083 SPEC_NOUN (loop->etype) = V_BIT;
1084 SPEC_USIGN (loop->etype) = 1;
1085 /* check if this fit into the remaining */
1086 /* bits of this byte else align it to the */
1087 /* next byte boundary */
1088 if ((SPEC_BLEN (loop->etype) = loop->bitVar) <= (8 - bitOffset)) {
1089 SPEC_BSTR (loop->etype) = bitOffset;
1090 if ((bitOffset += (loop->bitVar % 8)) == 8)
1093 else /* does not fit */ {
1095 SPEC_BSTR (loop->etype) = bitOffset;
1096 sum += (loop->bitVar / 8);
1097 bitOffset += (loop->bitVar % 8);
1099 /* if this is the last field then pad */
1100 if (!loop->next && bitOffset && bitOffset != 8) {
1106 checkDecl (loop, 1);
1107 sum += getSize (loop->type);
1112 /* if this is not a bitfield but the */
1113 /* previous one was and did not take */
1114 /* the whole byte then pad the rest */
1115 if ((loop && !loop->bitVar) && bitOffset) {
1120 /* if union then size = sizeof larget field */
1122 usum = max (usum, sum);
1126 return (su == UNION ? usum : sum);
1129 /*------------------------------------------------------------------*/
1130 /* checkSClass - check the storage class specification */
1131 /*------------------------------------------------------------------*/
1133 checkSClass (symbol * sym, int isProto)
1135 if (getenv("DEBUG_SANITY")) {
1136 fprintf (stderr, "checkSClass: %s \n", sym->name);
1139 /* type is literal can happen foe enums change
1141 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1142 SPEC_SCLS (sym->etype) = S_AUTO;
1144 /* if sfr or sbit then must also be */
1145 /* volatile the initial value will be xlated */
1146 /* to an absolute address */
1147 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1148 SPEC_SCLS (sym->etype) == S_SFR)
1150 SPEC_VOLATILE (sym->etype) = 1;
1151 /* if initial value given */
1154 SPEC_ABSA (sym->etype) = 1;
1155 SPEC_ADDR (sym->etype) =
1156 (int) list2int (sym->ival);
1161 /* if absolute address given then it mark it as
1162 volatile -- except in the PIC port */
1164 #if !OPT_DISABLE_PIC
1165 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1169 if (IS_ABSOLUTE (sym->etype))
1170 SPEC_VOLATILE (sym->etype) = 1;
1173 /* global variables declared const put into code */
1174 /* if no other storage class specified */
1175 if (sym->level == 0 &&
1176 SPEC_CONST (sym->etype) &&
1177 SPEC_SCLS(sym->etype) == S_FIXED) {
1178 SPEC_SCLS (sym->etype) = S_CODE;
1181 /* global variable in code space is a constant */
1182 if (sym->level == 0 &&
1183 SPEC_SCLS (sym->etype) == S_CODE &&
1185 SPEC_CONST (sym->etype) = 1;
1188 /* if bit variable then no storage class can be */
1189 /* specified since bit is already a storage */
1190 if (IS_BITVAR (sym->etype) &&
1191 (SPEC_SCLS (sym->etype) != S_FIXED &&
1192 SPEC_SCLS (sym->etype) != S_SBIT &&
1193 SPEC_SCLS (sym->etype) != S_BIT)
1196 werror (E_BITVAR_STORAGE, sym->name);
1197 SPEC_SCLS (sym->etype) = S_FIXED;
1200 /* extern variables cannot be initialized */
1201 if (IS_EXTERN (sym->etype) && sym->ival)
1203 werror (E_EXTERN_INIT, sym->name);
1207 /* if this is an atomatic symbol */
1208 if (sym->level && (options.stackAuto || reentrant)) {
1209 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1210 SPEC_SCLS (sym->etype) == S_FIXED ||
1211 SPEC_SCLS (sym->etype) == S_REGISTER ||
1212 SPEC_SCLS (sym->etype) == S_STACK ||
1213 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1214 SPEC_SCLS (sym->etype) = S_AUTO;
1216 /* storage class may only be specified for statics */
1217 if (!IS_STATIC(sym->etype)) {
1218 werror (E_AUTO_ASSUMED, sym->name);
1223 /* automatic symbols cannot be given */
1224 /* an absolute address ignore it */
1226 SPEC_ABSA (sym->etype) &&
1227 (options.stackAuto || reentrant))
1229 werror (E_AUTO_ABSA, sym->name);
1230 SPEC_ABSA (sym->etype) = 0;
1233 /* arrays & pointers cannot be defined for bits */
1234 /* SBITS or SFRs or BIT */
1235 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1236 (SPEC_NOUN (sym->etype) == V_BIT ||
1237 SPEC_NOUN (sym->etype) == V_SBIT ||
1238 SPEC_SCLS (sym->etype) == S_SFR))
1239 werror (E_BIT_ARRAY, sym->name);
1241 /* if this is a bit|sbit then set length & start */
1242 if (SPEC_NOUN (sym->etype) == V_BIT ||
1243 SPEC_NOUN (sym->etype) == V_SBIT)
1245 SPEC_BLEN (sym->etype) = 1;
1246 SPEC_BSTR (sym->etype) = 0;
1250 /* variables declared in CODE space must have */
1251 /* initializers if not an extern */
1252 if (SPEC_SCLS (sym->etype) == S_CODE &&
1253 sym->ival == NULL &&
1255 port->mem.code_ro &&
1256 !IS_EXTERN (sym->etype) &&
1257 !funcInChain (sym->type))
1258 werror (E_CODE_NO_INIT, sym->name);
1261 /* if parameter or local variable then change */
1262 /* the storage class to reflect where the var will go */
1263 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1264 !IS_STATIC(sym->etype))
1266 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1268 SPEC_SCLS (sym->etype) = (options.useXstack ?
1269 S_XSTACK : S_STACK);
1273 /* hack-o-matic! I see no reason why the useXstack option should ever
1274 * control this allcoation, but the code was originally that way, and
1275 * changing it for non-390 ports breaks the compiler badly.
1277 bool useXdata = TARGET_IS_DS390 ? 1 : options.useXstack;
1278 SPEC_SCLS (sym->etype) = (useXdata ?
1284 /*------------------------------------------------------------------*/
1285 /* changePointer - change pointer to functions */
1286 /*------------------------------------------------------------------*/
1288 changePointer (symbol * sym)
1292 /* go thru the chain of declarations */
1293 /* if we find a pointer to a function */
1294 /* unconditionally change it to a ptr */
1296 for (p = sym->type; p; p = p->next)
1298 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1299 DCL_TYPE (p) = port->unqualified_pointer;
1300 if (IS_PTR (p) && IS_FUNC (p->next))
1301 DCL_TYPE (p) = CPOINTER;
1305 /*------------------------------------------------------------------*/
1306 /* checkDecl - does semantic validation of a declaration */
1307 /*------------------------------------------------------------------*/
1309 checkDecl (symbol * sym, int isProto)
1312 checkSClass (sym, isProto); /* check the storage class */
1313 changePointer (sym); /* change pointers if required */
1315 /* if this is an array without any dimension
1316 then update the dimension from the initial value */
1317 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1318 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1323 /*------------------------------------------------------------------*/
1324 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1325 /*------------------------------------------------------------------*/
1327 copyLinkChain (sym_link * p)
1329 sym_link *head, *curr, *loop;
1332 head = loop = (curr ? newLink () : (void *) NULL);
1335 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1336 loop->next = (curr->next ? newLink () : (void *) NULL);
1345 /*------------------------------------------------------------------*/
1346 /* cleanUpBlock - cleansup the symbol table specified for all the */
1347 /* symbols in the given block */
1348 /*------------------------------------------------------------------*/
1350 cleanUpBlock (bucket ** table, int block)
1355 /* go thru the entire table */
1356 for (i = 0; i < 256; i++)
1358 for (chain = table[i]; chain; chain = chain->next)
1360 if (chain->block >= block)
1362 deleteSym (table, chain->sym, chain->name);
1368 /*------------------------------------------------------------------*/
1369 /* cleanUpLevel - cleansup the symbol table specified for all the */
1370 /* symbols in the given level */
1371 /*------------------------------------------------------------------*/
1373 cleanUpLevel (bucket ** table, int level)
1378 /* go thru the entire table */
1379 for (i = 0; i < 256; i++)
1381 for (chain = table[i]; chain; chain = chain->next)
1383 if (chain->level >= level)
1385 deleteSym (table, chain->sym, chain->name);
1391 /*------------------------------------------------------------------*/
1392 /* computeType - computes the resultant type from two types */
1393 /*------------------------------------------------------------------*/
1395 computeType (sym_link * type1, sym_link * type2)
1399 sym_link *etype1 = getSpec (type1);
1400 sym_link *etype2 = getSpec (type2);
1402 /* if one of them is a float then result is a float */
1403 /* here we assume that the types passed are okay */
1404 /* and can be cast to one another */
1405 /* which ever is greater in size */
1406 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1407 rType = newFloatLink ();
1409 /* if only one of them is a bit variable
1410 then the other one prevails */
1411 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1412 rType = copyLinkChain (type2);
1413 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1414 rType = copyLinkChain (type1);
1416 /* if one of them is a pointer or array then that
1418 if (IS_PTR (type1) || IS_ARRAY (type1))
1419 rType = copyLinkChain (type1);
1420 else if (IS_PTR (type2) || IS_ARRAY (type2))
1421 rType = copyLinkChain (type2);
1422 else if (getSize (type1) > getSize (type2))
1423 rType = copyLinkChain (type1);
1425 rType = copyLinkChain (type2);
1427 reType = getSpec (rType);
1429 /* if either of them unsigned but not val then make this unsigned */
1430 if (((!IS_LITERAL(type1) && SPEC_USIGN (etype1)) ||
1431 (!IS_LITERAL(type2) && SPEC_USIGN (etype2))) &&
1433 SPEC_USIGN (reType) = 1;
1435 SPEC_USIGN (reType) = 0;
1437 /* if result is a literal then make not so */
1438 if (IS_LITERAL (reType))
1439 SPEC_SCLS (reType) = S_REGISTER;
1444 /*--------------------------------------------------------------------*/
1445 /* compareType - will do type check return 1 if match, -1 if castable */
1446 /*--------------------------------------------------------------------*/
1448 compareType (sym_link * dest, sym_link * src)
1459 /* if dest is a declarator then */
1464 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1466 //checkFunction(src,dest);
1468 return compareType (dest->next, src->next);
1470 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1473 if (IS_PTR (src) && IS_GENPTR (dest))
1475 if (IS_PTR (dest) && IS_ARRAY (src)) {
1476 value *val=aggregateToPointer (valFromType(src));
1477 int res=compareType (dest, val->type);
1478 Safe_free(val->type);
1482 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1483 return compareType (dest->next, src);
1486 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1492 /* if one is a specifier and the other is not */
1493 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1494 (IS_SPEC (dest) && !IS_SPEC (src)))
1497 /* if one of them is a void then ok */
1498 if (SPEC_NOUN (dest) == V_VOID &&
1499 SPEC_NOUN (src) != V_VOID)
1502 if (SPEC_NOUN (dest) != V_VOID &&
1503 SPEC_NOUN (src) == V_VOID)
1506 /* if they are both bitfields then if the lengths
1507 and starts don't match */
1508 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1509 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1510 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1513 /* it is a specifier */
1514 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1516 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1517 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1518 getSize (dest) == getSize (src))
1520 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1525 else if (IS_STRUCT (dest))
1527 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1532 if (SPEC_LONG (dest) != SPEC_LONG (src))
1535 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1541 /*------------------------------------------------------------------*/
1542 /* inCalleeSaveList - return 1 if found in callee save list */
1543 /*------------------------------------------------------------------*/
1545 inCalleeSaveList (char *s)
1549 if (options.all_callee_saves) return 1;
1550 for (i = 0; options.calleeSaves[i]; i++)
1551 if (strcmp (options.calleeSaves[i], s) == 0)
1557 /*-----------------------------------------------------------------*/
1558 /* aggregateToPointer: change an agggregate type function */
1559 /* argument to a pointer to that type. */
1560 /*-----------------------------------------------------------------*/
1562 aggregateToPointer (value * val)
1564 if (IS_AGGREGATE (val->type))
1566 /* if this is a structure */
1567 /* then we need to add a new link */
1568 if (IS_STRUCT (val->type))
1570 /* first lets add DECLARATOR type */
1571 sym_link *p = val->type;
1573 werror (W_STRUCT_AS_ARG, val->name);
1574 val->type = newLink ();
1575 val->type->next = p;
1578 /* change to a pointer depending on the */
1579 /* storage class specified */
1580 switch (SPEC_SCLS (val->etype))
1583 DCL_TYPE (val->type) = IPOINTER;
1586 DCL_TYPE (val->type) = PPOINTER;
1589 if (SPEC_OCLS(val->etype)) {
1590 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1593 // this happens for (external) function parameters
1594 DCL_TYPE (val->type) = port->unqualified_pointer;
1596 if (TARGET_IS_DS390) {
1597 /* The AUTO and REGISTER classes should probably
1598 * also become generic pointers, but I haven't yet
1599 * devised a test case for that.
1601 DCL_TYPE (val->type) = port->unqualified_pointer;
1604 if (options.model==MODEL_LARGE) {
1605 DCL_TYPE (val->type) = FPOINTER;
1614 DCL_TYPE (val->type) = POINTER;
1617 DCL_TYPE (val->type) = CPOINTER;
1620 DCL_TYPE (val->type) = FPOINTER;
1623 DCL_TYPE (val->type) = EEPPOINTER;
1626 DCL_TYPE (val->type) = port->unqualified_pointer;
1629 /* is there is a symbol associated then */
1630 /* change the type of the symbol as well */
1633 val->sym->type = copyLinkChain (val->type);
1634 val->sym->etype = getSpec (val->sym->type);
1639 /*------------------------------------------------------------------*/
1640 /* checkFunction - does all kinds of check on a function */
1641 /*------------------------------------------------------------------*/
1643 checkFunction (symbol * sym, symbol *csym)
1645 value *exargs, *acargs;
1649 if (getenv("DEBUG_SANITY")) {
1650 fprintf (stderr, "checkFunction: %s ", sym->name);
1653 /* make sure the type is complete and sane */
1654 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1656 /* if not type then some kind of error */
1660 /* if the function has no type then make it return int */
1661 if (!sym->type->next)
1662 sym->type->next = sym->etype = newIntLink ();
1664 /* function cannot return aggregate */
1665 if (IS_AGGREGATE (sym->type->next))
1667 werror (E_FUNC_AGGR, sym->name);
1671 /* function cannot return bit */
1672 if (IS_BITVAR (sym->type->next))
1674 werror (E_FUNC_BIT, sym->name);
1678 /* check if this function is defined as calleeSaves
1679 then mark it as such */
1680 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1682 /* if interrupt service routine */
1683 /* then it cannot have arguments */
1684 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1686 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1687 werror (E_INT_ARGS, sym->name);
1688 FUNC_ARGS(sym->type)=NULL;
1692 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
1694 acargs=acargs->next, argCnt++) {
1696 // this can happen for reentrant functions
1697 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1698 // the show must go on: synthesize a name and symbol
1699 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
1700 acargs->sym = newSymbol (acargs->name, 1);
1701 SPEC_OCLS (acargs->etype) = istack;
1702 acargs->sym->type = copyLinkChain (acargs->type);
1703 acargs->sym->etype = getSpec (acargs->sym->type);
1704 acargs->sym->_isparm = 1;
1705 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
1706 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
1708 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1712 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
1713 return 1; /* not defined nothing more to check */
1715 /* check if body already present */
1716 if (csym && IFFUNC_HASBODY(csym->type))
1718 werror (E_FUNC_BODY, sym->name);
1722 /* check the return value type */
1723 if (compareType (csym->type, sym->type) <= 0)
1725 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1726 printFromToType(csym->type, sym->type);
1730 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
1732 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1735 if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
1737 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1740 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
1742 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
1745 /* compare expected args with actual args */
1746 exargs = FUNC_ARGS(csym->type);
1747 acargs = FUNC_ARGS(sym->type);
1749 /* for all the expected args do */
1752 exargs = exargs->next, acargs = acargs->next, argCnt++)
1754 if (getenv("DEBUG_SANITY")) {
1755 fprintf (stderr, "checkFunction: %s ", exargs->name);
1757 /* make sure the type is complete and sane */
1758 checkTypeSanity(exargs->etype, exargs->name);
1760 /* If the actual argument is an array, any prototype
1761 * will have modified it to a pointer. Duplicate that
1764 if (IS_AGGREGATE (acargs->type))
1766 checkValue = copyValue (acargs);
1767 aggregateToPointer (checkValue);
1771 checkValue = acargs;
1774 if (compareType (exargs->type, checkValue->type) <= 0)
1776 werror (E_ARG_TYPE, argCnt);
1777 printFromToType(exargs->type, checkValue->type);
1782 /* if one them ended we have a problem */
1783 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1784 (!exargs && acargs && !IS_VOID (acargs->type)))
1785 werror (E_ARG_COUNT);
1787 /* replace with this defition */
1788 sym->cdef = csym->cdef;
1789 deleteSym (SymbolTab, csym, csym->name);
1790 deleteFromSeg(csym);
1791 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1792 if (IS_EXTERN (csym->etype) && !
1793 IS_EXTERN (sym->etype))
1795 addSet (&publics, sym);
1800 /*-----------------------------------------------------------------*/
1801 /* processFuncArgs - does some processing with function args */
1802 /*-----------------------------------------------------------------*/
1804 processFuncArgs (symbol * func)
1808 sym_link *funcType=func->type;
1810 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
1811 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
1813 // if this is a pointer to a function
1814 if (IS_PTR(funcType)) {
1815 funcType=funcType->next;
1818 /* if this function has variable argument list */
1819 /* then make the function a reentrant one */
1820 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
1821 FUNC_ISREENT(funcType)=1;
1823 /* check if this function is defined as calleeSaves
1824 then mark it as such */
1825 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
1827 /* loop thru all the arguments */
1828 val = FUNC_ARGS(funcType);
1830 /* if it is void then remove parameters */
1831 if (val && IS_VOID (val->type))
1833 FUNC_ARGS(funcType) = NULL;
1837 /* reset regparm for the port */
1838 (*port->reset_regparms) ();
1839 /* if any of the arguments is an aggregate */
1840 /* change it to pointer to the same type */
1844 /* mark it as a register parameter if
1845 the function does not have VA_ARG
1846 and as port dictates */
1847 if (!IFFUNC_HASVARARGS(funcType) &&
1848 (argreg = (*port->reg_parm) (val->type)))
1850 SPEC_REGPARM (val->etype) = 1;
1851 SPEC_ARGREG(val->etype) = argreg;
1852 } else if (IFFUNC_ISREENT(funcType)) {
1853 FUNC_HASSTACKPARM(funcType) = 1;
1856 if (IS_AGGREGATE (val->type))
1858 aggregateToPointer (val);
1865 /* if this is an internal generated function call */
1867 /* ignore --stack-auto for this one, we don't know how it is compiled */
1868 /* simply trust on --int-long-reent or --float-reent */
1869 if (IFFUNC_ISREENT(funcType)) {
1873 /* if this function is reentrant or */
1874 /* automatics r 2b stacked then nothing */
1875 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
1879 val = FUNC_ARGS(funcType);
1884 /* if a symbolname is not given */
1885 /* synthesize a variable name */
1888 SNPRINTF (val->name, sizeof(val->name),
1889 "_%s_PARM_%d", func->name, pNum++);
1890 val->sym = newSymbol (val->name, 1);
1891 SPEC_OCLS (val->etype) = port->mem.default_local_map;
1892 val->sym->type = copyLinkChain (val->type);
1893 val->sym->etype = getSpec (val->sym->type);
1894 val->sym->_isparm = 1;
1895 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1896 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1897 SPEC_STAT (func->etype);
1898 addSymChain (val->sym);
1901 else /* symbol name given create synth name */
1904 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
1905 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1906 val->sym->_isparm = 1;
1907 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
1908 (options.model != MODEL_SMALL ? xdata : data);
1909 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1910 SPEC_STAT (func->etype);
1912 if (!isinSet(operKeyReset, val->sym)) {
1913 addSet (&operKeyReset, val->sym);
1914 applyToSet (operKeyReset, resetParmKey);
1920 /*-----------------------------------------------------------------*/
1921 /* isSymbolEqual - compares two symbols return 1 if they match */
1922 /*-----------------------------------------------------------------*/
1924 isSymbolEqual (symbol * dest, symbol * src)
1926 /* if pointers match then equal */
1930 /* if one of them is null then don't match */
1934 /* if both of them have rname match on rname */
1935 if (dest->rname[0] && src->rname[0])
1936 return (!strcmp (dest->rname, src->rname));
1938 /* otherwise match on name */
1939 return (!strcmp (dest->name, src->name));
1942 void PT(sym_link *type)
1944 printTypeChain(type,0);
1946 /*-----------------------------------------------------------------*/
1947 /* printTypeChain - prints the type chain in human readable form */
1948 /*-----------------------------------------------------------------*/
1950 printTypeChain (sym_link * start, FILE * of)
1953 sym_link * type, * search;
1962 fprintf (of, "void");
1966 /* print the chain as it is written in the source: */
1967 /* start with the last entry */
1968 for (type = start; type && type->next; type = type->next)
1974 if (DCL_PTR_VOLATILE (type)) {
1975 fprintf (of, "volatile ");
1977 switch (DCL_TYPE (type))
1980 fprintf (of, "function %s %s",
1981 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
1982 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
1985 if (DCL_PTR_CONST (type))
1986 fprintf (of, "const ");
1987 fprintf (of, "generic * ");
1990 if (DCL_PTR_CONST (type))
1991 fprintf (of, "const ");
1992 fprintf (of, "code * ");
1995 if (DCL_PTR_CONST (type))
1996 fprintf (of, "const ");
1997 fprintf (of, "xdata * ");
2000 if (DCL_PTR_CONST (type))
2001 fprintf (of, "const ");
2002 fprintf (of, "eeprom * ");
2006 if (DCL_PTR_CONST (type))
2007 fprintf (of, "const ");
2008 fprintf (of, "near *");
2011 if (DCL_PTR_CONST (type))
2012 fprintf (of, "const ");
2013 fprintf (of, "idata * ");
2016 if (DCL_PTR_CONST (type))
2017 fprintf (of, "const ");
2018 fprintf (of, "pdata * ");
2021 if (DCL_PTR_CONST (type))
2022 fprintf (of, "const ");
2023 fprintf (of, "unkown * ");
2026 if (DCL_ELEM(type)) {
2027 fprintf (of, "[%d] ", DCL_ELEM(type));
2029 fprintf (of, "[] ");
2036 switch (SPEC_SCLS(type))
2038 case S_DATA: fprintf (of, "data "); break;
2039 case S_XDATA: fprintf (of, "xdata "); break;
2040 case S_SFR: fprintf (of, "sfr "); break;
2041 case S_SBIT: fprintf (of, "sbit "); break;
2042 case S_CODE: fprintf (of, "code "); break;
2043 case S_IDATA: fprintf (of, "idata "); break;
2044 case S_PDATA: fprintf (of, "pdata "); break;
2045 case S_LITERAL: fprintf (of, "literal "); break;
2046 case S_STACK: fprintf (of, "stack "); break;
2047 case S_XSTACK: fprintf (of, "xstack "); break;
2048 case S_BIT: fprintf (of, "bit "); break;
2049 case S_EEPROM: fprintf (of, "eeprom "); break;
2053 if (SPEC_VOLATILE (type))
2054 fprintf (of, "volatile ");
2055 if (SPEC_USIGN (type))
2056 fprintf (of, "unsigned ");
2057 if (SPEC_CONST (type))
2058 fprintf (of, "const ");
2059 switch (SPEC_NOUN (type))
2063 fprintf (of, "long ");
2064 fprintf (of, "int");
2068 fprintf (of, "char");
2072 fprintf (of, "void");
2076 fprintf (of, "float");
2080 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2084 fprintf (of, "sbit");
2088 fprintf (of, "bit {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2092 fprintf (of, "double");
2096 fprintf (of, "unknown type");
2100 /* search entry in list before "type" */
2101 for (search = start; search && search->next != type;)
2102 search = search->next;
2111 /*-----------------------------------------------------------------*/
2112 /* cdbTypeInfo - print the type information for debugger */
2113 /*-----------------------------------------------------------------*/
2115 cdbTypeInfo (sym_link * type, FILE * of)
2117 fprintf (of, "{%d}", getSize (type));
2122 switch (DCL_TYPE (type))
2125 fprintf (of, "DF,");
2128 fprintf (of, "DG,");
2131 fprintf (of, "DC,");
2134 fprintf (of, "DX,");
2137 fprintf (of, "DD,");
2140 fprintf (of, "DI,");
2143 fprintf (of, "DP,");
2146 fprintf (of, "DA,");
2149 fprintf (of, "DA%d,", DCL_ELEM (type));
2157 switch (SPEC_NOUN (type))
2179 fprintf (of, "ST%s", SPEC_STRUCT (type)->tag);
2187 fprintf (of, "SB%d$%d", SPEC_BSTR (type), SPEC_BLEN (type));
2194 if (SPEC_USIGN (type))
2202 /*-----------------------------------------------------------------*/
2203 /* cdbSymbol - prints a symbol & its type information for debugger */
2204 /*-----------------------------------------------------------------*/
2206 cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc)
2218 fprintf (of, "S:"); /* symbol record */
2219 /* if this is not a structure symbol then
2220 we need to figure out the scope information */
2226 if (IS_STATIC (sym->etype))
2227 fprintf (of, "F%s$", moduleName); /* scope is file */
2229 fprintf (of, "G$"); /* scope is global */
2232 /* symbol is local */
2233 fprintf (of, "L%s$", (sym->localof ? sym->localof->name : "-null-"));
2236 fprintf (of, "S$"); /* scope is structure */
2238 /* print the name, & mangled name */
2239 fprintf (of, "%s$%d$%d(", sym->name,
2240 sym->level, sym->block);
2242 cdbTypeInfo (sym->type, of);
2245 /* print the address space */
2246 map = SPEC_OCLS (sym->etype);
2247 fprintf (of, "%c,%d,%d",
2248 (map ? map->dbName : 'Z'), sym->onStack, SPEC_STAK (sym->etype));
2250 /* if assigned to registers then output register names */
2251 /* if this is a function then print
2252 if is it an interrupt routine & interrupt number
2253 and the register bank it is using */
2255 fprintf (of, ",%d,%d,%d", FUNC_ISISR (sym->type),
2256 FUNC_INTNO (sym->type), FUNC_REGBANK (sym->type));
2257 /* alternate location to find this symbol @ : eg registers
2264 /*-----------------------------------------------------------------*/
2265 /* cdbStruct - print a structure for debugger */
2266 /*-----------------------------------------------------------------*/
2268 cdbStruct (structdef * sdef, int block, FILE * of,
2269 int inStruct, char *tag)
2274 /* if block # then must have function scope */
2275 fprintf (of, "F%s$", moduleName);
2276 fprintf (of, "%s[", (tag ? tag : sdef->tag));
2277 for (sym = sdef->fields; sym; sym = sym->next)
2279 fprintf (of, "({%d}", sym->offset);
2280 cdbSymbol (sym, of, TRUE, FALSE);
2288 /*------------------------------------------------------------------*/
2289 /* cdbStructBlock - calls struct printing for a blcks */
2290 /*------------------------------------------------------------------*/
2292 cdbStructBlock (int block, FILE * of)
2295 bucket **table = StructTab;
2299 /* go thru the entire table */
2300 for (i = 0; i < 256; i++)
2302 for (chain = table[i]; chain; chain = chain->next)
2304 if (chain->block >= block)
2306 cdbStruct ((structdef *) chain->sym, chain->block, of, 0, NULL);
2312 /*-----------------------------------------------------------------*/
2313 /* powof2 - returns power of two for the number if number is pow 2 */
2314 /*-----------------------------------------------------------------*/
2316 powof2 (unsigned long num)
2329 if (n1s > 1 || nshifts == 0)
2345 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2346 symbol *__muldiv[3][3][2];
2347 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2348 sym_link *__multypes[3][2];
2349 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2350 symbol *__conv[2][3][2];
2351 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2352 symbol *__rlrr[2][3][2];
2354 sym_link *floatType;
2357 _mangleFunctionName(char *in)
2359 if (port->getMangledFunctionName)
2361 return port->getMangledFunctionName(in);
2369 /*-----------------------------------------------------------------*/
2370 /* typeFromStr - create a typechain from an encoded string */
2371 /* basic types - 'c' - char */
2377 /* '*' - pointer - default (GPOINTER) */
2378 /* modifiers - 'u' - unsigned */
2379 /* pointer modifiers - 'g' - generic */
2383 /* 'F' - function */
2384 /* examples : "ig*" - generic int * */
2385 /* "cx*" - char xdata * */
2386 /* "ui" - unsigned int */
2387 /*-----------------------------------------------------------------*/
2388 sym_link *typeFromStr (char *s)
2390 sym_link *r = newLink();
2402 r->class = SPECIFIER;
2403 SPEC_NOUN(r) = V_CHAR;
2407 r->class = SPECIFIER;
2408 SPEC_NOUN(r) = V_INT;
2411 r->class = SPECIFIER;
2412 SPEC_NOUN(r) = V_INT;
2416 r->class = SPECIFIER;
2417 SPEC_NOUN(r) = V_FLOAT;
2420 r->class = SPECIFIER;
2421 SPEC_NOUN(r) = V_VOID;
2424 DCL_TYPE(r) = port->unqualified_pointer;
2431 assert(*(s+1)=='*');
2435 r->class = DECLARATOR ;
2438 DCL_TYPE(r) = GPOINTER;
2441 DCL_TYPE(r) = FPOINTER;
2444 DCL_TYPE(r) = CPOINTER;
2447 DCL_TYPE(r) = POINTER;
2450 DCL_TYPE(r) = FUNCTION;
2454 r->class = DECLARATOR ;
2455 DCL_TYPE(r) = CPOINTER;
2461 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
2462 "typeFromStr: unknown type");
2465 if (IS_SPEC(r) && usign) {
2474 /*-----------------------------------------------------------------*/
2475 /* initCSupport - create functions for C support routines */
2476 /*-----------------------------------------------------------------*/
2480 const char *smuldivmod[] =
2484 const char *sbwd[] =
2486 "char", "int", "long"
2492 const char *srlrr[] =
2497 int bwd, su, muldivmod, tofrom, rlrr;
2499 if (getenv("SDCC_NO_C_SUPPORT")) {
2500 /* for debugging only */
2504 floatType = newFloatLink ();
2506 for (bwd = 0; bwd < 3; bwd++)
2523 __multypes[bwd][0] = l;
2524 __multypes[bwd][1] = copyLinkChain (l);
2525 SPEC_USIGN (__multypes[bwd][1]) = 1;
2528 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2529 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2530 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2531 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2532 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2533 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2534 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2535 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2536 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2537 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2539 for (tofrom = 0; tofrom < 2; tofrom++)
2541 for (bwd = 0; bwd < 3; bwd++)
2543 for (su = 0; su < 2; su++)
2547 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
2548 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2552 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
2553 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2559 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2561 for (bwd = 0; bwd < 3; bwd++)
2563 for (su = 0; su < 2; su++)
2565 SNPRINTF (buffer, sizeof(buffer),
2567 smuldivmod[muldivmod],
2570 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2571 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2576 for (rlrr = 0; rlrr < 2; rlrr++)
2578 for (bwd = 0; bwd < 3; bwd++)
2580 for (su = 0; su < 2; su++)
2582 SNPRINTF (buffer, sizeof(buffer),
2587 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2588 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
2594 /*-----------------------------------------------------------------*/
2595 /* initBuiltIns - create prototypes for builtin functions */
2596 /*-----------------------------------------------------------------*/
2602 if (!port->builtintable) return ;
2604 for (i = 0 ; port->builtintable[i].name ; i++) {
2605 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
2606 port->builtintable[i].nParms,port->builtintable[i].parm_types);
2607 FUNC_ISBUILTIN(sym->type) = 1;
2608 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */