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 = mylineno; /* set the line number */
297 /*------------------------------------------------------------------*/
298 /* newLink - creates a new link (declarator,specifier) */
299 /*------------------------------------------------------------------*/
301 newLink (SYM_LINK_CLASS select)
305 p = Safe_alloc ( sizeof (sym_link));
311 /*------------------------------------------------------------------*/
312 /* newStruct - creats a new structdef from the free list */
313 /*------------------------------------------------------------------*/
315 newStruct (char *tag)
319 s = Safe_alloc ( sizeof (structdef));
321 strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
325 /*------------------------------------------------------------------*/
326 /* pointerTypes - do the computation for the pointer types */
327 /*------------------------------------------------------------------*/
329 pointerTypes (sym_link * ptr, sym_link * type)
334 /* find the first pointer type */
335 while (ptr && !IS_PTR (ptr))
338 /* could not find it */
339 if (!ptr || IS_SPEC (ptr))
342 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
343 pointerTypes (ptr->next, type);
347 /* change the pointer type depending on the
348 storage class of the type */
351 DCL_PTR_CONST (ptr) = SPEC_CONST (type);
352 DCL_PTR_VOLATILE (ptr) = SPEC_VOLATILE (type);
353 switch (SPEC_SCLS (type))
356 DCL_TYPE (ptr) = FPOINTER;
359 DCL_TYPE (ptr) = IPOINTER;
362 DCL_TYPE (ptr) = PPOINTER;
365 DCL_TYPE (ptr) = POINTER;
368 DCL_PTR_CONST (ptr) = port->mem.code_ro;
369 DCL_TYPE (ptr) = CPOINTER;
372 DCL_TYPE (ptr) = EEPPOINTER;
375 DCL_TYPE (ptr) = port->unqualified_pointer;
378 /* the storage class of type ends here */
381 SPEC_VOLATILE (type) = 0;
384 /* now change all the remaining unknown pointers
385 to generic pointers */
388 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
389 DCL_TYPE (ptr) = port->unqualified_pointer;
393 /* same for the type although it is highly unlikely that
394 type will have a pointer */
397 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
398 DCL_TYPE (type) = port->unqualified_pointer;
404 /*------------------------------------------------------------------*/
405 /* addDecl - adds a declarator @ the end of a chain */
406 /*------------------------------------------------------------------*/
408 addDecl (symbol * sym, int type, sym_link * p)
414 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
415 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
417 /* if we are passed a link then set head & tail */
426 head = tail = newLink (DECLARATOR);
427 DCL_TYPE (head) = type;
430 /* if this is the first entry */
438 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
440 sym->etype = mergeSpec (sym->etype, head, sym->name);
444 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
447 while (t->next != sym->etype)
450 tail->next = sym->etype;
454 sym->etype->next = head;
460 /* if the type is an unknown pointer and has
461 a tspec then take the storage class const & volatile
462 attribute from the tspec & make it those of this
466 //DCL_TYPE (p) == UPOINTER &&
469 if (!IS_SPEC (sym->etype))
471 sym->etype = sym->etype->next = newLink (SPECIFIER);
473 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
474 SPEC_CONST (sym->etype) = SPEC_CONST (DCL_TSPEC (p));
475 SPEC_VOLATILE (sym->etype) = SPEC_VOLATILE (DCL_TSPEC (p));
476 DCL_TSPEC (p) = NULL;
479 // if there is a function in this type chain
480 if (p && funcInChain(sym->type)) {
481 processFuncArgs (sym);
487 /*------------------------------------------------------------------
488 checkTypeSanity: prevent the user from doing e.g.:
490 ------------------------------------------------------------------*/
491 void checkTypeSanity(sym_link *etype, char *name) {
495 if (getenv("DEBUG_SANITY")) {
496 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
501 if (!IS_SPEC(etype)) {
502 if (getenv("DEBUG_SANITY")) {
503 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
508 noun=nounName(etype);
510 if (getenv("DEBUG_SANITY")) {
511 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
514 if ((SPEC_NOUN(etype)==V_CHAR ||
515 SPEC_NOUN(etype)==V_FLOAT ||
516 SPEC_NOUN(etype)==V_DOUBLE ||
517 SPEC_NOUN(etype)==V_VOID) &&
518 (etype->select.s._short || SPEC_LONG(etype))) {
519 // long or short for char float double or void
520 werror (E_LONG_OR_SHORT_INVALID, noun, name);
522 if ((SPEC_NOUN(etype)==V_FLOAT ||
523 SPEC_NOUN(etype)==V_DOUBLE ||
524 SPEC_NOUN(etype)==V_VOID) &&
525 (etype->select.s._signed || SPEC_USIGN(etype))) {
526 // signed or unsigned for float double or void
527 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
530 // special case for "short"
531 if (etype->select.s._short) {
532 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
533 etype->select.s._short = 0;
537 "const a;" or "data b;" or "signed s" or "long l"
539 if (!SPEC_NOUN(etype)) {
540 SPEC_NOUN(etype)=V_INT;
543 if (etype->select.s._signed && SPEC_USIGN(etype)) {
544 // signed AND unsigned
545 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
547 if (etype->select.s._short && SPEC_LONG(etype)) {
549 werror (E_LONG_AND_SHORT_INVALID, noun, name);
554 /*------------------------------------------------------------------*/
555 /* mergeSpec - merges two specifiers and returns the new one */
556 /*------------------------------------------------------------------*/
558 mergeSpec (sym_link * dest, sym_link * src, char *name)
560 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
562 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
565 werror (E_SYNTAX_ERROR, yytext);
566 // the show must go on
571 if (SPEC_NOUN(src)) {
572 if (!SPEC_NOUN(dest)) {
573 SPEC_NOUN(dest)=SPEC_NOUN(src);
575 /* we shouldn't redeclare the type */
576 if (getenv("DEBUG_SANITY")) {
577 fprintf (stderr, "mergeSpec: ");
579 werror(E_TWO_OR_MORE_DATA_TYPES, name);
583 if (SPEC_SCLS(src)) {
584 /* if destination has no storage class */
585 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
586 SPEC_SCLS (dest) = SPEC_SCLS (src);
588 if (getenv("DEBUG_SANITY")) {
589 fprintf (stderr, "mergeSpec: ");
591 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
595 /* copy all the specifications */
597 // we really should do:
599 if (SPEC_what(src)) {
600 if (SPEC_what(dest)) {
601 werror(W_DUPLICATE_SPEC, "what");
603 SPEC_what(dst)|=SPEC_what(src);
606 // but there are more important thing right now
608 SPEC_LONG (dest) |= SPEC_LONG (src);
609 dest->select.s._short|=src->select.s._short;
610 SPEC_USIGN (dest) |= SPEC_USIGN (src);
611 dest->select.s._signed|=src->select.s._signed;
612 SPEC_STAT (dest) |= SPEC_STAT (src);
613 SPEC_EXTR (dest) |= SPEC_EXTR (src);
614 SPEC_CONST(dest) |= SPEC_CONST (src);
615 SPEC_ABSA (dest) |= SPEC_ABSA (src);
616 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
617 SPEC_ADDR (dest) |= SPEC_ADDR (src);
618 SPEC_OCLS (dest) = SPEC_OCLS (src);
619 SPEC_BLEN (dest) |= SPEC_BLEN (src);
620 SPEC_BSTR (dest) |= SPEC_BSTR (src);
621 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
622 SPEC_ENUM (dest) |= SPEC_ENUM (src);
623 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
624 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
626 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
627 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
629 /* these are the only function attributes that will be set
630 in a specifier while parsing */
631 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
632 FUNC_BANKED(dest) |= FUNC_BANKED(src);
633 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
634 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
635 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
636 FUNC_ISISR(dest) |= FUNC_ISISR(src);
637 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
638 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
639 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
640 FUNC_INTNO(dest) |= FUNC_INTNO(src);
641 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
646 /*------------------------------------------------------------------*/
647 /* genSymName - generates and returns a name used for anonymous vars */
648 /*------------------------------------------------------------------*/
650 genSymName (int level)
652 static int gCount = 0;
653 static char gname[SDCC_NAME_MAX + 1];
655 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
659 /*------------------------------------------------------------------*/
660 /* getSpec - returns the specifier part from a declaration chain */
661 /*------------------------------------------------------------------*/
663 getSpec (sym_link * p)
668 while (p && !(IS_SPEC (p)))
674 /*------------------------------------------------------------------*/
675 /* newCharLink() - creates an char type */
676 /*------------------------------------------------------------------*/
682 p = newLink (SPECIFIER);
683 SPEC_NOUN (p) = V_CHAR;
688 /*------------------------------------------------------------------*/
689 /* newFloatLink - a new Float type */
690 /*------------------------------------------------------------------*/
696 p = newLink (SPECIFIER);
697 SPEC_NOUN (p) = V_FLOAT;
702 /*------------------------------------------------------------------*/
703 /* newLongLink() - new long type */
704 /*------------------------------------------------------------------*/
710 p = newLink (SPECIFIER);
711 SPEC_NOUN (p) = V_INT;
717 /*------------------------------------------------------------------*/
718 /* newIntLink() - creates an int type */
719 /*------------------------------------------------------------------*/
725 p = newLink (SPECIFIER);
726 SPEC_NOUN (p) = V_INT;
731 /*------------------------------------------------------------------*/
732 /* getSize - returns size of a type chain in bits */
733 /*------------------------------------------------------------------*/
735 getSize (sym_link * p)
737 /* if nothing return 0 */
741 { /* if this is the specifier then */
742 switch (SPEC_NOUN (p))
743 { /* depending on the specifier type */
745 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
753 return SPEC_STRUCT (p)->size;
759 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
765 /* this is a specifier */
766 switch (DCL_TYPE (p))
770 return DCL_ELEM (p) * getSize (p->next);
772 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
773 // "can not tell the size of an array[]");
793 /*------------------------------------------------------------------*/
794 /* bitsForType - returns # of bits required to store this type */
795 /*------------------------------------------------------------------*/
797 bitsForType (sym_link * p)
799 /* if nothing return 0 */
804 { /* if this is the specifier then */
806 switch (SPEC_NOUN (p))
807 { /* depending on the specifier type */
809 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
811 return FLOATSIZE * 8;
817 return SPEC_STRUCT (p)->size * 8;
823 return SPEC_BLEN (p);
829 /* this is a specifier */
830 switch (DCL_TYPE (p))
833 return DCL_ELEM (p) * getSize (p->next) * 8;
837 return (PTRSIZE * 8);
842 return (FPTRSIZE * 8);
844 return (GPTRSIZE * 8);
851 /*------------------------------------------------------------------*/
852 /* copySymbolChain - copies a symbol chain */
853 /*------------------------------------------------------------------*/
855 copySymbolChain (symbol * src)
862 dest = copySymbol (src);
863 dest->next = copySymbolChain (src->next);
867 /*------------------------------------------------------------------*/
868 /* copySymbol - makes a copy of a symbol */
869 /*------------------------------------------------------------------*/
871 copySymbol (symbol * src)
878 dest = newSymbol (src->name, src->level);
879 memcpy (dest, src, sizeof (symbol));
880 dest->level = src->level;
881 dest->block = src->block;
882 dest->ival = copyIlist (src->ival);
883 dest->type = copyLinkChain (src->type);
884 dest->etype = getSpec (dest->type);
886 dest->key = src->key;
887 dest->allocreq = src->allocreq;
891 /*------------------------------------------------------------------*/
892 /* reverseSyms - reverses the links for a symbol chain */
893 /*------------------------------------------------------------------*/
895 reverseSyms (symbol * sym)
897 symbol *prev, *curr, *next;
912 sym->next = (void *) NULL;
916 /*------------------------------------------------------------------*/
917 /* reverseLink - reverses the links for a type chain */
918 /*------------------------------------------------------------------*/
920 reverseLink (sym_link * type)
922 sym_link *prev, *curr, *next;
937 type->next = (void *) NULL;
941 /*------------------------------------------------------------------*/
942 /* addSymChain - adds a symbol chain to the symboltable */
943 /*------------------------------------------------------------------*/
945 addSymChain (symbol * symHead)
947 symbol *sym = symHead;
950 for (; sym != NULL; sym = sym->next)
953 checkTypeSanity(sym->etype, sym->name);
955 /* if already exists in the symbol table then check if
956 one of them is an extern definition if yes then
957 then check if the type match, if the types match then
958 delete the current entry and add the new entry */
959 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
960 csym->level == sym->level) {
962 /* one definition extern ? */
963 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) {
964 /* do types match ? */
965 if (compareType (csym->type, sym->type) != 1) {
967 werror (E_EXTERN_MISMATCH, csym->name);
972 if (compareType (csym->type, sym->type) != 1) {
973 werror (E_DUPLICATE, sym->name);
977 /* delete current entry */
978 deleteSym (SymbolTab, csym, csym->name);
983 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
988 /*------------------------------------------------------------------*/
989 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
990 /*------------------------------------------------------------------*/
992 funcInChain (sym_link * lnk)
1003 /*------------------------------------------------------------------*/
1004 /* structElemType - returns the type info of a sturct member */
1005 /*------------------------------------------------------------------*/
1007 structElemType (sym_link * stype, value * id)
1009 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1010 sym_link *type, *etype;
1011 sym_link *petype = getSpec (stype);
1015 /* look for the id */
1018 if (strcmp (fields->rname, id->name) == 0)
1020 type = copyLinkChain (fields->type);
1021 etype = getSpec (type);
1022 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1023 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1026 fields = fields->next;
1030 werror (E_NOT_MEMBER, id->name);
1032 // the show must go on
1033 return newIntLink();
1036 /*------------------------------------------------------------------*/
1037 /* getStructElement - returns element of a tructure definition */
1038 /*------------------------------------------------------------------*/
1040 getStructElement (structdef * sdef, symbol * sym)
1044 for (field = sdef->fields; field; field = field->next)
1045 if (strcmp (field->name, sym->name) == 0)
1048 werror (E_NOT_MEMBER, sym->name);
1050 return sdef->fields;
1053 /*------------------------------------------------------------------*/
1054 /* compStructSize - computes the size of a structure */
1055 /*------------------------------------------------------------------*/
1057 compStructSize (int su, structdef * sdef)
1059 int sum = 0, usum = 0;
1063 /* for the identifiers */
1064 loop = sdef->fields;
1067 /* create the internal name for this variable */
1068 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1069 loop->offset = (su == UNION ? sum = 0 : sum);
1070 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1072 /* if this is a bit field */
1075 /* change it to a unsigned bit */
1076 SPEC_NOUN (loop->etype) = V_BIT;
1077 SPEC_USIGN (loop->etype) = 1;
1078 /* check if this fit into the remaining */
1079 /* bits of this byte else align it to the */
1080 /* next byte boundary */
1081 if ((SPEC_BLEN (loop->etype) = loop->bitVar) <= (8 - bitOffset)) {
1082 SPEC_BSTR (loop->etype) = bitOffset;
1083 if ((bitOffset += (loop->bitVar % 8)) == 8)
1086 else /* does not fit */ {
1088 SPEC_BSTR (loop->etype) = bitOffset;
1089 sum += (loop->bitVar / 8);
1090 bitOffset += (loop->bitVar % 8);
1092 /* if this is the last field then pad */
1093 if (!loop->next && bitOffset && bitOffset != 8) {
1099 checkDecl (loop, 1);
1100 sum += getSize (loop->type);
1105 /* if this is not a bitfield but the */
1106 /* previous one was and did not take */
1107 /* the whole byte then pad the rest */
1108 if ((loop && !loop->bitVar) && bitOffset) {
1113 /* if union then size = sizeof larget field */
1115 usum = max (usum, sum);
1119 return (su == UNION ? usum : sum);
1122 /*------------------------------------------------------------------*/
1123 /* checkSClass - check the storage class specification */
1124 /*------------------------------------------------------------------*/
1126 checkSClass (symbol * sym, int isProto)
1128 if (getenv("DEBUG_SANITY")) {
1129 fprintf (stderr, "checkSClass: %s \n", sym->name);
1132 /* type is literal can happen foe enums change
1134 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1135 SPEC_SCLS (sym->etype) = S_AUTO;
1137 /* if sfr or sbit then must also be volatile */
1138 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1139 SPEC_SCLS (sym->etype) == S_SFR)
1141 SPEC_VOLATILE (sym->etype) = 1;
1144 /* if absolute address given then it mark it as
1145 volatile -- except in the PIC port */
1147 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1148 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1149 if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1152 if (IS_ABSOLUTE (sym->etype))
1153 SPEC_VOLATILE (sym->etype) = 1;
1156 /* global variables declared const put into code */
1157 /* if no other storage class specified */
1158 if (sym->level == 0 &&
1159 SPEC_CONST (sym->etype) &&
1160 SPEC_SCLS(sym->etype) == S_FIXED &&
1161 !IS_FUNC(sym->type)) {
1162 SPEC_SCLS (sym->etype) = S_CODE;
1165 /* global variable in code space is a constant */
1166 if (sym->level == 0 &&
1167 SPEC_SCLS (sym->etype) == S_CODE &&
1168 port->mem.code_ro) {
1169 if (IS_SPEC(sym->type)) {
1170 SPEC_CONST (sym->type) = 1;
1172 DCL_PTR_CONST (sym->type) = 1;
1176 /* if bit variable then no storage class can be */
1177 /* specified since bit is already a storage */
1178 if (IS_BITVAR (sym->etype) &&
1179 (SPEC_SCLS (sym->etype) != S_FIXED &&
1180 SPEC_SCLS (sym->etype) != S_SBIT &&
1181 SPEC_SCLS (sym->etype) != S_BIT)
1184 werror (E_BITVAR_STORAGE, sym->name);
1185 SPEC_SCLS (sym->etype) = S_FIXED;
1188 /* extern variables cannot be initialized */
1189 if (IS_EXTERN (sym->etype) && sym->ival)
1191 werror (E_EXTERN_INIT, sym->name);
1195 /* if this is an atomatic symbol */
1196 if (sym->level && (options.stackAuto || reentrant)) {
1197 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1198 SPEC_SCLS (sym->etype) == S_FIXED ||
1199 SPEC_SCLS (sym->etype) == S_REGISTER ||
1200 SPEC_SCLS (sym->etype) == S_STACK ||
1201 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1202 SPEC_SCLS (sym->etype) = S_AUTO;
1204 /* storage class may only be specified for statics */
1205 if (!IS_STATIC(sym->etype)) {
1206 werror (E_AUTO_ASSUMED, sym->name);
1211 /* automatic symbols cannot be given */
1212 /* an absolute address ignore it */
1214 SPEC_ABSA (sym->etype) &&
1215 (options.stackAuto || reentrant))
1217 werror (E_AUTO_ABSA, sym->name);
1218 SPEC_ABSA (sym->etype) = 0;
1221 /* arrays & pointers cannot be defined for bits */
1222 /* SBITS or SFRs or BIT */
1223 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1224 (SPEC_NOUN (sym->etype) == V_BIT ||
1225 SPEC_NOUN (sym->etype) == V_SBIT ||
1226 SPEC_SCLS (sym->etype) == S_SFR))
1227 werror (E_BIT_ARRAY, sym->name);
1229 /* if this is a bit|sbit then set length & start */
1230 if (SPEC_NOUN (sym->etype) == V_BIT ||
1231 SPEC_NOUN (sym->etype) == V_SBIT)
1233 SPEC_BLEN (sym->etype) = 1;
1234 SPEC_BSTR (sym->etype) = 0;
1238 /* variables declared in CODE space must have */
1239 /* initializers if not an extern */
1240 if (SPEC_SCLS (sym->etype) == S_CODE &&
1241 sym->ival == NULL &&
1243 port->mem.code_ro &&
1244 !IS_EXTERN (sym->etype) &&
1245 !funcInChain (sym->type))
1246 werror (E_CODE_NO_INIT, sym->name);
1249 /* if parameter or local variable then change */
1250 /* the storage class to reflect where the var will go */
1251 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1252 !IS_STATIC(sym->etype))
1254 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1256 SPEC_SCLS (sym->etype) = (options.useXstack ?
1257 S_XSTACK : S_STACK);
1261 /* hack-o-matic! I see no reason why the useXstack option should ever
1262 * control this allcoation, but the code was originally that way, and
1263 * changing it for non-390 ports breaks the compiler badly.
1265 bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1266 1 : options.useXstack;
1267 SPEC_SCLS (sym->etype) = (useXdata ?
1273 /*------------------------------------------------------------------*/
1274 /* changePointer - change pointer to functions */
1275 /*------------------------------------------------------------------*/
1277 changePointer (symbol * sym)
1281 /* go thru the chain of declarations */
1282 /* if we find a pointer to a function */
1283 /* unconditionally change it to a ptr */
1285 for (p = sym->type; p; p = p->next)
1287 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1288 DCL_TYPE (p) = port->unqualified_pointer;
1289 if (IS_PTR (p) && IS_FUNC (p->next))
1290 DCL_TYPE (p) = CPOINTER;
1294 /*------------------------------------------------------------------*/
1295 /* checkDecl - does semantic validation of a declaration */
1296 /*------------------------------------------------------------------*/
1298 checkDecl (symbol * sym, int isProto)
1301 checkSClass (sym, isProto); /* check the storage class */
1302 changePointer (sym); /* change pointers if required */
1304 /* if this is an array without any dimension
1305 then update the dimension from the initial value */
1306 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1307 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1312 /*------------------------------------------------------------------*/
1313 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1314 /*------------------------------------------------------------------*/
1316 copyLinkChain (sym_link * p)
1318 sym_link *head, *curr, *loop;
1321 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1324 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1325 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1334 /*------------------------------------------------------------------*/
1335 /* cleanUpBlock - cleansup the symbol table specified for all the */
1336 /* symbols in the given block */
1337 /*------------------------------------------------------------------*/
1339 cleanUpBlock (bucket ** table, int block)
1344 /* go thru the entire table */
1345 for (i = 0; i < 256; i++)
1347 for (chain = table[i]; chain; chain = chain->next)
1349 if (chain->block >= block)
1351 deleteSym (table, chain->sym, chain->name);
1357 /*------------------------------------------------------------------*/
1358 /* cleanUpLevel - cleansup the symbol table specified for all the */
1359 /* symbols in the given level */
1360 /*------------------------------------------------------------------*/
1362 cleanUpLevel (bucket ** table, int level)
1367 /* go thru the entire table */
1368 for (i = 0; i < 256; i++)
1370 for (chain = table[i]; chain; chain = chain->next)
1372 if (chain->level >= level)
1374 deleteSym (table, chain->sym, chain->name);
1380 /*------------------------------------------------------------------*/
1381 /* computeType - computes the resultant type from two types */
1382 /*------------------------------------------------------------------*/
1384 computeType (sym_link * type1, sym_link * type2)
1388 sym_link *etype1 = getSpec (type1);
1389 sym_link *etype2 = getSpec (type2);
1391 /* if one of them is a float then result is a float */
1392 /* here we assume that the types passed are okay */
1393 /* and can be cast to one another */
1394 /* which ever is greater in size */
1395 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1396 rType = newFloatLink ();
1398 /* if only one of them is a bit variable
1399 then the other one prevails */
1400 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1401 rType = copyLinkChain (type2);
1402 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1403 rType = copyLinkChain (type1);
1405 /* if one of them is a pointer or array then that
1407 if (IS_PTR (type1) || IS_ARRAY (type1))
1408 rType = copyLinkChain (type1);
1409 else if (IS_PTR (type2) || IS_ARRAY (type2))
1410 rType = copyLinkChain (type2);
1411 else if (getSize (type1) > getSize (type2))
1412 rType = copyLinkChain (type1);
1414 rType = copyLinkChain (type2);
1416 reType = getSpec (rType);
1418 /* if either of them unsigned but not val then make this unsigned */
1419 if (((/*!IS_LITERAL(type1) &&*/ SPEC_USIGN (etype1)) ||
1420 (/*!IS_LITERAL(type2) &&*/ SPEC_USIGN (etype2))) &&
1422 SPEC_USIGN (reType) = 1;
1424 SPEC_USIGN (reType) = 0;
1426 /* if result is a literal then make not so */
1427 if (IS_LITERAL (reType))
1428 SPEC_SCLS (reType) = S_REGISTER;
1433 /*--------------------------------------------------------------------*/
1434 /* compareType - will do type check return 1 if match, -1 if castable */
1435 /*--------------------------------------------------------------------*/
1437 compareType (sym_link * dest, sym_link * src)
1448 /* if dest is a declarator then */
1453 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1455 //checkFunction(src,dest);
1457 return compareType (dest->next, src->next);
1459 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1462 if (IS_PTR (src) && IS_GENPTR (dest))
1464 if (IS_PTR (dest) && IS_ARRAY (src)) {
1465 value *val=aggregateToPointer (valFromType(src));
1466 int res=compareType (dest, val->type);
1467 Safe_free(val->type);
1471 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1472 return compareType (dest->next, src);
1475 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1481 /* if one is a specifier and the other is not */
1482 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1483 (IS_SPEC (dest) && !IS_SPEC (src)))
1486 /* if one of them is a void then ok */
1487 if (SPEC_NOUN (dest) == V_VOID &&
1488 SPEC_NOUN (src) != V_VOID)
1491 if (SPEC_NOUN (dest) != V_VOID &&
1492 SPEC_NOUN (src) == V_VOID)
1495 /* if they are both bitfields then if the lengths
1496 and starts don't match */
1497 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1498 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1499 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1502 /* it is a specifier */
1503 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1505 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1506 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1507 getSize (dest) == getSize (src))
1509 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1514 else if (IS_STRUCT (dest))
1516 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1521 if (SPEC_LONG (dest) != SPEC_LONG (src))
1524 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1530 /*------------------------------------------------------------------*/
1531 /* inCalleeSaveList - return 1 if found in callee save list */
1532 /*------------------------------------------------------------------*/
1534 calleeCmp(void *p1, void *p2)
1536 return (strcmp((char *)p1, (char *)(p2)) == 0);
1540 inCalleeSaveList(char *s)
1542 if (options.all_callee_saves)
1544 return isinSetWith(options.calleeSavesSet, s, calleeCmp);
1547 /*-----------------------------------------------------------------*/
1548 /* aggregateToPointer: change an agggregate type function */
1549 /* argument to a pointer to that type. */
1550 /*-----------------------------------------------------------------*/
1552 aggregateToPointer (value * val)
1554 if (IS_AGGREGATE (val->type))
1556 /* if this is a structure */
1557 /* then we need to add a new link */
1558 if (IS_STRUCT (val->type))
1560 /* first lets add DECLARATOR type */
1561 sym_link *p = val->type;
1563 werror (W_STRUCT_AS_ARG, val->name);
1564 val->type = newLink (DECLARATOR);
1565 val->type->next = p;
1568 /* change to a pointer depending on the */
1569 /* storage class specified */
1570 switch (SPEC_SCLS (val->etype))
1573 DCL_TYPE (val->type) = IPOINTER;
1576 DCL_TYPE (val->type) = PPOINTER;
1579 if (SPEC_OCLS(val->etype)) {
1580 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1582 // this happens for (external) function parameters
1583 DCL_TYPE (val->type) = port->unqualified_pointer;
1589 DCL_TYPE (val->type) = POINTER;
1592 DCL_TYPE (val->type) = CPOINTER;
1595 DCL_TYPE (val->type) = FPOINTER;
1598 DCL_TYPE (val->type) = EEPPOINTER;
1601 DCL_TYPE (val->type) = port->unqualified_pointer;
1604 /* is there is a symbol associated then */
1605 /* change the type of the symbol as well */
1608 val->sym->type = copyLinkChain (val->type);
1609 val->sym->etype = getSpec (val->sym->type);
1614 /*------------------------------------------------------------------*/
1615 /* checkFunction - does all kinds of check on a function */
1616 /*------------------------------------------------------------------*/
1618 checkFunction (symbol * sym, symbol *csym)
1620 value *exargs, *acargs;
1624 if (getenv("DEBUG_SANITY")) {
1625 fprintf (stderr, "checkFunction: %s ", sym->name);
1628 /* make sure the type is complete and sane */
1629 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1631 /* if not type then some kind of error */
1635 /* if the function has no type then make it return int */
1636 if (!sym->type->next)
1637 sym->type->next = sym->etype = newIntLink ();
1639 /* function cannot return aggregate */
1640 if (IS_AGGREGATE (sym->type->next))
1642 werror (E_FUNC_AGGR, sym->name);
1646 /* function cannot return bit */
1647 if (IS_BITVAR (sym->type->next))
1649 werror (E_FUNC_BIT, sym->name);
1653 /* check if this function is defined as calleeSaves
1654 then mark it as such */
1655 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1657 /* if interrupt service routine */
1658 /* then it cannot have arguments */
1659 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1661 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1662 werror (E_INT_ARGS, sym->name);
1663 FUNC_ARGS(sym->type)=NULL;
1667 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
1669 acargs=acargs->next, argCnt++) {
1671 // this can happen for reentrant functions
1672 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1673 // the show must go on: synthesize a name and symbol
1674 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
1675 acargs->sym = newSymbol (acargs->name, 1);
1676 SPEC_OCLS (acargs->etype) = istack;
1677 acargs->sym->type = copyLinkChain (acargs->type);
1678 acargs->sym->etype = getSpec (acargs->sym->type);
1679 acargs->sym->_isparm = 1;
1680 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
1681 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
1683 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1687 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
1688 return 1; /* not defined nothing more to check */
1690 /* check if body already present */
1691 if (csym && IFFUNC_HASBODY(csym->type))
1693 werror (E_FUNC_BODY, sym->name);
1697 /* check the return value type */
1698 if (compareType (csym->type, sym->type) <= 0)
1700 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1701 printFromToType(csym->type, sym->type);
1705 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
1707 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1710 if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
1712 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1715 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
1717 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
1720 /* compare expected args with actual args */
1721 exargs = FUNC_ARGS(csym->type);
1722 acargs = FUNC_ARGS(sym->type);
1724 /* for all the expected args do */
1727 exargs = exargs->next, acargs = acargs->next, argCnt++)
1729 if (getenv("DEBUG_SANITY")) {
1730 fprintf (stderr, "checkFunction: %s ", exargs->name);
1732 /* make sure the type is complete and sane */
1733 checkTypeSanity(exargs->etype, exargs->name);
1735 /* If the actual argument is an array, any prototype
1736 * will have modified it to a pointer. Duplicate that
1739 if (IS_AGGREGATE (acargs->type))
1741 checkValue = copyValue (acargs);
1742 aggregateToPointer (checkValue);
1746 checkValue = acargs;
1749 if (compareType (exargs->type, checkValue->type) <= 0)
1751 werror (E_ARG_TYPE, argCnt);
1752 printFromToType(exargs->type, checkValue->type);
1757 /* if one them ended we have a problem */
1758 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1759 (!exargs && acargs && !IS_VOID (acargs->type)))
1760 werror (E_ARG_COUNT);
1762 /* replace with this defition */
1763 sym->cdef = csym->cdef;
1764 deleteSym (SymbolTab, csym, csym->name);
1765 deleteFromSeg(csym);
1766 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1767 if (IS_EXTERN (csym->etype) && !
1768 IS_EXTERN (sym->etype))
1770 addSet (&publics, sym);
1775 /*------------------------------------------------------------------*/
1776 /* cdbStructBlock - calls struct printing for a blcks */
1777 /*------------------------------------------------------------------*/
1778 void cdbStructBlock (int block)
1781 bucket **table = StructTab;
1784 /* go thru the entire table */
1785 for (i = 0; i < 256; i++)
1787 for (chain = table[i]; chain; chain = chain->next)
1789 if (chain->block >= block)
1792 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
1798 /*-----------------------------------------------------------------*/
1799 /* processFuncArgs - does some processing with function args */
1800 /*-----------------------------------------------------------------*/
1802 processFuncArgs (symbol * func)
1806 sym_link *funcType=func->type;
1808 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
1809 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
1811 // if this is a pointer to a function
1812 if (IS_PTR(funcType)) {
1813 funcType=funcType->next;
1816 /* if this function has variable argument list */
1817 /* then make the function a reentrant one */
1818 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
1819 FUNC_ISREENT(funcType)=1;
1821 /* check if this function is defined as calleeSaves
1822 then mark it as such */
1823 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
1825 /* loop thru all the arguments */
1826 val = FUNC_ARGS(funcType);
1828 /* if it is void then remove parameters */
1829 if (val && IS_VOID (val->type))
1831 FUNC_ARGS(funcType) = NULL;
1835 /* reset regparm for the port */
1836 (*port->reset_regparms) ();
1837 /* if any of the arguments is an aggregate */
1838 /* change it to pointer to the same type */
1842 /* mark it as a register parameter if
1843 the function does not have VA_ARG
1844 and as port dictates */
1845 if (!IFFUNC_HASVARARGS(funcType) &&
1846 (argreg = (*port->reg_parm) (val->type)))
1848 SPEC_REGPARM (val->etype) = 1;
1849 SPEC_ARGREG(val->etype) = argreg;
1850 } else if (IFFUNC_ISREENT(funcType)) {
1851 FUNC_HASSTACKPARM(funcType) = 1;
1854 if (IS_AGGREGATE (val->type))
1856 aggregateToPointer (val);
1863 /* if this is an internal generated function call */
1865 /* ignore --stack-auto for this one, we don't know how it is compiled */
1866 /* simply trust on --int-long-reent or --float-reent */
1867 if (IFFUNC_ISREENT(funcType)) {
1871 /* if this function is reentrant or */
1872 /* automatics r 2b stacked then nothing */
1873 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
1877 val = FUNC_ARGS(funcType);
1882 /* if a symbolname is not given */
1883 /* synthesize a variable name */
1886 SNPRINTF (val->name, sizeof(val->name),
1887 "_%s_PARM_%d", func->name, pNum++);
1888 val->sym = newSymbol (val->name, 1);
1889 SPEC_OCLS (val->etype) = port->mem.default_local_map;
1890 val->sym->type = copyLinkChain (val->type);
1891 val->sym->etype = getSpec (val->sym->type);
1892 val->sym->_isparm = 1;
1893 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
1894 if (IS_SPEC(func->etype)) {
1895 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1896 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 if (IS_SPEC(func->etype)) {
1910 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1911 SPEC_STAT (func->etype);
1914 if (!isinSet(operKeyReset, val->sym)) {
1915 addSet (&operKeyReset, val->sym);
1916 applyToSet (operKeyReset, resetParmKey);
1922 /*-----------------------------------------------------------------*/
1923 /* isSymbolEqual - compares two symbols return 1 if they match */
1924 /*-----------------------------------------------------------------*/
1926 isSymbolEqual (symbol * dest, symbol * src)
1928 /* if pointers match then equal */
1932 /* if one of them is null then don't match */
1936 /* if both of them have rname match on rname */
1937 if (dest->rname[0] && src->rname[0])
1938 return (!strcmp (dest->rname, src->rname));
1940 /* otherwise match on name */
1941 return (!strcmp (dest->name, src->name));
1944 void PT(sym_link *type)
1946 printTypeChain(type,0);
1948 /*-----------------------------------------------------------------*/
1949 /* printTypeChain - prints the type chain in human readable form */
1950 /*-----------------------------------------------------------------*/
1952 printTypeChain (sym_link * start, FILE * of)
1955 sym_link * type, * search;
1965 fprintf (of, "void");
1969 /* Print the chain as it is written in the source: */
1970 /* start with the last entry. */
1971 /* However, the storage class at the end of the */
1972 /* chain reall applies to the first in the chain! */
1974 for (type = start; type && type->next; type = type->next)
1976 scls=SPEC_SCLS(type);
1982 case S_DATA: fprintf (of, "data-"); break;
1983 case S_XDATA: fprintf (of, "xdata-"); break;
1984 case S_SFR: fprintf (of, "sfr-"); break;
1985 case S_SBIT: fprintf (of, "sbit-"); break;
1986 case S_CODE: fprintf (of, "code-"); break;
1987 case S_IDATA: fprintf (of, "idata-"); break;
1988 case S_PDATA: fprintf (of, "pdata-"); break;
1989 case S_LITERAL: fprintf (of, "literal-"); break;
1990 case S_STACK: fprintf (of, "stack-"); break;
1991 case S_XSTACK: fprintf (of, "xstack-"); break;
1992 case S_BIT: fprintf (of, "bit-"); break;
1993 case S_EEPROM: fprintf (of, "eeprom-"); break;
2000 if (!IS_FUNC(type)) {
2001 if (DCL_PTR_VOLATILE (type)) {
2002 fprintf (of, "volatile-");
2004 if (DCL_PTR_CONST (type)) {
2005 fprintf (of, "const-");
2008 switch (DCL_TYPE (type))
2011 fprintf (of, "function %s %s",
2012 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2013 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2016 fprintf (of, "generic* ");
2019 fprintf (of, "code* ");
2022 fprintf (of, "xdata* ");
2025 fprintf (of, "eeprom* ");
2028 fprintf (of, "near* ");
2031 fprintf (of, "idata* ");
2034 fprintf (of, "pdata* ");
2037 fprintf (of, "unkown* ");
2040 if (DCL_ELEM(type)) {
2041 fprintf (of, "[%d] ", DCL_ELEM(type));
2043 fprintf (of, "[] ");
2050 if (SPEC_VOLATILE (type))
2051 fprintf (of, "volatile-");
2052 if (SPEC_CONST (type))
2053 fprintf (of, "const-");
2054 if (SPEC_USIGN (type))
2055 fprintf (of, "unsigned-");
2056 switch (SPEC_NOUN (type))
2060 fprintf (of, "long-");
2061 fprintf (of, "int");
2065 fprintf (of, "char");
2069 fprintf (of, "void");
2073 fprintf (of, "float");
2077 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2081 fprintf (of, "sbit");
2085 fprintf (of, "bit {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2089 fprintf (of, "double");
2093 fprintf (of, "unknown type");
2097 /* search entry in list before "type" */
2098 for (search = start; search && search->next != type;)
2099 search = search->next;
2109 /*-----------------------------------------------------------------*/
2110 /* powof2 - returns power of two for the number if number is pow 2 */
2111 /*-----------------------------------------------------------------*/
2113 powof2 (unsigned long num)
2126 if (n1s > 1 || nshifts == 0)
2142 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2143 symbol *__muldiv[3][3][2];
2144 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2145 sym_link *__multypes[3][2];
2146 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2147 symbol *__conv[2][3][2];
2148 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2149 symbol *__rlrr[2][3][2];
2151 sym_link *floatType;
2154 _mangleFunctionName(char *in)
2156 if (port->getMangledFunctionName)
2158 return port->getMangledFunctionName(in);
2166 /*-----------------------------------------------------------------*/
2167 /* typeFromStr - create a typechain from an encoded string */
2168 /* basic types - 'c' - char */
2174 /* '*' - pointer - default (GPOINTER) */
2175 /* modifiers - 'u' - unsigned */
2176 /* pointer modifiers - 'g' - generic */
2180 /* 'F' - function */
2181 /* examples : "ig*" - generic int * */
2182 /* "cx*" - char xdata * */
2183 /* "ui" - unsigned int */
2184 /*-----------------------------------------------------------------*/
2185 sym_link *typeFromStr (char *s)
2187 sym_link *r = newLink(DECLARATOR);
2199 r->class = SPECIFIER;
2200 SPEC_NOUN(r) = V_CHAR;
2204 r->class = SPECIFIER;
2205 SPEC_NOUN(r) = V_INT;
2208 r->class = SPECIFIER;
2209 SPEC_NOUN(r) = V_INT;
2213 r->class = SPECIFIER;
2214 SPEC_NOUN(r) = V_FLOAT;
2217 r->class = SPECIFIER;
2218 SPEC_NOUN(r) = V_VOID;
2221 DCL_TYPE(r) = port->unqualified_pointer;
2228 assert(*(s+1)=='*');
2229 nr = newLink(DECLARATOR);
2234 DCL_TYPE(r) = GPOINTER;
2237 DCL_TYPE(r) = FPOINTER;
2240 DCL_TYPE(r) = CPOINTER;
2243 DCL_TYPE(r) = POINTER;
2246 DCL_TYPE(r) = FUNCTION;
2247 nr = newLink(DECLARATOR);
2250 DCL_TYPE(r) = CPOINTER;
2256 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
2257 "typeFromStr: unknown type");
2260 if (IS_SPEC(r) && usign) {
2269 /*-----------------------------------------------------------------*/
2270 /* initCSupport - create functions for C support routines */
2271 /*-----------------------------------------------------------------*/
2275 const char *smuldivmod[] =
2279 const char *sbwd[] =
2281 "char", "int", "long"
2287 const char *srlrr[] =
2292 int bwd, su, muldivmod, tofrom, rlrr;
2294 if (getenv("SDCC_NO_C_SUPPORT")) {
2295 /* for debugging only */
2299 floatType = newFloatLink ();
2301 for (bwd = 0; bwd < 3; bwd++)
2318 __multypes[bwd][0] = l;
2319 __multypes[bwd][1] = copyLinkChain (l);
2320 SPEC_USIGN (__multypes[bwd][1]) = 1;
2323 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2324 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2325 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2326 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2327 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2328 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2329 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2330 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2331 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2332 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2334 for (tofrom = 0; tofrom < 2; tofrom++)
2336 for (bwd = 0; bwd < 3; bwd++)
2338 for (su = 0; su < 2; su++)
2342 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
2343 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2347 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
2348 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2355 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2357 for (bwd = 0; bwd < 3; bwd++)
2359 for (su = 0; su < 2; su++)
2361 SNPRINTF (buffer, sizeof(buffer),
2363 smuldivmod[muldivmod],
2366 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2367 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2372 muluint() and mulsint() resp. mululong() and mulslong() return the same result.
2373 Therefore they've been merged into mulint() and mullong().
2376 for (bwd = 0; bwd < 3; bwd++)
2378 for (su = 0; su < 2; su++)
2380 for (muldivmod = 1; muldivmod < 3; muldivmod++)
2383 SNPRINTF (buffer, sizeof(buffer),
2385 smuldivmod[muldivmod],
2388 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2389 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2397 for (su = 0; su < 2; su++)
2399 /* muluchar and mulschar are still separate functions, because e.g. the z80
2400 port is sign/zero-extending to int before calling mulint() */
2401 SNPRINTF (buffer, sizeof(buffer),
2403 smuldivmod[muldivmod],
2406 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2407 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2411 /* word and doubleword */
2412 for (bwd = 1; bwd < 3; bwd++)
2415 SNPRINTF (buffer, sizeof(buffer),
2417 smuldivmod[muldivmod],
2419 __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2420 FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
2421 /* signed = unsigned */
2422 __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
2425 for (rlrr = 0; rlrr < 2; rlrr++)
2427 for (bwd = 0; bwd < 3; bwd++)
2429 for (su = 0; su < 2; su++)
2431 SNPRINTF (buffer, sizeof(buffer),
2436 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2437 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
2443 /*-----------------------------------------------------------------*/
2444 /* initBuiltIns - create prototypes for builtin functions */
2445 /*-----------------------------------------------------------------*/
2451 if (!port->builtintable) return ;
2453 for (i = 0 ; port->builtintable[i].name ; i++) {
2454 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
2455 port->builtintable[i].nParms,port->builtintable[i].parm_types);
2456 FUNC_ISBUILTIN(sym->type) = 1;
2457 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
2461 sym_link *validateLink(sym_link *l,
2468 if (l && l->class==select)
2473 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
2474 " expected %s, got %s\n",
2475 macro, args, file, line,
2476 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
2478 return l; // never reached, makes compiler happy.