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)
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 if (SPEC_NOUN (reType) == V_CHAR)
1551 SPEC_NOUN (reType) = V_INT;
1554 /* if either of them unsigned but not val then make this unsigned */
1555 if ((SPEC_USIGN (etype1) || SPEC_USIGN (etype2)) &&
1557 SPEC_USIGN (reType) = 1;
1559 SPEC_USIGN (reType) = 0;
1561 /* if result is a literal then make not so */
1562 if (IS_LITERAL (reType))
1563 SPEC_SCLS (reType) = S_REGISTER;
1568 /*--------------------------------------------------------------------*/
1569 /* compareType - will do type check return 1 if match, -1 if castable */
1570 /*--------------------------------------------------------------------*/
1572 compareType (sym_link * dest, sym_link * src)
1583 /* if dest is a declarator then */
1588 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1590 //checkFunction(src,dest);
1592 return compareType (dest->next, src->next);
1594 if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1597 if (IS_PTR (src) && IS_GENPTR (dest))
1599 if (IS_PTR (dest) && IS_ARRAY (src)) {
1600 value *val=aggregateToPointer (valFromType(src));
1601 int res=compareType (dest, val->type);
1602 Safe_free(val->type);
1606 if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1607 return compareType (dest->next, src);
1610 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1616 /* if one is a specifier and the other is not */
1617 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1618 (IS_SPEC (dest) && !IS_SPEC (src)))
1621 /* if one of them is a void then ok */
1622 if (SPEC_NOUN (dest) == V_VOID &&
1623 SPEC_NOUN (src) != V_VOID)
1626 if (SPEC_NOUN (dest) != V_VOID &&
1627 SPEC_NOUN (src) == V_VOID)
1630 /* if they are both bitfields then if the lengths
1631 and starts don't match */
1632 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1633 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1634 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1637 /* it is a specifier */
1638 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1640 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1641 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1642 getSize (dest) == getSize (src))
1644 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1649 else if (IS_STRUCT (dest))
1651 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1656 if (SPEC_LONG (dest) != SPEC_LONG (src))
1659 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1665 /*--------------------------------------------------------------------*/
1666 /* compareTypeExact - will do type check return 1 if match exactly */
1667 /*--------------------------------------------------------------------*/
1669 compareTypeExact (sym_link * dest, sym_link * src, int level)
1671 STORAGE_CLASS srcScls, destScls;
1682 /* if dest is a declarator then */
1687 if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1688 if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
1690 if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
1692 if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
1696 value *exargs, *acargs, *checkValue;
1698 /* verify function return type */
1699 if (!compareTypeExact (dest->next, src->next, -1))
1701 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
1703 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
1705 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
1708 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
1712 /* compare expected args with actual args */
1713 exargs = FUNC_ARGS(dest);
1714 acargs = FUNC_ARGS(src);
1716 /* for all the expected args do */
1717 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
1719 //checkTypeSanity(acargs->etype, acargs->name);
1721 if (IS_AGGREGATE (acargs->type))
1723 checkValue = copyValue (acargs);
1724 aggregateToPointer (checkValue);
1727 checkValue = acargs;
1730 if (!compareTypeExact (exargs->type, checkValue->type, -1))
1735 /* if one them ended we have a problem */
1736 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1737 (!exargs && acargs && !IS_VOID (acargs->type)))
1741 return compareTypeExact (dest->next, src->next, level);
1748 /* if one is a specifier and the other is not */
1749 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1750 (IS_SPEC (dest) && !IS_SPEC (src)))
1753 /* if one of them is a void then ok */
1754 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1757 /* if they are both bitfields then if the lengths
1758 and starts don't match */
1759 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1760 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1761 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1764 if (IS_INTEGRAL (dest))
1766 /* signedness must match */
1767 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1769 /* size must match */
1770 if (SPEC_LONG (dest) != SPEC_LONG (src))
1772 if (SPEC_SHORT (dest) != SPEC_SHORT (src))
1776 if (IS_STRUCT (dest))
1778 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1782 if (SPEC_CONST (dest) != SPEC_CONST (src))
1784 if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
1786 if (SPEC_STAT (dest) != SPEC_STAT (src))
1788 if (SPEC_ABSA (dest) != SPEC_ABSA (src))
1790 if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
1793 destScls = SPEC_SCLS (dest);
1794 srcScls = SPEC_SCLS (src);
1796 /* Compensate for const to const code change in checkSClass() */
1797 if (!level & port->mem.code_ro && SPEC_CONST (dest))
1799 if (srcScls == S_CODE && destScls == S_FIXED)
1801 if (destScls == S_CODE && srcScls == S_FIXED)
1805 /* compensate for allocGlobal() */
1806 if ((srcScls == S_FIXED || srcScls == S_AUTO)
1807 && port->mem.default_globl_map == xdata
1811 if (level>0 && !SPEC_STAT (dest))
1813 /* Compensate for hack-o-matic in checkSClass() */
1814 if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1816 if (destScls == S_FIXED)
1817 destScls = (options.useXstack ? S_XSTACK : S_STACK);
1818 if (srcScls == S_FIXED)
1819 srcScls = (options.useXstack ? S_XSTACK : S_STACK);
1821 else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
1823 if (destScls == S_FIXED)
1825 if (srcScls == S_FIXED)
1830 if (srcScls != destScls)
1833 printf ("level = %d\n", level);
1834 printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
1835 SPEC_SCLS (src), SPEC_SCLS (dest));
1836 printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
1844 /*------------------------------------------------------------------*/
1845 /* inCalleeSaveList - return 1 if found in callee save list */
1846 /*------------------------------------------------------------------*/
1848 calleeCmp(void *p1, void *p2)
1850 return (strcmp((char *)p1, (char *)(p2)) == 0);
1854 inCalleeSaveList(char *s)
1856 if (options.all_callee_saves)
1858 return isinSetWith(options.calleeSavesSet, s, calleeCmp);
1861 /*-----------------------------------------------------------------*/
1862 /* aggregateToPointer: change an agggregate type function */
1863 /* argument to a pointer to that type. */
1864 /*-----------------------------------------------------------------*/
1866 aggregateToPointer (value * val)
1868 if (IS_AGGREGATE (val->type))
1870 /* if this is a structure */
1871 /* then we need to add a new link */
1872 if (IS_STRUCT (val->type))
1874 /* first lets add DECLARATOR type */
1875 sym_link *p = val->type;
1877 werror (W_STRUCT_AS_ARG, val->name);
1878 val->type = newLink (DECLARATOR);
1879 val->type->next = p;
1882 /* change to a pointer depending on the */
1883 /* storage class specified */
1884 switch (SPEC_SCLS (val->etype))
1887 DCL_TYPE (val->type) = IPOINTER;
1890 DCL_TYPE (val->type) = PPOINTER;
1893 if (SPEC_OCLS(val->etype)) {
1894 DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1896 // this happens for (external) function parameters
1897 DCL_TYPE (val->type) = port->unqualified_pointer;
1903 DCL_TYPE (val->type) = POINTER;
1906 DCL_TYPE (val->type) = CPOINTER;
1909 DCL_TYPE (val->type) = FPOINTER;
1912 DCL_TYPE (val->type) = EEPPOINTER;
1915 DCL_TYPE (val->type) = port->unqualified_pointer;
1918 /* is there is a symbol associated then */
1919 /* change the type of the symbol as well */
1922 val->sym->type = copyLinkChain (val->type);
1923 val->sym->etype = getSpec (val->sym->type);
1928 /*------------------------------------------------------------------*/
1929 /* checkFunction - does all kinds of check on a function */
1930 /*------------------------------------------------------------------*/
1932 checkFunction (symbol * sym, symbol *csym)
1934 value *exargs, *acargs;
1938 if (getenv("DEBUG_SANITY")) {
1939 fprintf (stderr, "checkFunction: %s ", sym->name);
1942 if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
1944 werror(E_SYNTAX_ERROR, sym->name);
1948 /* make sure the type is complete and sane */
1949 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1951 /* if not type then some kind of error */
1955 /* if the function has no type then make it return int */
1956 if (!sym->type->next)
1957 sym->type->next = sym->etype = newIntLink ();
1959 /* function cannot return aggregate */
1960 if (IS_AGGREGATE (sym->type->next))
1962 werror (E_FUNC_AGGR, sym->name);
1966 /* function cannot return bit */
1967 if (IS_BITVAR (sym->type->next))
1969 werror (E_FUNC_BIT, sym->name);
1973 /* check if this function is defined as calleeSaves
1974 then mark it as such */
1975 FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1977 /* if interrupt service routine */
1978 /* then it cannot have arguments */
1979 if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1981 if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1982 werror (E_INT_ARGS, sym->name);
1983 FUNC_ARGS(sym->type)=NULL;
1987 for (argCnt=1, acargs = FUNC_ARGS(sym->type);
1989 acargs=acargs->next, argCnt++) {
1991 // this can happen for reentrant functions
1992 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1993 // the show must go on: synthesize a name and symbol
1994 SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
1995 acargs->sym = newSymbol (acargs->name, 1);
1996 SPEC_OCLS (acargs->etype) = istack;
1997 acargs->sym->type = copyLinkChain (acargs->type);
1998 acargs->sym->etype = getSpec (acargs->sym->type);
1999 acargs->sym->_isparm = 1;
2000 strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2001 } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2003 werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2008 if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2009 return 1; /* not defined nothing more to check */
2011 /* check if body already present */
2012 if (csym && IFFUNC_HASBODY(csym->type))
2014 werror (E_FUNC_BODY, sym->name);
2018 /* check the return value type */
2019 if (compareType (csym->type, sym->type) <= 0)
2021 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2022 printFromToType(csym->type, sym->type);
2026 if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2028 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2031 if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
2033 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2036 if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2038 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2041 /* Really, reentrant should match regardless of argCnt, but */
2042 /* this breaks some existing code (the fp lib functions). If */
2043 /* the first argument is always passed the same way, this */
2044 /* lax checking is ok (but may not be true for in future ports) */
2045 if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2048 //printf("argCnt = %d\n",argCnt);
2049 werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2052 /* compare expected args with actual args */
2053 exargs = FUNC_ARGS(csym->type);
2054 acargs = FUNC_ARGS(sym->type);
2056 /* for all the expected args do */
2059 exargs = exargs->next, acargs = acargs->next, argCnt++)
2061 if (getenv("DEBUG_SANITY")) {
2062 fprintf (stderr, "checkFunction: %s ", exargs->name);
2064 /* make sure the type is complete and sane */
2065 checkTypeSanity(exargs->etype, exargs->name);
2067 /* If the actual argument is an array, any prototype
2068 * will have modified it to a pointer. Duplicate that
2071 if (IS_AGGREGATE (acargs->type))
2073 checkValue = copyValue (acargs);
2074 aggregateToPointer (checkValue);
2078 checkValue = acargs;
2081 if (compareType (exargs->type, checkValue->type) <= 0)
2083 werror (E_ARG_TYPE, argCnt);
2084 printFromToType(exargs->type, checkValue->type);
2089 /* if one them ended we have a problem */
2090 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2091 (!exargs && acargs && !IS_VOID (acargs->type)))
2092 werror (E_ARG_COUNT);
2094 /* replace with this defition */
2095 sym->cdef = csym->cdef;
2096 deleteSym (SymbolTab, csym, csym->name);
2097 deleteFromSeg(csym);
2098 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2099 if (IS_EXTERN (csym->etype) && !
2100 IS_EXTERN (sym->etype))
2102 addSet (&publics, sym);
2107 /*------------------------------------------------------------------*/
2108 /* cdbStructBlock - calls struct printing for a blcks */
2109 /*------------------------------------------------------------------*/
2110 void cdbStructBlock (int block)
2113 bucket **table = StructTab;
2116 /* go thru the entire table */
2117 for (i = 0; i < 256; i++)
2119 for (chain = table[i]; chain; chain = chain->next)
2121 if (chain->block >= block)
2124 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2130 /*-----------------------------------------------------------------*/
2131 /* processFuncArgs - does some processing with function args */
2132 /*-----------------------------------------------------------------*/
2134 processFuncArgs (symbol * func)
2138 sym_link *funcType=func->type;
2140 if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2141 fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2143 // if this is a pointer to a function
2144 if (IS_PTR(funcType)) {
2145 funcType=funcType->next;
2148 /* if this function has variable argument list */
2149 /* then make the function a reentrant one */
2150 if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2151 FUNC_ISREENT(funcType)=1;
2153 /* check if this function is defined as calleeSaves
2154 then mark it as such */
2155 FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2157 /* loop thru all the arguments */
2158 val = FUNC_ARGS(funcType);
2160 /* if it is void then remove parameters */
2161 if (val && IS_VOID (val->type))
2163 FUNC_ARGS(funcType) = NULL;
2167 /* reset regparm for the port */
2168 (*port->reset_regparms) ();
2169 /* if any of the arguments is an aggregate */
2170 /* change it to pointer to the same type */
2174 /* mark it as a register parameter if
2175 the function does not have VA_ARG
2176 and as port dictates */
2177 if (!IFFUNC_HASVARARGS(funcType) &&
2178 (argreg = (*port->reg_parm) (val->type)))
2180 SPEC_REGPARM (val->etype) = 1;
2181 SPEC_ARGREG(val->etype) = argreg;
2182 } else if (IFFUNC_ISREENT(funcType)) {
2183 FUNC_HASSTACKPARM(funcType) = 1;
2186 if (IS_AGGREGATE (val->type))
2188 aggregateToPointer (val);
2195 /* if this is an internal generated function call */
2197 /* ignore --stack-auto for this one, we don't know how it is compiled */
2198 /* simply trust on --int-long-reent or --float-reent */
2199 if (IFFUNC_ISREENT(funcType)) {
2203 /* if this function is reentrant or */
2204 /* automatics r 2b stacked then nothing */
2205 if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2209 val = FUNC_ARGS(funcType);
2214 /* if a symbolname is not given */
2215 /* synthesize a variable name */
2218 SNPRINTF (val->name, sizeof(val->name),
2219 "_%s_PARM_%d", func->name, pNum++);
2220 val->sym = newSymbol (val->name, 1);
2221 SPEC_OCLS (val->etype) = port->mem.default_local_map;
2222 val->sym->type = copyLinkChain (val->type);
2223 val->sym->etype = getSpec (val->sym->type);
2224 val->sym->_isparm = 1;
2225 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2226 if (IS_SPEC(func->etype)) {
2227 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2228 SPEC_STAT (func->etype);
2230 addSymChain (val->sym);
2233 else /* symbol name given create synth name */
2236 SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2237 strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2238 val->sym->_isparm = 1;
2239 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2240 (options.model != MODEL_SMALL ? xdata : data);
2241 if (IS_SPEC(func->etype)) {
2242 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2243 SPEC_STAT (func->etype);
2246 if (!isinSet(operKeyReset, val->sym)) {
2247 addSet (&operKeyReset, val->sym);
2248 applyToSet (operKeyReset, resetParmKey);
2254 /*-----------------------------------------------------------------*/
2255 /* isSymbolEqual - compares two symbols return 1 if they match */
2256 /*-----------------------------------------------------------------*/
2258 isSymbolEqual (symbol * dest, symbol * src)
2260 /* if pointers match then equal */
2264 /* if one of them is null then don't match */
2268 /* if both of them have rname match on rname */
2269 if (dest->rname[0] && src->rname[0])
2270 return (!strcmp (dest->rname, src->rname));
2272 /* otherwise match on name */
2273 return (!strcmp (dest->name, src->name));
2276 void PT(sym_link *type)
2278 printTypeChain(type,0);
2280 /*-----------------------------------------------------------------*/
2281 /* printTypeChain - prints the type chain in human readable form */
2282 /*-----------------------------------------------------------------*/
2284 printTypeChain (sym_link * start, FILE * of)
2288 sym_link * type, * search;
2298 fprintf (of, "void");
2302 /* Print the chain as it is written in the source: */
2303 /* start with the last entry. */
2304 /* However, the storage class at the end of the */
2305 /* chain reall applies to the first in the chain! */
2307 for (type = start; type && type->next; type = type->next)
2310 scls=SPEC_SCLS(type);
2318 case S_DATA: fprintf (of, "data-"); break;
2319 case S_XDATA: fprintf (of, "xdata-"); break;
2320 case S_SFR: fprintf (of, "sfr-"); break;
2321 case S_SBIT: fprintf (of, "sbit-"); break;
2322 case S_CODE: fprintf (of, "code-"); break;
2323 case S_IDATA: fprintf (of, "idata-"); break;
2324 case S_PDATA: fprintf (of, "pdata-"); break;
2325 case S_LITERAL: fprintf (of, "literal-"); break;
2326 case S_STACK: fprintf (of, "stack-"); break;
2327 case S_XSTACK: fprintf (of, "xstack-"); break;
2328 case S_BIT: fprintf (of, "bit-"); break;
2329 case S_EEPROM: fprintf (of, "eeprom-"); break;
2336 if (!IS_FUNC(type)) {
2337 if (DCL_PTR_VOLATILE (type)) {
2338 fprintf (of, "volatile-");
2340 if (DCL_PTR_CONST (type)) {
2341 fprintf (of, "const-");
2344 switch (DCL_TYPE (type))
2347 fprintf (of, "function %s %s",
2348 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2349 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2351 for (args = FUNC_ARGS(type);
2354 printTypeChain(args->type, of);
2361 fprintf (of, "generic* ");
2364 fprintf (of, "code* ");
2367 fprintf (of, "xdata* ");
2370 fprintf (of, "eeprom* ");
2373 fprintf (of, "near* ");
2376 fprintf (of, "idata* ");
2379 fprintf (of, "pdata* ");
2382 fprintf (of, "unknown* ");
2385 if (DCL_ELEM(type)) {
2386 fprintf (of, "[%d] ", DCL_ELEM(type));
2388 fprintf (of, "[] ");
2395 if (SPEC_VOLATILE (type))
2396 fprintf (of, "volatile-");
2397 if (SPEC_CONST (type))
2398 fprintf (of, "const-");
2399 if (SPEC_USIGN (type))
2400 fprintf (of, "unsigned-");
2401 switch (SPEC_NOUN (type))
2405 fprintf (of, "long-");
2406 fprintf (of, "int");
2410 fprintf (of, "char");
2414 fprintf (of, "void");
2418 fprintf (of, "float");
2422 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2426 fprintf (of, "sbit");
2430 fprintf (of, "bit");
2434 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2438 fprintf (of, "double");
2442 fprintf (of, "unknown type");
2446 /* search entry in list before "type" */
2447 for (search = start; search && search->next != type;)
2448 search = search->next;
2457 /*--------------------------------------------------------------------*/
2458 /* printTypeChainRaw - prints the type chain in human readable form */
2459 /* in the raw data structure ordering */
2460 /*--------------------------------------------------------------------*/
2462 printTypeChainRaw (sym_link * start, FILE * of)
2475 fprintf (of, "void");
2485 if (!IS_FUNC(type)) {
2486 if (DCL_PTR_VOLATILE (type)) {
2487 fprintf (of, "volatile-");
2489 if (DCL_PTR_CONST (type)) {
2490 fprintf (of, "const-");
2493 switch (DCL_TYPE (type))
2496 fprintf (of, "function %s %s",
2497 (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2498 (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2500 for (args = FUNC_ARGS(type);
2503 printTypeChain(args->type, of);
2510 fprintf (of, "generic* ");
2513 fprintf (of, "code* ");
2516 fprintf (of, "xdata* ");
2519 fprintf (of, "eeprom* ");
2522 fprintf (of, "near* ");
2525 fprintf (of, "idata* ");
2528 fprintf (of, "pdata* ");
2531 fprintf (of, "unknown* ");
2534 if (DCL_ELEM(type)) {
2535 fprintf (of, "[%d] ", DCL_ELEM(type));
2537 fprintf (of, "[] ");
2541 if (DCL_TSPEC(type))
2544 printTypeChainRaw(DCL_TSPEC(type), of);
2548 else if (IS_SPEC (type))
2550 switch (SPEC_SCLS (type))
2552 case S_DATA: fprintf (of, "data-"); break;
2553 case S_XDATA: fprintf (of, "xdata-"); break;
2554 case S_SFR: fprintf (of, "sfr-"); break;
2555 case S_SBIT: fprintf (of, "sbit-"); break;
2556 case S_CODE: fprintf (of, "code-"); break;
2557 case S_IDATA: fprintf (of, "idata-"); break;
2558 case S_PDATA: fprintf (of, "pdata-"); break;
2559 case S_LITERAL: fprintf (of, "literal-"); break;
2560 case S_STACK: fprintf (of, "stack-"); break;
2561 case S_XSTACK: fprintf (of, "xstack-"); break;
2562 case S_BIT: fprintf (of, "bit-"); break;
2563 case S_EEPROM: fprintf (of, "eeprom-"); break;
2566 if (SPEC_VOLATILE (type))
2567 fprintf (of, "volatile-");
2568 if (SPEC_CONST (type))
2569 fprintf (of, "const-");
2570 if (SPEC_USIGN (type))
2571 fprintf (of, "unsigned-");
2572 switch (SPEC_NOUN (type))
2576 fprintf (of, "long-");
2577 fprintf (of, "int");
2581 fprintf (of, "char");
2585 fprintf (of, "void");
2589 fprintf (of, "float");
2593 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2597 fprintf (of, "sbit");
2601 fprintf (of, "bit");
2605 fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2609 fprintf (of, "double");
2613 fprintf (of, "unknown type");
2618 fprintf (of, "NOT_SPEC_OR_DECL");
2628 /*-----------------------------------------------------------------*/
2629 /* powof2 - returns power of two for the number if number is pow 2 */
2630 /*-----------------------------------------------------------------*/
2632 powof2 (unsigned long num)
2645 if (n1s > 1 || nshifts == 0)
2661 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2662 symbol *__muldiv[3][3][2];
2663 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2664 sym_link *__multypes[3][2];
2665 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2666 symbol *__conv[2][3][2];
2667 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2668 symbol *__rlrr[2][3][2];
2670 sym_link *floatType;
2673 _mangleFunctionName(char *in)
2675 if (port->getMangledFunctionName)
2677 return port->getMangledFunctionName(in);
2685 /*-----------------------------------------------------------------*/
2686 /* typeFromStr - create a typechain from an encoded string */
2687 /* basic types - 'c' - char */
2693 /* '*' - pointer - default (GPOINTER) */
2694 /* modifiers - 'u' - unsigned */
2695 /* pointer modifiers - 'g' - generic */
2699 /* 'F' - function */
2700 /* examples : "ig*" - generic int * */
2701 /* "cx*" - char xdata * */
2702 /* "ui" - unsigned int */
2703 /*-----------------------------------------------------------------*/
2704 sym_link *typeFromStr (char *s)
2706 sym_link *r = newLink(DECLARATOR);
2718 r->class = SPECIFIER;
2719 SPEC_NOUN(r) = V_CHAR;
2723 r->class = SPECIFIER;
2724 SPEC_NOUN(r) = V_INT;
2727 r->class = SPECIFIER;
2728 SPEC_NOUN(r) = V_INT;
2732 r->class = SPECIFIER;
2733 SPEC_NOUN(r) = V_FLOAT;
2736 r->class = SPECIFIER;
2737 SPEC_NOUN(r) = V_VOID;
2740 DCL_TYPE(r) = port->unqualified_pointer;
2747 assert(*(s+1)=='*');
2748 nr = newLink(DECLARATOR);
2753 DCL_TYPE(r) = GPOINTER;
2756 DCL_TYPE(r) = FPOINTER;
2759 DCL_TYPE(r) = CPOINTER;
2762 DCL_TYPE(r) = POINTER;
2765 DCL_TYPE(r) = FUNCTION;
2766 nr = newLink(DECLARATOR);
2769 DCL_TYPE(r) = CPOINTER;
2775 werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
2776 "typeFromStr: unknown type");
2779 if (IS_SPEC(r) && usign) {
2788 /*-----------------------------------------------------------------*/
2789 /* initCSupport - create functions for C support routines */
2790 /*-----------------------------------------------------------------*/
2794 const char *smuldivmod[] =
2798 const char *sbwd[] =
2800 "char", "int", "long"
2806 const char *srlrr[] =
2811 int bwd, su, muldivmod, tofrom, rlrr;
2813 if (getenv("SDCC_NO_C_SUPPORT")) {
2814 /* for debugging only */
2818 floatType = newFloatLink ();
2820 for (bwd = 0; bwd < 3; bwd++)
2837 __multypes[bwd][0] = l;
2838 __multypes[bwd][1] = copyLinkChain (l);
2839 SPEC_USIGN (__multypes[bwd][1]) = 1;
2842 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2843 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2844 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2845 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2846 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2847 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2848 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2849 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2850 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2851 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2853 for (tofrom = 0; tofrom < 2; tofrom++)
2855 for (bwd = 0; bwd < 3; bwd++)
2857 for (su = 0; su < 2; su++)
2861 SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
2862 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2866 SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
2867 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2874 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2876 for (bwd = 0; bwd < 3; bwd++)
2878 for (su = 0; su < 2; su++)
2880 SNPRINTF (buffer, sizeof(buffer),
2882 smuldivmod[muldivmod],
2885 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2886 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2891 muluint() and mulsint() resp. mululong() and mulslong() return the same result.
2892 Therefore they've been merged into mulint() and mullong().
2895 for (bwd = 0; bwd < 3; bwd++)
2897 for (su = 0; su < 2; su++)
2899 for (muldivmod = 1; muldivmod < 3; muldivmod++)
2902 SNPRINTF (buffer, sizeof(buffer),
2904 smuldivmod[muldivmod],
2907 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2908 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2916 for (su = 0; su < 2; su++)
2918 /* muluchar and mulschar are still separate functions, because e.g. the z80
2919 port is sign/zero-extending to int before calling mulint() */
2920 SNPRINTF (buffer, sizeof(buffer),
2922 smuldivmod[muldivmod],
2925 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2926 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2930 /* word and doubleword */
2931 for (bwd = 1; bwd < 3; bwd++)
2934 SNPRINTF (buffer, sizeof(buffer),
2936 smuldivmod[muldivmod],
2938 __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2939 FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
2940 /* signed = unsigned */
2941 __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
2944 for (rlrr = 0; rlrr < 2; rlrr++)
2946 for (bwd = 0; bwd < 3; bwd++)
2948 for (su = 0; su < 2; su++)
2950 SNPRINTF (buffer, sizeof(buffer),
2955 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2956 FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
2962 /*-----------------------------------------------------------------*/
2963 /* initBuiltIns - create prototypes for builtin functions */
2964 /*-----------------------------------------------------------------*/
2970 if (!port->builtintable) return ;
2972 for (i = 0 ; port->builtintable[i].name ; i++) {
2973 sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
2974 port->builtintable[i].nParms,port->builtintable[i].parm_types);
2975 FUNC_ISBUILTIN(sym->type) = 1;
2976 FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
2980 sym_link *validateLink(sym_link *l,
2987 if (l && l->class==select)
2992 "Internal error: validateLink failed in %s(%s) @ %s:%u:"
2993 " expected %s, got %s\n",
2994 macro, args, file, line,
2995 DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
2997 return l; // never reached, makes compiler happy.