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);
28 void printTypeChainRaw (sym_link * start, FILE * of);
30 void printFromToType(sym_link *from, sym_link *to) {
31 fprintf (stderr, "from type '");
32 printTypeChain (from, stderr);
33 fprintf (stderr, "'\nto type '");
34 printTypeChain (to, stderr);
35 fprintf (stderr, "'\n");
39 char *nounName(sym_link *sl) {
40 switch (SPEC_NOUN(sl))
43 if (SPEC_LONG(sl)) return "long";
44 if (sl->select.s._short) return "short";
47 case V_FLOAT: return "float";
48 case V_CHAR: return "char";
49 case V_VOID: return "void";
50 case V_STRUCT: return "struct";
51 case V_LABEL: return "label";
52 case V_BITFIELD: return "bitfield";
53 case V_BIT: return "bit";
54 case V_SBIT: return "sbit";
55 case V_DOUBLE: return "double";
60 bucket *SymbolTab[256]; /* the symbol table */
61 bucket *StructTab[256]; /* the structure table */
62 bucket *TypedefTab[256]; /* the typedef table */
63 bucket *LabelTab[256]; /* the Label table */
64 bucket *enumTab[256]; /* enumerated table */
66 /*------------------------------------------------------------------*/
67 /* initSymt () - initialises symbol table related stuff */
68 /*------------------------------------------------------------------*/
74 for (i = 0; i < 256; i++)
75 SymbolTab[i] = StructTab[i] = (void *) NULL;
79 /*-----------------------------------------------------------------*/
80 /* newBucket - allocates & returns a new bucket */
81 /*-----------------------------------------------------------------*/
87 bp = Safe_alloc ( sizeof (bucket));
92 /*-----------------------------------------------------------------*/
93 /* hashKey - computes the hashkey given a symbol name */
94 /*-----------------------------------------------------------------*/
96 hashKey (const char *s)
98 unsigned long key = 0;
105 /*-----------------------------------------------------------------*/
106 /* addSym - adds a symbol to the hash Table */
107 /*-----------------------------------------------------------------*/
109 addSym (bucket ** stab,
116 int i; /* index into the hash Table */
117 bucket *bp; /* temp bucket * */
120 symbol *csym = (symbol *)sym;
122 if (getenv("DEBUG_SANITY")) {
123 fprintf (stderr, "addSym: %s ", sname);
125 /* make sure the type is complete and sane */
126 checkTypeSanity(csym->etype, csym->name);
129 /* prevent overflow of the (r)name buffers */
130 if (strlen(sname)>SDCC_SYMNAME_MAX) {
131 werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
132 sname[SDCC_SYMNAME_MAX]='\0';
135 /* the symbols are always added at the head of the list */
137 /* get a free entry */
138 bp = Safe_alloc ( sizeof (bucket));
140 bp->sym = sym; /* update the symbol pointer */
141 bp->level = level; /* update the nest level */
143 strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
145 /* if this is the first entry */
148 bp->prev = bp->next = (void *) NULL; /* point to nothing */
151 /* not first entry then add @ head of list */
161 /*-----------------------------------------------------------------*/
162 /* deleteSym - deletes a symbol from the hash Table entry */
163 /*-----------------------------------------------------------------*/
165 deleteSym (bucket ** stab, void *sym, char *sname)
173 /* find the symbol */
176 if (bp->sym == sym) /* found it then break out */
177 break; /* of the loop */
181 if (!bp) /* did not find it */
183 /* if this is the first one in the chain */
187 if (stab[i]) /* if chain ! empty */
188 stab[i]->prev = (void *) NULL;
190 /* middle || end of chain */
193 if (bp->next) /* if not end of chain */
194 bp->next->prev = bp->prev;
196 bp->prev->next = bp->next;
201 /*-----------------------------------------------------------------*/
202 /* findSym - finds a symbol in a table */
203 /*-----------------------------------------------------------------*/
205 findSym (bucket ** stab, void *sym, const char *sname)
209 bp = stab[hashKey (sname)];
212 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
217 return (bp ? bp->sym : (void *) NULL);
220 /*-----------------------------------------------------------------*/
221 /* findSymWithLevel - finds a symbol with a name & level */
222 /*-----------------------------------------------------------------*/
224 findSymWithLevel (bucket ** stab, symbol * sym)
228 bp = stab[hashKey (sym->name)];
231 ** do the search from the head of the list since the
232 ** elements are added at the head it is ensured that
233 ** we will find the deeper definitions before we find
234 ** the global ones. we need to check for symbols with
235 ** level <= to the level given, if levels match then block
236 ** numbers need to match as well
240 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
242 /* if this is parameter then nothing else need to be checked */
243 if (((symbol *) (bp->sym))->_isparm)
245 /* if levels match then block numbers should also match */
246 if (bp->level && bp->level == sym->level && bp->block == sym->block)
248 /* if levels don't match then we are okay */
249 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
251 /* if this is a global variable then we are ok too */
259 return (void *) NULL;
262 /*-----------------------------------------------------------------*/
263 /* findSymWithBlock - finds a symbol with name in with a block */
264 /*-----------------------------------------------------------------*/
266 findSymWithBlock (bucket ** stab, symbol * sym, int block)
270 bp = stab[hashKey (sym->name)];
273 if (strcmp (bp->name, sym->name) == 0 &&
279 return (bp ? bp->sym : (void *) NULL);
282 /*------------------------------------------------------------------*/
283 /* newSymbol () - returns a new pointer to a symbol */
284 /*------------------------------------------------------------------*/
286 newSymbol (char *name, int scope)
290 sym = Safe_alloc ( sizeof (symbol));
292 strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */
293 sym->level = scope; /* set the level */
294 sym->block = currBlockno;
295 sym->lineDef = mylineno; /* set the line number */
299 /*------------------------------------------------------------------*/
300 /* newLink - creates a new link (declarator,specifier) */
301 /*------------------------------------------------------------------*/
303 newLink (SYM_LINK_CLASS select)
307 p = Safe_alloc ( sizeof (sym_link));
313 /*------------------------------------------------------------------*/
314 /* newStruct - creats a new structdef from the free list */
315 /*------------------------------------------------------------------*/
317 newStruct (char *tag)
321 s = Safe_alloc ( sizeof (structdef));
323 strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
327 /*------------------------------------------------------------------*/
328 /* sclsFromPtr - Return the storage class a pointer points into. */
329 /* S_FIXED is returned for generic pointers or other */
330 /* unexpected cases */
331 /*------------------------------------------------------------------*/
333 sclsFromPtr(sym_link *ptr)
335 switch (DCL_TYPE (ptr))
358 /*------------------------------------------------------------------*/
359 /* pointerTypes - do the computation for the pointer types */
360 /*------------------------------------------------------------------*/
362 pointerTypes (sym_link * ptr, sym_link * type)
367 /* find the first pointer type */
368 while (ptr && !IS_PTR (ptr))
371 /* could not find it */
372 if (!ptr || IS_SPEC (ptr))
375 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
376 pointerTypes (ptr->next, type);
380 /* change the pointer type depending on the
381 storage class of the type */
384 switch (SPEC_SCLS (type))
387 DCL_TYPE (ptr) = FPOINTER;
390 DCL_TYPE (ptr) = IPOINTER;
393 DCL_TYPE (ptr) = PPOINTER;
396 DCL_TYPE (ptr) = POINTER;
399 DCL_TYPE (ptr) = CPOINTER;
402 DCL_TYPE (ptr) = EEPPOINTER;
405 DCL_TYPE (ptr) = port->unqualified_pointer;
408 /* the storage class of type ends here */
409 SPEC_SCLS (type) = 0;
412 /* now change all the remaining unknown pointers
413 to generic pointers */
416 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
417 DCL_TYPE (ptr) = port->unqualified_pointer;
421 /* same for the type although it is highly unlikely that
422 type will have a pointer */
425 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
426 DCL_TYPE (type) = port->unqualified_pointer;
431 /*------------------------------------------------------------------*/
432 /* addDecl - adds a declarator @ the end of a chain */
433 /*------------------------------------------------------------------*/
435 addDecl (symbol * sym, int type, sym_link * p)
441 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
442 fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
444 /* if we are passed a link then set head & tail */
453 head = tail = newLink (DECLARATOR);
454 DCL_TYPE (head) = type;
457 /* if this is the first entry */
465 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
467 sym->etype = mergeSpec (sym->etype, head, sym->name);
471 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
474 while (t->next != sym->etype)
477 tail->next = sym->etype;
481 sym->etype->next = head;
487 /* if the type is an unknown pointer and has
488 a tspec then take the storage class const & volatile
489 attribute from the tspec & make it those of this
493 //DCL_TYPE (p) == UPOINTER &&
496 if (!IS_SPEC (sym->etype))
498 sym->etype = sym->etype->next = newLink (SPECIFIER);
500 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
501 DCL_TSPEC (p) = NULL;
504 // if there is a function in this type chain
505 if (p && funcInChain(sym->type)) {
506 processFuncArgs (sym);
512 /*------------------------------------------------------------------
513 checkTypeSanity: prevent the user from doing e.g.:
515 ------------------------------------------------------------------*/
516 void checkTypeSanity(sym_link *etype, char *name) {
520 if (getenv("DEBUG_SANITY")) {
521 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
526 if (!IS_SPEC(etype)) {
527 if (getenv("DEBUG_SANITY")) {
528 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
533 noun=nounName(etype);
535 if (getenv("DEBUG_SANITY")) {
536 fprintf (stderr, "checking sanity for %s %p\n", name, etype);
539 if ((SPEC_NOUN(etype)==V_CHAR ||
540 SPEC_NOUN(etype)==V_FLOAT ||
541 SPEC_NOUN(etype)==V_DOUBLE ||
542 SPEC_NOUN(etype)==V_VOID) &&
543 (etype->select.s._short || SPEC_LONG(etype))) {
544 // long or short for char float double or void
545 werror (E_LONG_OR_SHORT_INVALID, noun, name);
547 if ((SPEC_NOUN(etype)==V_FLOAT ||
548 SPEC_NOUN(etype)==V_DOUBLE ||
549 SPEC_NOUN(etype)==V_VOID) &&
550 (etype->select.s._signed || SPEC_USIGN(etype))) {
551 // signed or unsigned for float double or void
552 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
555 // special case for "short"
556 if (etype->select.s._short) {
557 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
558 etype->select.s._short = 0;
562 "const a;" or "data b;" or "signed s" or "long l"
564 if (!SPEC_NOUN(etype)) {
565 SPEC_NOUN(etype)=V_INT;
568 if (etype->select.s._signed && SPEC_USIGN(etype)) {
569 // signed AND unsigned
570 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
572 if (etype->select.s._short && SPEC_LONG(etype)) {
574 werror (E_LONG_AND_SHORT_INVALID, noun, name);
579 /*------------------------------------------------------------------*/
580 /* mergeSpec - merges two specifiers and returns the new one */
581 /*------------------------------------------------------------------*/
583 mergeSpec (sym_link * dest, sym_link * src, char *name)
585 if (!IS_SPEC(dest) || !IS_SPEC(src)) {
587 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
590 werror (E_SYNTAX_ERROR, yytext);
591 // the show must go on
596 if (SPEC_NOUN(src)) {
597 if (!SPEC_NOUN(dest)) {
598 SPEC_NOUN(dest)=SPEC_NOUN(src);
600 /* we shouldn't redeclare the type */
601 if (getenv("DEBUG_SANITY")) {
602 fprintf (stderr, "mergeSpec: ");
604 werror(E_TWO_OR_MORE_DATA_TYPES, name);
608 if (SPEC_SCLS(src)) {
609 /* if destination has no storage class */
610 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
611 SPEC_SCLS (dest) = SPEC_SCLS (src);
613 if (getenv("DEBUG_SANITY")) {
614 fprintf (stderr, "mergeSpec: ");
616 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
620 /* copy all the specifications */
622 // we really should do:
624 if (SPEC_what(src)) {
625 if (SPEC_what(dest)) {
626 werror(W_DUPLICATE_SPEC, "what");
628 SPEC_what(dst)|=SPEC_what(src);
631 // but there are more important thing right now
633 SPEC_LONG (dest) |= SPEC_LONG (src);
634 dest->select.s._short|=src->select.s._short;
635 SPEC_USIGN (dest) |= SPEC_USIGN (src);
636 dest->select.s._signed|=src->select.s._signed;
637 SPEC_STAT (dest) |= SPEC_STAT (src);
638 SPEC_EXTR (dest) |= SPEC_EXTR (src);
639 SPEC_CONST(dest) |= SPEC_CONST (src);
640 SPEC_ABSA (dest) |= SPEC_ABSA (src);
641 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
642 SPEC_ADDR (dest) |= SPEC_ADDR (src);
643 SPEC_OCLS (dest) = SPEC_OCLS (src);
644 SPEC_BLEN (dest) |= SPEC_BLEN (src);
645 SPEC_BSTR (dest) |= SPEC_BSTR (src);
646 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
647 SPEC_ENUM (dest) |= SPEC_ENUM (src);
648 if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
649 SPEC_ARGREG(dest) = SPEC_ARGREG(src);
651 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
652 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
654 /* these are the only function attributes that will be set
655 in a specifier while parsing */
656 FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
657 FUNC_BANKED(dest) |= FUNC_BANKED(src);
658 FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
659 FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
660 FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
661 FUNC_ISISR(dest) |= FUNC_ISISR(src);
662 FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
663 FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
664 FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
665 FUNC_INTNO(dest) |= FUNC_INTNO(src);
666 FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
671 /*------------------------------------------------------------------*/
672 /* genSymName - generates and returns a name used for anonymous vars */
673 /*------------------------------------------------------------------*/
675 genSymName (int level)
677 static int gCount = 0;
678 static char gname[SDCC_NAME_MAX + 1];
680 SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
684 /*------------------------------------------------------------------*/
685 /* getSpec - returns the specifier part from a declaration chain */
686 /*------------------------------------------------------------------*/
688 getSpec (sym_link * p)
693 while (p && !(IS_SPEC (p)))
699 /*------------------------------------------------------------------*/
700 /* newCharLink() - creates an char type */
701 /*------------------------------------------------------------------*/
707 p = newLink (SPECIFIER);
708 SPEC_NOUN (p) = V_CHAR;
713 /*------------------------------------------------------------------*/
714 /* newFloatLink - a new Float type */
715 /*------------------------------------------------------------------*/
721 p = newLink (SPECIFIER);
722 SPEC_NOUN (p) = V_FLOAT;
727 /*------------------------------------------------------------------*/
728 /* newLongLink() - new long type */
729 /*------------------------------------------------------------------*/
735 p = newLink (SPECIFIER);
736 SPEC_NOUN (p) = V_INT;
742 /*------------------------------------------------------------------*/
743 /* newIntLink() - creates an int type */
744 /*------------------------------------------------------------------*/
750 p = newLink (SPECIFIER);
751 SPEC_NOUN (p) = V_INT;
756 /*------------------------------------------------------------------*/
757 /* getSize - returns size of a type chain in bits */
758 /*------------------------------------------------------------------*/
760 getSize (sym_link * p)
762 /* if nothing return 0 */
766 { /* if this is the specifier then */
767 switch (SPEC_NOUN (p))
768 { /* depending on the specifier type */
770 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
778 return SPEC_STRUCT (p)->size;
785 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
791 /* this is a specifier */
792 switch (DCL_TYPE (p))
796 return DCL_ELEM (p) * getSize (p->next);
798 // werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
799 // "can not tell the size of an array[]");
819 /*------------------------------------------------------------------*/
820 /* bitsForType - returns # of bits required to store this type */
821 /*------------------------------------------------------------------*/
823 bitsForType (sym_link * p)
825 /* if nothing return 0 */
830 { /* if this is the specifier then */
832 switch (SPEC_NOUN (p))
833 { /* depending on the specifier type */
835 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
837 return FLOATSIZE * 8;
843 return SPEC_STRUCT (p)->size * 8;
850 return SPEC_BLEN (p);
856 /* this is a specifier */
857 switch (DCL_TYPE (p))
860 return DCL_ELEM (p) * getSize (p->next) * 8;
864 return (PTRSIZE * 8);
869 return (FPTRSIZE * 8);
871 return (GPTRSIZE * 8);
878 /*------------------------------------------------------------------*/
879 /* copySymbolChain - copies a symbol chain */
880 /*------------------------------------------------------------------*/
882 copySymbolChain (symbol * src)
889 dest = copySymbol (src);
890 dest->next = copySymbolChain (src->next);
894 /*------------------------------------------------------------------*/
895 /* copySymbol - makes a copy of a symbol */
896 /*------------------------------------------------------------------*/
898 copySymbol (symbol * src)
905 dest = newSymbol (src->name, src->level);
906 memcpy (dest, src, sizeof (symbol));
907 dest->level = src->level;
908 dest->block = src->block;
909 dest->ival = copyIlist (src->ival);
910 dest->type = copyLinkChain (src->type);
911 dest->etype = getSpec (dest->type);
913 dest->key = src->key;
914 dest->allocreq = src->allocreq;
918 /*------------------------------------------------------------------*/
919 /* reverseSyms - reverses the links for a symbol chain */
920 /*------------------------------------------------------------------*/
922 reverseSyms (symbol * sym)
924 symbol *prev, *curr, *next;
939 sym->next = (void *) NULL;
943 /*------------------------------------------------------------------*/
944 /* reverseLink - reverses the links for a type chain */
945 /*------------------------------------------------------------------*/
947 reverseLink (sym_link * type)
949 sym_link *prev, *curr, *next;
964 type->next = (void *) NULL;
968 /*------------------------------------------------------------------*/
969 /* addSymChain - adds a symbol chain to the symboltable */
970 /*------------------------------------------------------------------*/
972 addSymChain (symbol * symHead)
974 symbol *sym = symHead;
978 for (; sym != NULL; sym = sym->next)
981 checkTypeSanity(sym->etype, sym->name);
983 if (!sym->level && !(IS_SPEC(sym->etype) && IS_TYPEDEF(sym->etype)))
986 /* if already exists in the symbol table then check if
987 one of them is an extern definition if yes then
988 then check if the type match, if the types match then
989 delete the current entry and add the new entry */
990 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
991 csym->level == sym->level) {
993 /* If the previous definition was for an array with incomplete */
994 /* type, and the new definition has completed the type, update */
995 /* the original type to match */
996 if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY
997 && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY)
999 if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type))
1000 DCL_ELEM(csym->type) = DCL_ELEM(sym->type);
1004 /* If only one of the definitions used the "at" keyword, copy */
1005 /* the address to the other. */
1006 if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype)
1007 && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype))
1009 SPEC_ABSA (sym->etype) = 1;
1010 SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype);
1012 if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype)
1013 && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype))
1015 SPEC_ABSA (csym->etype) = 1;
1016 SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype);
1021 if (csym->ival && sym->ival)
1023 if (compareTypeExact (csym->type, sym->type, sym->level) != 1)
1027 /* one definition extern ? */
1028 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype))
1029 werror (E_EXTERN_MISMATCH, sym->name);
1031 werror (E_DUPLICATE, sym->name);
1032 fprintf (stderr, "from type '");
1033 printTypeChain (csym->type, stderr);
1034 if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype))
1035 fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype));
1036 fprintf (stderr, "'\nto type '");
1037 printTypeChain (sym->type, stderr);
1038 if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype))
1039 fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype));
1040 fprintf (stderr, "'\n");
1044 if (csym->ival && !sym->ival)
1045 sym->ival = csym->ival;
1047 /* delete current entry */
1048 deleteSym (SymbolTab, csym, csym->name);
1049 deleteFromSeg(csym);
1053 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1058 /*------------------------------------------------------------------*/
1059 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
1060 /*------------------------------------------------------------------*/
1062 funcInChain (sym_link * lnk)
1073 /*------------------------------------------------------------------*/
1074 /* structElemType - returns the type info of a struct member */
1075 /*------------------------------------------------------------------*/
1077 structElemType (sym_link * stype, value * id)
1079 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1080 sym_link *type, *etype;
1081 sym_link *petype = getSpec (stype);
1085 /* look for the id */
1088 if (strcmp (fields->rname, id->name) == 0)
1090 type = copyLinkChain (fields->type);
1091 etype = getSpec (type);
1092 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1093 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1095 SPEC_CONST (type) |= SPEC_CONST (stype);
1097 DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1100 fields = fields->next;
1104 werror (E_NOT_MEMBER, id->name);
1106 // the show must go on
1107 return newIntLink();
1110 /*------------------------------------------------------------------*/
1111 /* getStructElement - returns element of a tructure definition */
1112 /*------------------------------------------------------------------*/
1114 getStructElement (structdef * sdef, symbol * sym)
1118 for (field = sdef->fields; field; field = field->next)
1119 if (strcmp (field->name, sym->name) == 0)
1122 werror (E_NOT_MEMBER, sym->name);
1124 return sdef->fields;
1127 /*------------------------------------------------------------------*/
1128 /* compStructSize - computes the size of a structure */
1129 /*------------------------------------------------------------------*/
1131 compStructSize (int su, structdef * sdef)
1133 int sum = 0, usum = 0;
1137 /* for the identifiers */
1138 loop = sdef->fields;
1141 /* create the internal name for this variable */
1142 SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1147 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1149 /* if this is a bit field */
1152 /* change it to a unsigned bit */
1153 SPEC_NOUN (loop->etype) = V_BITFIELD;
1154 SPEC_USIGN (loop->etype) = 1;
1155 SPEC_BLEN (loop->etype) = loop->bitVar;
1157 if (loop->bitVar == BITVAR_PAD) {
1158 /* A zero length bitfield forces padding */
1159 SPEC_BSTR (loop->etype) = bitOffset;
1160 SPEC_BLEN (loop->etype) = 0;
1165 if (bitOffset == 8) {
1169 /* check if this fit into the remaining */
1170 /* bits of this byte else align it to the */
1171 /* next byte boundary */
1172 if (loop->bitVar <= (8 - bitOffset)) {
1173 /* fits into current byte */
1175 SPEC_BSTR (loop->etype) = bitOffset;
1176 bitOffset += loop->bitVar;
1178 else if (!bitOffset) {
1179 /* does not fit, but is already byte aligned */
1181 SPEC_BSTR (loop->etype) = bitOffset;
1182 bitOffset += loop->bitVar;
1185 /* does not fit; need to realign first */
1187 loop->offset = (su == UNION ? sum = 0 : sum);
1189 SPEC_BSTR (loop->etype) = bitOffset;
1190 bitOffset += loop->bitVar;
1192 while (bitOffset>8) {
1199 /* This is a non-bit field. Make sure we are */
1200 /* byte aligned first */
1203 loop->offset = (su == UNION ? sum = 0 : sum);
1207 checkDecl (loop, 1);
1208 sum += getSize (loop->type);
1213 /* if union then size = sizeof larget field */
1215 /* For UNION, round up after each field */
1216 sum += ((bitOffset+7)/8);
1217 usum = max (usum, sum);
1222 /* For STRUCT, round up after all fields processed */
1224 sum += ((bitOffset+7)/8);
1226 return (su == UNION ? usum : sum);
1229 /*------------------------------------------------------------------*/
1230 /* checkSClass - check the storage class specification */
1231 /*------------------------------------------------------------------*/
1233 checkSClass (symbol * sym, int isProto)
1237 if (getenv("DEBUG_SANITY")) {
1238 fprintf (stderr, "checkSClass: %s \n", sym->name);
1241 /* type is literal can happen for enums change
1243 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1244 SPEC_SCLS (sym->etype) = S_AUTO;
1246 /* if sfr or sbit then must also be volatile */
1247 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1248 SPEC_SCLS (sym->etype) == S_SFR)
1250 SPEC_VOLATILE (sym->etype) = 1;
1253 /* if absolute address given then it mark it as
1254 volatile -- except in the PIC port */
1256 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1257 /* The PIC port uses a different peep hole optimizer based on "pCode" */
1258 if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1261 if (IS_ABSOLUTE (sym->etype))
1262 SPEC_VOLATILE (sym->etype) = 1;
1264 /* If code memory is read only, then pointers to code memory */
1265 /* implicitly point to constants -- make this explicit */
1267 while (t && t->next) {
1268 if (IS_CODEPTR(t) && port->mem.code_ro) {
1269 if (IS_SPEC(t->next)) {
1270 SPEC_CONST (t->next) = 1;
1272 DCL_PTR_CONST (t->next) = 1;
1278 /* global variables declared const put into code */
1279 /* if no other storage class specified */
1280 if (sym->level == 0 &&
1281 SPEC_SCLS(sym->etype) == S_FIXED &&
1282 !IS_FUNC(sym->type)) {
1283 /* find the first non-array link */
1287 if (IS_CONSTANT (t)) {
1288 SPEC_SCLS (sym->etype) = S_CODE;
1292 /* global variable in code space is a constant */
1293 if (sym->level == 0 &&
1294 SPEC_SCLS (sym->etype) == S_CODE &&
1295 port->mem.code_ro) {
1296 /* find the first non-array link */
1303 DCL_PTR_CONST (t) = 1;
1307 /* if bit variable then no storage class can be */
1308 /* specified since bit is already a storage */
1309 if (IS_BITVAR (sym->etype) &&
1310 (SPEC_SCLS (sym->etype) != S_FIXED &&
1311 SPEC_SCLS (sym->etype) != S_SBIT &&
1312 SPEC_SCLS (sym->etype) != S_BIT)
1315 werror (E_BITVAR_STORAGE, sym->name);
1316 SPEC_SCLS (sym->etype) = S_FIXED;
1319 /* extern variables cannot be initialized */
1320 if (IS_EXTERN (sym->etype) && sym->ival)
1322 werror (E_EXTERN_INIT, sym->name);
1326 /* if this is an automatic symbol */
1327 if (sym->level && (options.stackAuto || reentrant)) {
1328 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1329 SPEC_SCLS (sym->etype) == S_FIXED ||
1330 SPEC_SCLS (sym->etype) == S_REGISTER ||
1331 SPEC_SCLS (sym->etype) == S_STACK ||
1332 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1333 SPEC_SCLS (sym->etype) = S_AUTO;
1335 /* storage class may only be specified for statics */
1336 if (!IS_STATIC(sym->etype)) {
1337 werror (E_AUTO_ASSUMED, sym->name);
1342 /* automatic symbols cannot be given */
1343 /* an absolute address ignore it */
1345 SPEC_ABSA (sym->etype) &&
1346 (options.stackAuto || reentrant))
1348 werror (E_AUTO_ABSA, sym->name);
1349 SPEC_ABSA (sym->etype) = 0;
1352 /* arrays & pointers cannot be defined for bits */
1353 /* SBITS or SFRs or BIT */
1354 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1355 (SPEC_NOUN (sym->etype) == V_BIT ||
1356 SPEC_NOUN (sym->etype) == V_SBIT ||
1357 SPEC_NOUN (sym->etype) == V_BITFIELD ||
1358 SPEC_SCLS (sym->etype) == S_SFR))
1359 werror (E_BIT_ARRAY, sym->name);
1361 /* if this is a bit|sbit then set length & start */
1362 if (SPEC_NOUN (sym->etype) == V_BIT ||
1363 SPEC_NOUN (sym->etype) == V_SBIT)
1365 SPEC_BLEN (sym->etype) = 1;
1366 SPEC_BSTR (sym->etype) = 0;
1370 /* variables declared in CODE space must have */
1371 /* initializers if not an extern */
1372 if (SPEC_SCLS (sym->etype) == S_CODE &&
1373 sym->ival == NULL &&
1375 port->mem.code_ro &&
1376 !IS_EXTERN (sym->etype) &&
1377 !funcInChain (sym->type))
1378 werror (E_CODE_NO_INIT, sym->name);
1381 /* if parameter or local variable then change */
1382 /* the storage class to reflect where the var will go */
1383 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1384 !IS_STATIC(sym->etype))
1386 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1388 SPEC_SCLS (sym->etype) = (options.useXstack ?
1389 S_XSTACK : S_STACK);
1393 /* hack-o-matic! I see no reason why the useXstack option should ever
1394 * control this allcoation, but the code was originally that way, and
1395 * changing it for non-390 ports breaks the compiler badly.
1397 bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1398 1 : options.useXstack;
1399 SPEC_SCLS (sym->etype) = (useXdata ?
1405 /*------------------------------------------------------------------*/
1406 /* changePointer - change pointer to functions */
1407 /*------------------------------------------------------------------*/
1409 changePointer (symbol * sym)
1413 /* go thru the chain of declarations */
1414 /* if we find a pointer to a function */
1415 /* unconditionally change it to a ptr */
1417 for (p = sym->type; p; p = p->next)
1419 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1420 DCL_TYPE (p) = port->unqualified_pointer;
1421 if (IS_PTR (p) && IS_FUNC (p->next))
1422 DCL_TYPE (p) = CPOINTER;
1426 /*------------------------------------------------------------------*/
1427 /* checkDecl - does semantic validation of a declaration */
1428 /*------------------------------------------------------------------*/
1430 checkDecl (symbol * sym, int isProto)
1433 checkSClass (sym, isProto); /* check the storage class */
1434 changePointer (sym); /* change pointers if required */
1436 /* if this is an array without any dimension
1437 then update the dimension from the initial value */
1438 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1439 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1444 /*------------------------------------------------------------------*/
1445 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1446 /*------------------------------------------------------------------*/
1448 copyLinkChain (sym_link * p)
1450 sym_link *head, *curr, *loop;
1453 head = loop = (curr ? newLink (p->class) : (void *) NULL);
1456 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1457 loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1466 /*------------------------------------------------------------------*/
1467 /* cleanUpBlock - cleansup the symbol table specified for all the */
1468 /* symbols in the given block */
1469 /*------------------------------------------------------------------*/
1471 cleanUpBlock (bucket ** table, int block)
1476 /* go thru the entire table */
1477 for (i = 0; i < 256; i++)
1479 for (chain = table[i]; chain; chain = chain->next)
1481 if (chain->block >= block)
1483 deleteSym (table, chain->sym, chain->name);
1489 /*------------------------------------------------------------------*/
1490 /* cleanUpLevel - cleansup the symbol table specified for all the */
1491 /* symbols in the given level */
1492 /*------------------------------------------------------------------*/
1494 cleanUpLevel (bucket ** table, int level)
1499 /* go thru the entire table */
1500 for (i = 0; i < 256; i++)
1502 for (chain = table[i]; chain; chain = chain->next)
1504 if (chain->level >= level)
1506 deleteSym (table, chain->sym, chain->name);
1512 /*------------------------------------------------------------------*/
1513 /* computeType - computes the resultant type from two types */
1514 /*------------------------------------------------------------------*/
1516 computeType (sym_link * type1, sym_link * type2, bool promoteCharToInt)
1520 sym_link *etype1 = getSpec (type1);
1521 sym_link *etype2 = getSpec (type2);
1523 /* if one of them is a float then result is a float */
1524 /* here we assume that the types passed are okay */
1525 /* and can be cast to one another */
1526 /* which ever is greater in size */
1527 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1528 rType = newFloatLink ();
1530 /* if only one of them is a bit variable
1531 then the other one prevails */
1532 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1533 rType = copyLinkChain (type2);
1534 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1535 rType = copyLinkChain (type1);
1537 /* if one of them is a pointer or array then that
1539 if (IS_PTR (type1) || IS_ARRAY (type1))
1540 rType = copyLinkChain (type1);
1541 else if (IS_PTR (type2) || IS_ARRAY (type2))
1542 rType = copyLinkChain (type2);
1543 else if (getSize (type1) > getSize (type2))
1544 rType = copyLinkChain (type1);
1546 rType = copyLinkChain (type2);
1548 reType = getSpec (rType);
1550 /* avoid conflicting types */
1551 reType->select.s._signed = 0;
1553 if (IS_CHAR (reType) && promoteCharToInt)
1554 SPEC_NOUN (reType) = V_INT;
1556 if ( ( ( SPEC_USIGN (etype1)
1557 && (getSize (etype1) >= getSize (reType)))
1558 || ( SPEC_USIGN (etype2)
1559 && (getSize (etype2) >= getSize (reType))))
1560 && !IS_FLOAT (reType))
1561 SPEC_USIGN (reType) = 1;
1563 SPEC_USIGN (reType) = 0;
1565 /* if result is a literal then make not so */
1566 if (IS_LITERAL (reType))
1567 SPEC_SCLS (reType) = S_REGISTER;
1572 /*--------------------------------------------------------------------*/
1573 /* compareType - will do type check return 1 if match, -1 if castable */
1574 /*--------------------------------------------------------------------*/
1576 compareType (sym_link * dest, sym_link * src)
1587 /* if dest is a declarator then */
1592 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1594 //checkFunction(src,dest);
1596 return compareType (dest->next, src->next);
1598 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1601 if (IS_PTR (src) && IS_GENPTR (dest))
1603 if (IS_PTR (dest) && IS_ARRAY (src)) {
1604 value *val=aggregateToPointer (valFromType(src));
1605 int res=compareType (dest, val->type);
1606 Safe_free(val->type);
1610 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1611 return compareType (dest->next, src);
1614 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1620 /* if one is a specifier and the other is not */
1621 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1622 (IS_SPEC (dest) && !IS_SPEC (src)))
1625 /* if one of them is a void then ok */
1626 if (SPEC_NOUN (dest) == V_VOID &&
1627 SPEC_NOUN (src) != V_VOID)
1630 if (SPEC_NOUN (dest) != V_VOID &&
1631 SPEC_NOUN (src) == V_VOID)
1634 /* if they are both bitfields then if the lengths
1635 and starts don't match */
1636 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1637 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1638 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1641 /* it is a specifier */
1642 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1644 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1645 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1646 getSize (dest) == getSize (src))
1648 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1653 else if (IS_STRUCT (dest))
1655 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1660 if (SPEC_LONG (dest) != SPEC_LONG (src))
1663 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1669 /*--------------------------------------------------------------------*/
1670 /* compareTypeExact - will do type check return 1 if match exactly */
1671 /*--------------------------------------------------------------------*/
1673 compareTypeExact (sym_link * dest, sym_link * src, int level)
1675 STORAGE_CLASS srcScls, destScls;
1686 /* if dest is a declarator then */
1691 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1692 if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
1694 if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
1696 if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
1700 value *exargs, *acargs, *checkValue;
1702 /* verify function return type */
1703 if (!compareTypeExact (dest->next, src->next, -1))
1705 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
1707 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
1709 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
1712 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
1716 /* compare expected args with actual args */
1717 exargs = FUNC_ARGS(dest);
1718 acargs = FUNC_ARGS(src);
1720 /* for all the expected args do */
1721 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
1723 //checkTypeSanity(acargs->etype, acargs->name);
1725 if (IS_AGGREGATE (acargs->type))
1727 checkValue = copyValue (acargs);
1728 aggregateToPointer (checkValue);
1731 checkValue = acargs;
1734 if (!compareTypeExact (exargs->type, checkValue->type, -1))
1739 /* if one them ended we have a problem */
1740 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1741 (!exargs && acargs && !IS_VOID (acargs->type)))
1745 return compareTypeExact (dest->next, src->next, level);
1752 /* if one is a specifier and the other is not */
1753 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1754 (IS_SPEC (dest) && !IS_SPEC (src)))
1757 /* if one of them is a void then ok */
1758 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1761 /* if they are both bitfields then if the lengths
1762 and starts don't match */
1763 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1764 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1765 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1768 if (IS_INTEGRAL (dest))
1770 /* signedness must match */
1771 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1773 /* size must match */
1774 if (SPEC_LONG (dest) != SPEC_LONG (src))
1776 if (SPEC_SHORT (dest) != SPEC_SHORT (src))
1780 if (IS_STRUCT (dest))
1782 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1786 if (SPEC_CONST (dest) != SPEC_CONST (src))
1788 if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
1790 if (SPEC_STAT (dest) != SPEC_STAT (src))
1792 if (SPEC_ABSA (dest) != SPEC_ABSA (src))
1794 if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
1797 destScls = SPEC_SCLS (dest);
1798 srcScls = SPEC_SCLS (src);
1800 /* Compensate for const to const code change in checkSClass() */
1801 if (!level & port->mem.code_ro && SPEC_CONST (dest))
1803 if (srcScls == S_CODE && destScls == S_FIXED)
1805 if (destScls == S_CODE && srcScls == S_FIXED)
1809 /* compensate for allocGlobal() */
1810 if ((srcScls == S_FIXED || srcScls == S_AUTO)
1811 && port->mem.default_globl_map == xdata
1815 if (level>0 && !SPEC_STAT (dest))
1817 /* Compensate for hack-o-matic in checkSClass() */
1818 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1820 if (destScls == S_FIXED)
1821 destScls = (options.useXstack ? S_XSTACK : S_STACK);
1822 if (srcScls == S_FIXED)
1823 srcScls = (options.useXstack ? S_XSTACK : S_STACK);
1825 else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
1827 if (destScls == S_FIXED)
1829 if (srcScls == S_FIXED)
1834 if (srcScls != destScls)
1837 printf ("level = %d\n", level);
1838 printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
1839 SPEC_SCLS (src), SPEC_SCLS (dest));
1840 printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
1848 /*------------------------------------------------------------------*/
1849 /* inCalleeSaveList - return 1 if found in callee save list */
1850 /*------------------------------------------------------------------*/
1852 calleeCmp(void *p1, void *p2)
1854 return (strcmp((char *)p1, (char *)(p2)) == 0);
1858 inCalleeSaveList(char *s)
1860 if (options.all_callee_saves)
1862 return isinSetWith(options.calleeSavesSet, s, calleeCmp);
1865 /*-----------------------------------------------------------------*/
1866 /* aggregateToPointer: change an agggregate type function */
1867 /* argument to a pointer to that type. */
1868 /*-----------------------------------------------------------------*/
1870 aggregateToPointer (value * val)
1872 if (IS_AGGREGATE (val->type))
1874 /* if this is a structure */
1875 /* then we need to add a new link */
1876 if (IS_STRUCT (val->type))
1878 /* first lets add DECLARATOR type */
1879 sym_link *p = val->type;
1881 werror (W_STRUCT_AS_ARG, val->name);
1882 val->type = newLink (DECLARATOR);
1883 val->type->next = p;
1886 /* change to a pointer depending on the */
1887 /* storage class specified */
1888 switch (SPEC_SCLS (val->etype))
1891 DCL_TYPE (val->type) = IPOINTER;
1894 DCL_TYPE (val->type) = PPOINTER;
1897 if (SPEC_OCLS(val->etype)) {
1898 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1900 // this happens for (external) function parameters
1901 DCL_TYPE (val->type) = port->unqualified_pointer;
1907 DCL_TYPE (val->type) = POINTER;
1910 DCL_TYPE (val->type) = CPOINTER;
1913 DCL_TYPE (val->type) = FPOINTER;
1916 DCL_TYPE (val->type) = EEPPOINTER;
1919 DCL_TYPE (val->type) = port->unqualified_pointer;
1922 /* is there is a symbol associated then */
1923 /* change the type of the symbol as well */
1926 val->sym->type = copyLinkChain (val->type);
1927 val->sym->etype = getSpec (val->sym->type);
1932 /*------------------------------------------------------------------*/
1933 /* checkFunction - does all kinds of check on a function */
1934 /*------------------------------------------------------------------*/
1936 checkFunction (symbol * sym, symbol *csym)
1938 value *exargs, *acargs;
1942 if (getenv("DEBUG_SANITY")) {
1943 fprintf (stderr, "checkFunction: %s ", sym->name);
1946 if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
1948 werror(E_SYNTAX_ERROR, sym->name);
1952 /* make sure the type is complete and sane */
1953 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1955 /* if not type then some kind of error */
1959 /* if the function has no type then make it return int */
1960 if (!sym->type->next)
1961 sym->type->next = sym->etype = newIntLink ();
1963 /* function cannot return aggregate */
1964 if (IS_AGGREGATE (sym->type->next))
1966 werror (E_FUNC_AGGR, sym->name);
1970 /* function cannot return bit */
1971 if (IS_BITVAR (sym->type->next))
1973 werror (E_FUNC_BIT, sym->name);
1977 /* check if this function is defined as calleeSaves
1978 then mark it as such */
1979 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1981 /* if interrupt service routine */
1982 /* then it cannot have arguments */
1983 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1985 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1986 werror (E_INT_ARGS, sym->name);
1987 FUNC_ARGS(sym->type)=NULL;
1991 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
1993 acargs=acargs->next, argCnt++) {
1995 // this can happen for reentrant functions
1996 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1997 // the show must go on: synthesize a name and symbol
1998 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
1999 acargs->sym = newSymbol (acargs->name, 1);
2000 SPEC_OCLS (acargs->etype) = istack;
2001 acargs->sym->type = copyLinkChain (acargs->type);
2002 acargs->sym->etype = getSpec (acargs->sym->type);
2003 acargs->sym->_isparm = 1;
2004 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2005 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2007 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2012 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2013 return 1; /* not defined nothing more to check */
2015 /* check if body already present */
2016 if (csym && IFFUNC_HASBODY(csym->type))
2018 werror (E_FUNC_BODY, sym->name);
2022 /* check the return value type */
2023 if (compareType (csym->type, sym->type) <= 0)
2025 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2026 printFromToType(csym->type, sym->type);
2030 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2032 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2035 if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
2037 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2040 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2042 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2045 /* Really, reentrant should match regardless of argCnt, but */
2046 /* this breaks some existing code (the fp lib functions). If */
2047 /* the first argument is always passed the same way, this */
2048 /* lax checking is ok (but may not be true for in future ports) */
2049 if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2052 //printf("argCnt = %d\n",argCnt);
2053 werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2056 /* compare expected args with actual args */
2057 exargs = FUNC_ARGS(csym->type);
2058 acargs = FUNC_ARGS(sym->type);
2060 /* for all the expected args do */
2063 exargs = exargs->next, acargs = acargs->next, argCnt++)
2065 if (getenv("DEBUG_SANITY")) {
2066 fprintf (stderr, "checkFunction: %s ", exargs->name);
2068 /* make sure the type is complete and sane */
2069 checkTypeSanity(exargs->etype, exargs->name);
2071 /* If the actual argument is an array, any prototype
2072 * will have modified it to a pointer. Duplicate that
2075 if (IS_AGGREGATE (acargs->type))
2077 checkValue = copyValue (acargs);
2078 aggregateToPointer (checkValue);
2082 checkValue = acargs;
2085 if (compareType (exargs->type, checkValue->type) <= 0)
2087 werror (E_ARG_TYPE, argCnt);
2088 printFromToType(exargs->type, checkValue->type);
2093 /* if one them ended we have a problem */
2094 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2095 (!exargs && acargs && !IS_VOID (acargs->type)))
2096 werror (E_ARG_COUNT);
2098 /* replace with this defition */
2099 sym->cdef = csym->cdef;
2100 deleteSym (SymbolTab, csym, csym->name);
2101 deleteFromSeg(csym);
2102 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2103 if (IS_EXTERN (csym->etype) && !
2104 IS_EXTERN (sym->etype))
2106 addSet (&publics, sym);
2111 /*------------------------------------------------------------------*/
2112 /* cdbStructBlock - calls struct printing for a blcks */
2113 /*------------------------------------------------------------------*/
2114 void cdbStructBlock (int block)
2117 bucket **table = StructTab;
2120 /* go thru the entire table */
2121 for (i = 0; i < 256; i++)
2123 for (chain = table[i]; chain; chain = chain->next)
2125 if (chain->block >= block)
2128 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2134 /*-----------------------------------------------------------------*/
2135 /* processFuncArgs - does some processing with function args */
2136 /*-----------------------------------------------------------------*/
2138 processFuncArgs (symbol * func)
2142 sym_link *funcType=func->type;
2144 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2145 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2147 // if this is a pointer to a function
2148 if (IS_PTR(funcType)) {
2149 funcType=funcType->next;
2152 /* if this function has variable argument list */
2153 /* then make the function a reentrant one */
2154 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2155 FUNC_ISREENT(funcType)=1;
2157 /* check if this function is defined as calleeSaves
2158 then mark it as such */
2159 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2161 /* loop thru all the arguments */
2162 val = FUNC_ARGS(funcType);
2164 /* if it is void then remove parameters */
2165 if (val && IS_VOID (val->type))
2167 FUNC_ARGS(funcType) = NULL;
2171 /* reset regparm for the port */
2172 (*port->reset_regparms) ();
2173 /* if any of the arguments is an aggregate */
2174 /* change it to pointer to the same type */
2178 /* mark it as a register parameter if
2179 the function does not have VA_ARG
2180 and as port dictates */
2181 if (!IFFUNC_HASVARARGS(funcType) &&
2182 (argreg = (*port->reg_parm) (val->type)))
2184 SPEC_REGPARM (val->etype) = 1;
2185 SPEC_ARGREG(val->etype) = argreg;
2186 } else if (IFFUNC_ISREENT(funcType)) {
2187 FUNC_HASSTACKPARM(funcType) = 1;
2190 if (IS_AGGREGATE (val->type))
2192 aggregateToPointer (val);
2199 /* if this is an internal generated function call */
2201 /* ignore --stack-auto for this one, we don't know how it is compiled */
2202 /* simply trust on --int-long-reent or --float-reent */
2203 if (IFFUNC_ISREENT(funcType)) {
2207 /* if this function is reentrant or */
2208 /* automatics r 2b stacked then nothing */
2209 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2213 val = FUNC_ARGS(funcType);
2218 /* if a symbolname is not given */
2219 /* synthesize a variable name */
2222 SNPRINTF (val->name, sizeof(val->name),
2223 "_%s_PARM_%d", func->name, pNum++);
2224 val->sym = newSymbol (val->name, 1);
2225 SPEC_OCLS (val->etype) = port->mem.default_local_map;
2226 val->sym->type = copyLinkChain (val->type);
2227 val->sym->etype = getSpec (val->sym->type);
2228 val->sym->_isparm = 1;
2229 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2230 if (IS_SPEC(func->etype)) {
2231 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2232 SPEC_STAT (func->etype);
2234 addSymChain (val->sym);
2237 else /* symbol name given create synth name */
2240 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2241 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2242 val->sym->_isparm = 1;
2243 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2244 (options.model != MODEL_SMALL ? xdata : data);
2245 if (IS_SPEC(func->etype)) {
2246 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2247 SPEC_STAT (func->etype);
2250 if (!isinSet(operKeyReset, val->sym)) {
2251 addSet (&operKeyReset, val->sym);
2252 applyToSet (operKeyReset, resetParmKey);
2258 /*-----------------------------------------------------------------*/
2259 /* isSymbolEqual - compares two symbols return 1 if they match */
2260 /*-----------------------------------------------------------------*/
2262 isSymbolEqual (symbol * dest, symbol * src)
2264 /* if pointers match then equal */
2268 /* if one of them is null then don't match */
2272 /* if both of them have rname match on rname */
2273 if (dest->rname[0] && src->rname[0])
2274 return (!strcmp (dest->rname, src->rname));
2276 /* otherwise match on name */
2277 return (!strcmp (dest->name, src->name));
2280 void PT(sym_link *type)
2282 printTypeChain(type,0);
2284 /*-----------------------------------------------------------------*/
2285 /* printTypeChain - prints the type chain in human readable form */
2286 /*-----------------------------------------------------------------*/
2288 printTypeChain (sym_link * start, FILE * of)
2292 sym_link * type, * search;
2302 fprintf (of, "void");
2306 /* Print the chain as it is written in the source: */
2307 /* start with the last entry. */
2308 /* However, the storage class at the end of the */
2309 /* chain reall applies to the first in the chain! */
2311 for (type = start; type && type->next; type = type->next)
2314 scls=SPEC_SCLS(type);
2322 case S_DATA: fprintf (of, "data-"); break;
2323 case S_XDATA: fprintf (of, "xdata-"); break;
2324 case S_SFR: fprintf (of, "sfr-"); break;
2325 case S_SBIT: fprintf (of, "sbit-"); break;
2326 case S_CODE: fprintf (of, "code-"); break;
2327 case S_IDATA: fprintf (of, "idata-"); break;
2328 case S_PDATA: fprintf (of, "pdata-"); break;
2329 case S_LITERAL: fprintf (of, "literal-"); break;
2330 case S_STACK: fprintf (of, "stack-"); break;
2331 case S_XSTACK: fprintf (of, "xstack-"); break;
2332 case S_BIT: fprintf (of, "bit-"); break;
2333 case S_EEPROM: fprintf (of, "eeprom-"); break;
2340 if (!IS_FUNC(type)) {
2341 if (DCL_PTR_VOLATILE (type)) {
2342 fprintf (of, "volatile-");
2344 if (DCL_PTR_CONST (type)) {
2345 fprintf (of, "const-");
2348 switch (DCL_TYPE (type))
2351 fprintf (of, "function %s %s",
2352 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2353 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2355 for (args = FUNC_ARGS(type);
2358 printTypeChain(args->type, of);
2365 fprintf (of, "generic* ");
2368 fprintf (of, "code* ");
2371 fprintf (of, "xdata* ");
2374 fprintf (of, "eeprom* ");
2377 fprintf (of, "near* ");
2380 fprintf (of, "idata* ");
2383 fprintf (of, "pdata* ");
2386 fprintf (of, "unknown* ");
2389 if (DCL_ELEM(type)) {
2390 fprintf (of, "[%d] ", DCL_ELEM(type));
2392 fprintf (of, "[] ");
2399 if (SPEC_VOLATILE (type))
2400 fprintf (of, "volatile-");
2401 if (SPEC_CONST (type))
2402 fprintf (of, "const-");
2403 if (SPEC_USIGN (type))
2404 fprintf (of, "unsigned-");
2405 switch (SPEC_NOUN (type))
2409 fprintf (of, "long-");
2410 fprintf (of, "int");
2414 fprintf (of, "char");
2418 fprintf (of, "void");
2422 fprintf (of, "float");
2426 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2430 fprintf (of, "sbit");
2434 fprintf (of, "bit");
2438 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2442 fprintf (of, "double");
2446 fprintf (of, "unknown type");
2450 /* search entry in list before "type" */
2451 for (search = start; search && search->next != type;)
2452 search = search->next;
2461 /*--------------------------------------------------------------------*/
2462 /* printTypeChainRaw - prints the type chain in human readable form */
2463 /* in the raw data structure ordering */
2464 /*--------------------------------------------------------------------*/
2466 printTypeChainRaw (sym_link * start, FILE * of)
2479 fprintf (of, "void");
2489 if (!IS_FUNC(type)) {
2490 if (DCL_PTR_VOLATILE (type)) {
2491 fprintf (of, "volatile-");
2493 if (DCL_PTR_CONST (type)) {
2494 fprintf (of, "const-");
2497 switch (DCL_TYPE (type))
2500 fprintf (of, "function %s %s",
2501 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2502 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2504 for (args = FUNC_ARGS(type);
2507 printTypeChain(args->type, of);
2514 fprintf (of, "generic* ");
2517 fprintf (of, "code* ");
2520 fprintf (of, "xdata* ");
2523 fprintf (of, "eeprom* ");
2526 fprintf (of, "near* ");
2529 fprintf (of, "idata* ");
2532 fprintf (of, "pdata* ");
2535 fprintf (of, "unknown* ");
2538 if (DCL_ELEM(type)) {
2539 fprintf (of, "[%d] ", DCL_ELEM(type));
2541 fprintf (of, "[] ");
2545 if (DCL_TSPEC(type))
2548 printTypeChainRaw(DCL_TSPEC(type), of);
2552 else if (IS_SPEC (type))
2554 switch (SPEC_SCLS (type))
2556 case S_DATA: fprintf (of, "data-"); break;
2557 case S_XDATA: fprintf (of, "xdata-"); break;
2558 case S_SFR: fprintf (of, "sfr-"); break;
2559 case S_SBIT: fprintf (of, "sbit-"); break;
2560 case S_CODE: fprintf (of, "code-"); break;
2561 case S_IDATA: fprintf (of, "idata-"); break;
2562 case S_PDATA: fprintf (of, "pdata-"); break;
2563 case S_LITERAL: fprintf (of, "literal-"); break;
2564 case S_STACK: fprintf (of, "stack-"); break;
2565 case S_XSTACK: fprintf (of, "xstack-"); break;
2566 case S_BIT: fprintf (of, "bit-"); break;
2567 case S_EEPROM: fprintf (of, "eeprom-"); break;
2570 if (SPEC_VOLATILE (type))
2571 fprintf (of, "volatile-");
2572 if (SPEC_CONST (type))
2573 fprintf (of, "const-");
2574 if (SPEC_USIGN (type))
2575 fprintf (of, "unsigned-");
2576 switch (SPEC_NOUN (type))
2580 fprintf (of, "long-");
2581 fprintf (of, "int");
2585 fprintf (of, "char");
2589 fprintf (of, "void");
2593 fprintf (of, "float");
2597 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2601 fprintf (of, "sbit");
2605 fprintf (of, "bit");
2609 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2613 fprintf (of, "double");
2617 fprintf (of, "unknown type");
2622 fprintf (of, "NOT_SPEC_OR_DECL");
2632 /*-----------------------------------------------------------------*/
2633 /* powof2 - returns power of two for the number if number is pow 2 */
2634 /*-----------------------------------------------------------------*/
2636 powof2 (TYPE_UDWORD num)
2649 if (n1s > 1 || nshifts == 0)
2665 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2666 symbol *__muldiv[3][3][2];
2667 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2668 sym_link *__multypes[3][2];
2669 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2670 symbol *__conv[2][3][2];
2671 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2672 symbol *__rlrr[2][3][2];
2674 sym_link *floatType;
2677 _mangleFunctionName(char *in)
2679 if (port->getMangledFunctionName)
2681 return port->getMangledFunctionName(in);
2689 /*-----------------------------------------------------------------*/
2690 /* typeFromStr - create a typechain from an encoded string */
2691 /* basic types - 'c' - char */
2697 /* '*' - pointer - default (GPOINTER) */
2698 /* modifiers - 'u' - unsigned */
2699 /* pointer modifiers - 'g' - generic */
2703 /* 'F' - function */
2704 /* examples : "ig*" - generic int * */
2705 /* "cx*" - char xdata * */
2706 /* "ui" - unsigned int */
2707 /*-----------------------------------------------------------------*/
2708 sym_link *typeFromStr (char *s)
2710 sym_link *r = newLink(DECLARATOR);
2722 r->class = SPECIFIER;
2723 SPEC_NOUN(r) = V_CHAR;
2727 r->class = SPECIFIER;
2728 SPEC_NOUN(r) = V_INT;
2731 r->class = SPECIFIER;
2732 SPEC_NOUN(r) = V_INT;
2736 r->class = SPECIFIER;
2737 SPEC_NOUN(r) = V_FLOAT;
2740 r->class = SPECIFIER;
2741 SPEC_NOUN(r) = V_VOID;
2744 DCL_TYPE(r) = port->unqualified_pointer;
2751 assert(*(s+1)=='*');
2752 nr = newLink(DECLARATOR);
2757 DCL_TYPE(r) = GPOINTER;
2760 DCL_TYPE(r) = FPOINTER;
2763 DCL_TYPE(r) = CPOINTER;
2766 DCL_TYPE(r) = POINTER;
2769 DCL_TYPE(r) = FUNCTION;
2770 nr = newLink(DECLARATOR);
2773 DCL_TYPE(r) = CPOINTER;
2779 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
2780 "typeFromStr: unknown type");
2783 if (IS_SPEC(r) && usign) {
2792 /*-----------------------------------------------------------------*/
2793 /* initCSupport - create functions for C support routines */
2794 /*-----------------------------------------------------------------*/
2798 const char *smuldivmod[] =
2802 const char *sbwd[] =
2804 "char", "int", "long"
2810 const char *srlrr[] =
2815 int bwd, su, muldivmod, tofrom, rlrr;
2817 if (getenv("SDCC_NO_C_SUPPORT")) {
2818 /* for debugging only */
2822 floatType = newFloatLink ();
2824 for (bwd = 0; bwd < 3; bwd++)
2841 __multypes[bwd][0] = l;
2842 __multypes[bwd][1] = copyLinkChain (l);
2843 SPEC_USIGN (__multypes[bwd][1]) = 1;
2846 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2847 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2848 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2849 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2850 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2851 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2852 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2853 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2854 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2855 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2857 for (tofrom = 0; tofrom < 2; tofrom++)
2859 for (bwd = 0; bwd < 3; bwd++)
2861 for (su = 0; su < 2; su++)
2865 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
2866 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2870 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
2871 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2878 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2880 for (bwd = 0; bwd < 3; bwd++)
2882 for (su = 0; su < 2; su++)
2884 SNPRINTF (buffer, sizeof(buffer),
2886 smuldivmod[muldivmod],
2889 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2890 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2895 muluint() and mulsint() resp. mululong() and mulslong() return the same result.
2896 Therefore they've been merged into mulint() and mullong().
2899 for (bwd = 0; bwd < 3; bwd++)
2901 for (su = 0; su < 2; su++)
2903 for (muldivmod = 1; muldivmod < 3; muldivmod++)
2906 SNPRINTF (buffer, sizeof(buffer),
2908 smuldivmod[muldivmod],
2911 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2912 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2920 for (su = 0; su < 2; su++)
2922 /* muluchar and mulschar are still separate functions, because e.g. the z80
2923 port is sign/zero-extending to int before calling mulint() */
2924 SNPRINTF (buffer, sizeof(buffer),
2926 smuldivmod[muldivmod],
2929 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2930 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2934 /* word and doubleword */
2935 for (bwd = 1; bwd < 3; bwd++)
2938 SNPRINTF (buffer, sizeof(buffer),
2940 smuldivmod[muldivmod],
2942 __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2943 FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
2944 /* signed = unsigned */
2945 __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
2948 for (rlrr = 0; rlrr < 2; rlrr++)
2950 for (bwd = 0; bwd < 3; bwd++)
2952 for (su = 0; su < 2; su++)
2954 SNPRINTF (buffer, sizeof(buffer),
2959 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2960 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
2966 /*-----------------------------------------------------------------*/
2967 /* initBuiltIns - create prototypes for builtin functions */
2968 /*-----------------------------------------------------------------*/
2974 if (!port->builtintable) return ;
2976 for (i = 0 ; port->builtintable[i].name ; i++) {
2977 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
2978 port->builtintable[i].nParms,port->builtintable[i].parm_types);
2979 FUNC_ISBUILTIN(sym->type) = 1;
2980 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
2984 sym_link *validateLink(sym_link *l,
2991 if (l && l->class==select)
2996 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
2997 " expected %s, got %s\n",
2998 macro, args, file, line,
2999 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
3001 return l; // never reached, makes compiler happy.