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 -------------------------------------------------------------------------*/
28 char *nounName(sym_link *sl) {
29 switch (SPEC_NOUN(sl))
32 if (SPEC_LONG(sl)) return "long";
33 if (sl->select.s._short) return "short";
36 case V_FLOAT: return "float";
37 case V_CHAR: return "char";
38 case V_VOID: return "void";
39 case V_STRUCT: return "struct";
40 case V_LABEL: return "label";
41 case V_BIT: return "bit";
42 case V_SBIT: return "sbit";
43 case V_DOUBLE: return "double";
48 bucket *SymbolTab[256]; /* the symbol table */
49 bucket *StructTab[256]; /* the structure table */
50 bucket *TypedefTab[256]; /* the typedef table */
51 bucket *LabelTab[256]; /* the Label table */
52 bucket *enumTab[256]; /* enumerated table */
54 /*------------------------------------------------------------------*/
55 /* initSymt () - initialises symbol table related stuff */
56 /*------------------------------------------------------------------*/
62 for (i = 0; i < 256; i++)
63 SymbolTab[i] = StructTab[i] = (void *) NULL;
67 /*-----------------------------------------------------------------*/
68 /* newBucket - allocates & returns a new bucket */
69 /*-----------------------------------------------------------------*/
75 bp = Safe_calloc (1, sizeof (bucket));
80 /*-----------------------------------------------------------------*/
81 /* hashKey - computes the hashkey given a symbol name */
82 /*-----------------------------------------------------------------*/
84 hashKey (const char *s)
86 unsigned long key = 0;
93 /*-----------------------------------------------------------------*/
94 /* addSym - adds a symbol to the hash Table */
95 /*-----------------------------------------------------------------*/
97 addSym (bucket ** stab,
104 int i; /* index into the hash Table */
105 bucket *bp; /* temp bucket * */
108 if (getenv("DEBUG_SANITY")) {
109 fprintf (stderr, "addSym: %s ", sname);
111 /* make sure the type is complete and sane */
112 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
115 /* the symbols are always added at the head of the list */
117 /* get a free entry */
118 bp = Safe_calloc (1, sizeof (bucket));
120 bp->sym = sym; /* update the symbol pointer */
121 bp->level = level; /* update the nest level */
123 strcpy (bp->name, sname); /* copy the name into place */
125 /* if this is the first entry */
128 bp->prev = bp->next = (void *) NULL; /* point to nothing */
131 /* not first entry then add @ head of list */
141 /*-----------------------------------------------------------------*/
142 /* deleteSym - deletes a symbol from the hash Table entry */
143 /*-----------------------------------------------------------------*/
145 deleteSym (bucket ** stab, void *sym, char *sname)
153 /* find the symbol */
156 if (bp->sym == sym) /* found it then break out */
157 break; /* of the loop */
161 if (!bp) /* did not find it */
163 /* if this is the first one in the chain */
167 if (stab[i]) /* if chain ! empty */
168 stab[i]->prev = (void *) NULL;
170 /* middle || end of chain */
173 if (bp->next) /* if not end of chain */
174 bp->next->prev = bp->prev;
176 bp->prev->next = bp->next;
181 /*-----------------------------------------------------------------*/
182 /* findSym - finds a symbol in a table */
183 /*-----------------------------------------------------------------*/
185 findSym (bucket ** stab, void *sym, const char *sname)
189 bp = stab[hashKey (sname)];
192 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
197 return (bp ? bp->sym : (void *) NULL);
200 /*-----------------------------------------------------------------*/
201 /* findSymWithLevel - finds a symbol with a name & level */
202 /*-----------------------------------------------------------------*/
204 findSymWithLevel (bucket ** stab, symbol * sym)
208 bp = stab[hashKey (sym->name)];
211 ** do the search from the head of the list since the
212 ** elements are added at the head it is ensured that
213 ** we will find the deeper definitions before we find
214 ** the global ones. we need to check for symbols with
215 ** level <= to the level given, if levels match then block
216 ** numbers need to match as well
221 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
223 /* if this is parameter then nothing else need to be checked */
224 if (((symbol *) (bp->sym))->_isparm)
226 /* if levels match then block numbers hsould also match */
227 if (bp->level && bp->level == sym->level && bp->block == sym->block)
229 /* if levels don't match then we are okay */
230 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
232 /* if this is a global variable then we are ok too */
240 return (void *) NULL;
243 /*-----------------------------------------------------------------*/
244 /* findSymWithBlock - finds a symbol with name in with a block */
245 /*-----------------------------------------------------------------*/
247 findSymWithBlock (bucket ** stab, symbol * sym, int block)
251 bp = stab[hashKey (sym->name)];
254 if (strcmp (bp->name, sym->name) == 0 &&
260 return (bp ? bp->sym : (void *) NULL);
263 /*------------------------------------------------------------------*/
264 /* newSymbol () - returns a new pointer to a symbol */
265 /*------------------------------------------------------------------*/
267 newSymbol (char *name, int scope)
271 sym = Safe_calloc (1, sizeof (symbol));
273 strcpy (sym->name, name); /* copy the name */
274 sym->level = scope; /* set the level */
275 sym->block = currBlockno;
276 sym->lineDef = yylineno; /* set the line number */
280 /*------------------------------------------------------------------*/
281 /* newLink - creates a new link (declarator,specifier) */
282 /*------------------------------------------------------------------*/
288 p = Safe_calloc (1, sizeof (sym_link));
293 /*------------------------------------------------------------------*/
294 /* newStruct - creats a new structdef from the free list */
295 /*------------------------------------------------------------------*/
297 newStruct (char *tag)
301 s = Safe_calloc (1, sizeof (structdef));
303 strcpy (s->tag, tag); /* copy the tag */
307 /*------------------------------------------------------------------*/
308 /* pointerTypes - do the computation for the pointer types */
309 /*------------------------------------------------------------------*/
311 pointerTypes (sym_link * ptr, sym_link * type)
316 /* find the first pointer type */
317 while (ptr && !IS_PTR (ptr))
320 /* could not find it */
322 if (!ptr || IS_SPEC (ptr) ||
323 DCL_TYPE(ptr)!=UPOINTER)
326 if (!ptr || IS_SPEC (ptr))
329 if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
330 pointerTypes (ptr->next, type);
335 /* change the pointer type depending on the
336 storage class of the type */
339 DCL_PTR_CONST (ptr) = SPEC_CONST (type);
340 DCL_PTR_VOLATILE (ptr) = SPEC_VOLATILE (type);
341 switch (SPEC_SCLS (type))
344 DCL_TYPE (ptr) = FPOINTER;
347 DCL_TYPE (ptr) = IPOINTER;
350 DCL_TYPE (ptr) = PPOINTER;
353 DCL_TYPE (ptr) = POINTER;
356 DCL_PTR_CONST (ptr) = port->mem.code_ro;
357 DCL_TYPE (ptr) = CPOINTER;
360 DCL_TYPE (ptr) = EEPPOINTER;
363 DCL_TYPE (ptr) = GPOINTER;
366 /* the storage class of type ends here */
369 SPEC_VOLATILE (type) = 0;
372 /* now change all the remaining unknown pointers
373 to generic pointers */
376 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
377 DCL_TYPE (ptr) = GPOINTER;
381 /* same for the type although it is highly unlikely that
382 type will have a pointer */
385 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
386 DCL_TYPE (type) = GPOINTER;
392 /*------------------------------------------------------------------*/
393 /* addDecl - adds a declarator @ the end of a chain */
394 /*------------------------------------------------------------------*/
396 addDecl (symbol * sym, int type, sym_link * p)
402 /* if we are passed a link then set head & tail */
411 head = tail = newLink ();
412 DCL_TYPE (head) = type;
415 /* if this is the first entry */
423 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
425 sym->etype = mergeSpec (sym->etype, head, sym->name);
429 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
432 while (t->next != sym->etype)
435 tail->next = sym->etype;
439 sym->etype->next = head;
445 /* if the type is a unknown pointer and has
446 a tspec then take the storage class const & volatile
447 attribute from the tspec & make it those of this
451 DCL_TYPE (p) == UPOINTER &&
454 fprintf (stderr, "This has to go!\n");
456 if (!IS_SPEC (sym->etype))
458 sym->etype = sym->etype->next = newLink ();
459 sym->etype->class = SPECIFIER;
461 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
462 SPEC_CONST (sym->etype) = SPEC_CONST (DCL_TSPEC (p));
463 SPEC_VOLATILE (sym->etype) = SPEC_VOLATILE (DCL_TSPEC (p));
464 DCL_TSPEC (p) = NULL;
469 /*------------------------------------------------------------------
470 checkTypeSanity: prevent the user from doing e.g.:
472 ------------------------------------------------------------------*/
473 void checkTypeSanity(sym_link *etype, char *name) {
477 if (getenv("DEBUG_SANITY")) {
478 fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
483 if (!IS_SPEC(etype)) {
484 if (getenv("DEBUG_SANITY")) {
485 fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
490 noun=nounName(etype);
492 if (getenv("DEBUG_SANITY")) {
493 fprintf (stderr, "checking sanity for %s %x\n", name, (int)etype);
496 if ((SPEC_NOUN(etype)==V_CHAR ||
497 SPEC_NOUN(etype)==V_FLOAT ||
498 SPEC_NOUN(etype)==V_DOUBLE ||
499 SPEC_NOUN(etype)==V_VOID) &&
500 (etype->select.s._short || SPEC_LONG(etype))) {
501 // long or short for char float double or void
502 werror (E_LONG_OR_SHORT_INVALID, noun, name);
504 if ((SPEC_NOUN(etype)==V_FLOAT ||
505 SPEC_NOUN(etype)==V_DOUBLE ||
506 SPEC_NOUN(etype)==V_VOID) &&
507 (etype->select.s._signed || SPEC_USIGN(etype))) {
508 // signed or unsigned for float double or void
509 werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
512 // special case for "short"
513 if (etype->select.s._short) {
514 SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
515 etype->select.s._short = 0;
519 "const a;" or "data b;" or "signed s" or "long l"
521 if (!SPEC_NOUN(etype)) {
522 SPEC_NOUN(etype)=V_INT;
525 if (etype->select.s._signed && SPEC_USIGN(etype)) {
526 // signed AND unsigned
527 werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
529 if (etype->select.s._short && SPEC_LONG(etype)) {
531 werror (E_LONG_AND_SHORT_INVALID, noun, name);
536 /*------------------------------------------------------------------*/
537 /* mergeSpec - merges two specifiers and returns the new one */
538 /*------------------------------------------------------------------*/
539 #define LAST_MINUTE_2_3_0_FIX
541 mergeSpec (sym_link * dest, sym_link * src, char *name)
544 #ifdef LAST_MINUTE_2_3_0_FIX
547 if (!IS_SPEC(dest)) {
548 // This should not happen
549 fprintf (stderr, "*** internal error: can't merge declarators\n");
552 // here we have a declarator as source, reverse them
556 while (!IS_SPEC(dest)) {
557 // and find the specifier
565 if (getenv("DEBUG_mergeSpec")) {
566 fprintf (stderr, "mergeSpec: \"%s\"\n", name);
569 if (SPEC_NOUN(src)) {
570 if (!SPEC_NOUN(dest)) {
571 SPEC_NOUN(dest)=SPEC_NOUN(src);
573 /* we shouldn't redeclare the type */
574 if (getenv("DEBUG_SANITY")) {
575 fprintf (stderr, "mergeSpec: ");
577 werror(E_TWO_OR_MORE_DATA_TYPES, name);
581 if (SPEC_SCLS(src)) {
582 /* if destination has no storage class */
583 if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
584 SPEC_SCLS (dest) = SPEC_SCLS (src);
586 if (getenv("DEBUG_SANITY")) {
587 fprintf (stderr, "mergeSpec: ");
589 werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
593 /* copy all the specifications */
595 // we really should do:
597 if (SPEC_what(src)) {
598 if (SPEC_what(dest)) {
599 werror(W_DUPLICATE_SPEC, "what");
601 SPEC_what(dst)|=SPEC_what(src);
604 // but there are more important thing right now
606 SPEC_LONG (dest) |= SPEC_LONG (src);
607 dest->select.s._short|=src->select.s._short;
608 SPEC_USIGN (dest) |= SPEC_USIGN (src);
609 dest->select.s._signed|=src->select.s._signed;
610 SPEC_STAT (dest) |= SPEC_STAT (src);
611 SPEC_EXTR (dest) |= SPEC_EXTR (src);
612 SPEC_ABSA (dest) |= SPEC_ABSA (src);
613 SPEC_RENT (dest) |= SPEC_RENT (src);
614 SPEC_INTN (dest) |= SPEC_INTN (src);
615 SPEC_BANK (dest) |= SPEC_BANK (src);
616 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
617 SPEC_CRTCL (dest) |= SPEC_CRTCL (src);
618 SPEC_ADDR (dest) |= SPEC_ADDR (src);
619 SPEC_OCLS (dest) = SPEC_OCLS (src);
620 SPEC_BLEN (dest) |= SPEC_BLEN (src);
621 SPEC_BSTR (dest) |= SPEC_BSTR (src);
622 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
623 SPEC_NONBANKED (dest) |= SPEC_NONBANKED (src);
624 SPEC_NAKED (dest) |= SPEC_NAKED (src);
626 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
627 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
629 #ifdef LAST_MINUTE_2_3_0_FIX
636 /*------------------------------------------------------------------*/
637 /* cloneSpec - copies the entire spec and returns a new spec */
638 /*------------------------------------------------------------------*/
640 cloneSpec (sym_link * src)
644 /* go thru chain till we find the specifier */
645 while (src && src->class != SPECIFIER)
649 memcpy (spec, src, sizeof (sym_link));
653 /*------------------------------------------------------------------*/
654 /* genSymName - generates and returns a name used for anonymous vars */
655 /*------------------------------------------------------------------*/
657 genSymName (int level)
659 static int gCount = 0;
660 static char gname[SDCC_NAME_MAX + 1];
662 sprintf (gname, "__%04d%04d", level, gCount++);
666 /*------------------------------------------------------------------*/
667 /* getSpec - returns the specifier part from a declaration chain */
668 /*------------------------------------------------------------------*/
670 getSpec (sym_link * p)
675 while (p && !(IS_SPEC (p)))
681 /*------------------------------------------------------------------*/
682 /* newCharLink() - creates an char type */
683 /*------------------------------------------------------------------*/
690 p->class = SPECIFIER;
691 SPEC_NOUN (p) = V_CHAR;
696 /*------------------------------------------------------------------*/
697 /* newFloatLink - a new Float type */
698 /*------------------------------------------------------------------*/
705 p->class = SPECIFIER;
706 SPEC_NOUN (p) = V_FLOAT;
711 /*------------------------------------------------------------------*/
712 /* newLongLink() - new long type */
713 /*------------------------------------------------------------------*/
720 p->class = SPECIFIER;
721 SPEC_NOUN (p) = V_INT;
727 /*------------------------------------------------------------------*/
728 /* newIntLink() - creates an int type */
729 /*------------------------------------------------------------------*/
736 p->class = SPECIFIER;
737 SPEC_NOUN (p) = V_INT;
742 /*------------------------------------------------------------------*/
743 /* getSize - returns size of a type chain in bits */
744 /*------------------------------------------------------------------*/
746 getSize (sym_link * p)
748 /* if nothing return 0 */
752 { /* if this is the specifier then */
753 switch (SPEC_NOUN (p))
754 { /* depending on the specifier type */
756 return (IS_LONG (p) ? LONGSIZE : INTSIZE);
764 return SPEC_STRUCT (p)->size;
770 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
776 /* this is a specifier */
777 switch (DCL_TYPE (p))
782 return DCL_ELEM (p) * getSize (p->next);
799 /*------------------------------------------------------------------*/
800 /* bitsForType - returns # of bits required to store this type */
801 /*------------------------------------------------------------------*/
803 bitsForType (sym_link * p)
805 /* if nothing return 0 */
810 { /* if this is the specifier then */
812 switch (SPEC_NOUN (p))
813 { /* depending on the specifier type */
815 return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
817 return FLOATSIZE * 8;
823 return SPEC_STRUCT (p)->size * 8;
829 return SPEC_BLEN (p);
835 /* this is a specifier */
836 switch (DCL_TYPE (p))
841 return DCL_ELEM (p) * getSize (p->next) * 8;
845 return (PTRSIZE * 8);
849 return (FPTRSIZE * 8);
851 return (GPTRSIZE * 8);
858 /*------------------------------------------------------------------*/
859 /* copySymbolChain - copies a symbol chain */
860 /*------------------------------------------------------------------*/
862 copySymbolChain (symbol * src)
869 dest = copySymbol (src);
870 dest->next = copySymbolChain (src->next);
874 /*------------------------------------------------------------------*/
875 /* copySymbol - makes a copy of a symbol */
876 /*------------------------------------------------------------------*/
878 copySymbol (symbol * src)
885 dest = newSymbol (src->name, src->level);
886 memcpy (dest, src, sizeof (symbol));
887 dest->level = src->level;
888 dest->block = src->block;
889 dest->ival = copyIlist (src->ival);
890 dest->type = copyLinkChain (src->type);
891 dest->etype = getSpec (dest->type);
893 dest->args = copyValueChain (src->args);
894 dest->key = src->key;
895 dest->calleeSave = src->calleeSave;
896 dest->allocreq = src->allocreq;
900 /*------------------------------------------------------------------*/
901 /* reverseSyms - reverses the links for a symbol chain */
902 /*------------------------------------------------------------------*/
904 reverseSyms (symbol * sym)
906 symbol *prev, *curr, *next;
921 sym->next = (void *) NULL;
925 /*------------------------------------------------------------------*/
926 /* reverseLink - reverses the links for a type chain */
927 /*------------------------------------------------------------------*/
929 reverseLink (sym_link * type)
931 sym_link *prev, *curr, *next;
946 type->next = (void *) NULL;
950 /*------------------------------------------------------------------*/
951 /* addSymChain - adds a symbol chain to the symboltable */
952 /*------------------------------------------------------------------*/
954 addSymChain (symbol * symHead)
956 symbol *sym = symHead;
959 for (; sym != NULL; sym = sym->next)
962 checkTypeSanity(sym->etype, sym->name);
964 /* if already exists in the symbol table then check if
965 one of them is an extern definition if yes then
966 then check if the type match, if the types match then
967 delete the current entry and add the new entry */
968 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
969 csym->level == sym->level) {
971 /* one definition extern ? */
972 if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) {
973 /* do types match ? */
974 if (compareType (csym->type, sym->type) != 1) {
976 werror (E_EXTERN_MISMATCH, csym->name);
979 /* delete current entry */
980 deleteSym (SymbolTab, csym, csym->name);
983 werror (E_DUPLICATE, sym->name);
989 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
994 /*------------------------------------------------------------------*/
995 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
996 /*------------------------------------------------------------------*/
998 funcInChain (sym_link * lnk)
1009 /*------------------------------------------------------------------*/
1010 /* structElemType - returns the type info of a sturct member */
1011 /*------------------------------------------------------------------*/
1013 structElemType (sym_link * stype, value * id, value ** argsp)
1015 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1016 sym_link *type, *etype;
1017 sym_link *petype = getSpec (stype);
1022 /* look for the id */
1025 if (strcmp (fields->rname, id->name) == 0)
1029 *argsp = fields->args;
1031 type = copyLinkChain (fields->type);
1032 etype = getSpec (type);
1033 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1034 SPEC_SCLS (etype) : SPEC_SCLS (petype));
1037 fields = fields->next;
1039 werror (E_NOT_MEMBER, id->name);
1044 /*------------------------------------------------------------------*/
1045 /* getStructElement - returns element of a tructure definition */
1046 /*------------------------------------------------------------------*/
1048 getStructElement (structdef * sdef, symbol * sym)
1052 for (field = sdef->fields; field; field = field->next)
1053 if (strcmp (field->name, sym->name) == 0)
1056 werror (E_NOT_MEMBER, sym->name);
1058 return sdef->fields;
1061 /*------------------------------------------------------------------*/
1062 /* compStructSize - computes the size of a structure */
1063 /*------------------------------------------------------------------*/
1065 compStructSize (int su, structdef * sdef)
1067 int sum = 0, usum = 0;
1071 /* for the identifiers */
1072 loop = sdef->fields;
1075 /* create the internal name for this variable */
1076 sprintf (loop->rname, "_%s", loop->name);
1077 loop->offset = (su == UNION ? sum = 0 : sum);
1078 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1080 /* if this is a bit field */
1083 /* change it to a unsigned bit */
1084 SPEC_NOUN (loop->etype) = V_BIT;
1085 SPEC_USIGN (loop->etype) = 1;
1086 /* check if this fit into the remaining */
1087 /* bits of this byte else align it to the */
1088 /* next byte boundary */
1089 if ((SPEC_BLEN (loop->etype) = loop->bitVar) <= (8 - bitOffset)) {
1090 SPEC_BSTR (loop->etype) = bitOffset;
1091 if ((bitOffset += (loop->bitVar % 8)) == 8)
1094 else /* does not fit */ {
1096 SPEC_BSTR (loop->etype) = bitOffset;
1097 sum += (loop->bitVar / 8);
1098 bitOffset += (loop->bitVar % 8);
1100 /* if this is the last field then pad */
1101 if (!loop->next && bitOffset && bitOffset != 8) {
1107 checkDecl (loop, 1);
1108 sum += getSize (loop->type);
1111 /* if function then do the arguments for it */
1112 if (funcInChain (loop->type)) {
1113 processFuncArgs (loop, 1);
1118 /* if this is not a bitfield but the */
1119 /* previous one was and did not take */
1120 /* the whole byte then pad the rest */
1121 if ((loop && !loop->bitVar) && bitOffset) {
1126 /* if union then size = sizeof larget field */
1128 usum = max (usum, sum);
1132 return (su == UNION ? usum : sum);
1135 /*------------------------------------------------------------------*/
1136 /* checkSClass - check the storage class specification */
1137 /*------------------------------------------------------------------*/
1139 checkSClass (symbol * sym, int isProto)
1141 if (getenv("DEBUG_SANITY")) {
1142 fprintf (stderr, "checkSClass: %s \n", sym->name);
1144 if (strcmp(sym->name, "_testsGlobal")==0) {
1148 /* type is literal can happen foe enums change
1150 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1151 SPEC_SCLS (sym->etype) = S_AUTO;
1153 /* if sfr or sbit then must also be */
1154 /* volatile the initial value will be xlated */
1155 /* to an absolute address */
1156 if (SPEC_SCLS (sym->etype) == S_SBIT ||
1157 SPEC_SCLS (sym->etype) == S_SFR)
1159 SPEC_VOLATILE (sym->etype) = 1;
1160 /* if initial value given */
1163 SPEC_ABSA (sym->etype) = 1;
1164 SPEC_ADDR (sym->etype) =
1165 (int) list2int (sym->ival);
1170 /* if absolute address given then it mark it as
1172 if (IS_ABSOLUTE (sym->etype))
1173 SPEC_VOLATILE (sym->etype) = 1;
1175 /* global variables declared const put into code */
1176 if (sym->level == 0 &&
1177 SPEC_CONST (sym->etype)) {
1178 SPEC_SCLS (sym->etype) = S_CODE;
1181 /* global variable in code space is a constant */
1182 if (sym->level == 0 &&
1183 SPEC_SCLS (sym->etype) == S_CODE &&
1185 SPEC_CONST (sym->etype) = 1;
1188 /* if bit variable then no storage class can be */
1189 /* specified since bit is already a storage */
1190 if (IS_BITVAR (sym->etype) &&
1191 (SPEC_SCLS (sym->etype) != S_FIXED &&
1192 SPEC_SCLS (sym->etype) != S_SBIT &&
1193 SPEC_SCLS (sym->etype) != S_BIT)
1196 werror (E_BITVAR_STORAGE, sym->name);
1197 SPEC_SCLS (sym->etype) = S_FIXED;
1200 /* extern variables cannot be initialized */
1201 if (IS_EXTERN (sym->etype) && sym->ival)
1203 werror (E_EXTERN_INIT, sym->name);
1208 /* if this is an automatic symbol then */
1209 /* storage class will be ignored and */
1210 /* symbol will be allocated on stack/ */
1211 /* data depending on flag */
1213 (options.stackAuto || reentrant) &&
1214 (SPEC_SCLS (sym->etype) != S_AUTO &&
1215 SPEC_SCLS (sym->etype) != S_FIXED &&
1216 SPEC_SCLS (sym->etype) != S_REGISTER &&
1217 SPEC_SCLS (sym->etype) != S_STACK &&
1218 SPEC_SCLS (sym->etype) != S_XSTACK))
1220 werror (E_AUTO_ASSUMED, sym->name);
1221 SPEC_SCLS (sym->etype) = S_AUTO;
1224 /* if this is an atomatic symbol */
1225 if (sym->level && (options.stackAuto || reentrant)) {
1226 if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1227 SPEC_SCLS (sym->etype) == S_FIXED ||
1228 SPEC_SCLS (sym->etype) == S_REGISTER ||
1229 SPEC_SCLS (sym->etype) == S_STACK ||
1230 SPEC_SCLS (sym->etype) == S_XSTACK)) {
1231 SPEC_SCLS (sym->etype) = S_AUTO;
1233 /* storage class may only be specified for statics */
1234 if (!IS_STATIC(sym->etype)) {
1235 werror (E_AUTO_ASSUMED, sym->name);
1241 /* automatic symbols cannot be given */
1242 /* an absolute address ignore it */
1244 SPEC_ABSA (sym->etype) &&
1245 (options.stackAuto || reentrant))
1247 werror (E_AUTO_ABSA, sym->name);
1248 SPEC_ABSA (sym->etype) = 0;
1251 /* arrays & pointers cannot be defined for bits */
1252 /* SBITS or SFRs or BIT */
1253 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1254 (SPEC_NOUN (sym->etype) == V_BIT ||
1255 SPEC_NOUN (sym->etype) == V_SBIT ||
1256 SPEC_SCLS (sym->etype) == S_SFR))
1257 werror (E_BIT_ARRAY, sym->name);
1259 /* if this is a bit|sbit then set length & start */
1260 if (SPEC_NOUN (sym->etype) == V_BIT ||
1261 SPEC_NOUN (sym->etype) == V_SBIT)
1263 SPEC_BLEN (sym->etype) = 1;
1264 SPEC_BSTR (sym->etype) = 0;
1268 /* variables declared in CODE space must have */
1269 /* initializers if not an extern */
1270 if (SPEC_SCLS (sym->etype) == S_CODE &&
1271 sym->ival == NULL &&
1273 port->mem.code_ro &&
1274 !IS_EXTERN (sym->etype) &&
1275 !funcInChain (sym->type))
1276 werror (E_CODE_NO_INIT, sym->name);
1279 /* if parameter or local variable then change */
1280 /* the storage class to reflect where the var will go */
1281 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1282 !IS_STATIC(sym->etype))
1284 if (options.stackAuto || (currFunc && IS_RENT (currFunc->etype)))
1286 SPEC_SCLS (sym->etype) = (options.useXstack ?
1287 S_XSTACK : S_STACK);
1291 /* hack-o-matic! I see no reason why the useXstack option should ever
1292 * control this allcoation, but the code was originally that way, and
1293 * changing it for non-390 ports breaks the compiler badly.
1295 bool useXdata = TARGET_IS_DS390 ? 1 : options.useXstack;
1296 SPEC_SCLS (sym->etype) = (useXdata ?
1302 /*------------------------------------------------------------------*/
1303 /* changePointer - change pointer to functions */
1304 /*------------------------------------------------------------------*/
1306 changePointer (symbol * sym)
1310 /* go thru the chain of declarations */
1311 /* if we find a pointer to a function */
1312 /* unconditionally change it to a ptr */
1314 for (p = sym->type; p; p = p->next)
1316 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1317 DCL_TYPE (p) = GPOINTER;
1318 if (IS_PTR (p) && IS_FUNC (p->next))
1319 DCL_TYPE (p) = CPOINTER;
1323 /*------------------------------------------------------------------*/
1324 /* checkDecl - does semantic validation of a declaration */
1325 /*------------------------------------------------------------------*/
1327 checkDecl (symbol * sym, int isProto)
1330 checkSClass (sym, isProto); /* check the storage class */
1331 changePointer (sym); /* change pointers if required */
1333 /* if this is an array without any dimension
1334 then update the dimension from the initial value */
1335 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1336 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1341 /*------------------------------------------------------------------*/
1342 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1343 /*------------------------------------------------------------------*/
1345 copyLinkChain (sym_link * p)
1347 sym_link *head, *curr, *loop;
1350 head = loop = (curr ? newLink () : (void *) NULL);
1353 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1354 loop->next = (curr->next ? newLink () : (void *) NULL);
1363 /*------------------------------------------------------------------*/
1364 /* cleanUpBlock - cleansup the symbol table specified for all the */
1365 /* symbols in the given block */
1366 /*------------------------------------------------------------------*/
1368 cleanUpBlock (bucket ** table, int block)
1373 /* go thru the entire table */
1374 for (i = 0; i < 256; i++)
1376 for (chain = table[i]; chain; chain = chain->next)
1378 if (chain->block >= block)
1380 deleteSym (table, chain->sym, chain->name);
1386 /*------------------------------------------------------------------*/
1387 /* cleanUpLevel - cleansup the symbol table specified for all the */
1388 /* symbols in the given level */
1389 /*------------------------------------------------------------------*/
1391 cleanUpLevel (bucket ** table, int level)
1396 /* go thru the entire table */
1397 for (i = 0; i < 256; i++)
1399 for (chain = table[i]; chain; chain = chain->next)
1401 if (chain->level >= level)
1403 deleteSym (table, chain->sym, chain->name);
1409 /*------------------------------------------------------------------*/
1410 /* computeType - computes the resultant type from two types */
1411 /*------------------------------------------------------------------*/
1413 computeType (sym_link * type1, sym_link * type2)
1417 sym_link *etype1 = getSpec (type1);
1418 sym_link *etype2 = getSpec (type2);
1420 /* if one of them is a float then result is a float */
1421 /* here we assume that the types passed are okay */
1422 /* and can be cast to one another */
1423 /* which ever is greater in size */
1424 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1425 rType = newFloatLink ();
1427 /* if only one of them is a bit variable
1428 then the other one prevails */
1429 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1430 rType = copyLinkChain (type2);
1431 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1432 rType = copyLinkChain (type1);
1434 /* if one of them is a pointer then that
1437 rType = copyLinkChain (type1);
1438 else if (IS_PTR (type2))
1439 rType = copyLinkChain (type2);
1440 else if (getSize (type1) > getSize (type2))
1441 rType = copyLinkChain (type1);
1443 rType = copyLinkChain (type2);
1445 reType = getSpec (rType);
1447 /* if either of them unsigned then make this unsigned */
1448 if ((SPEC_USIGN (etype1) || SPEC_USIGN (etype2)) && !IS_FLOAT (reType))
1449 SPEC_USIGN (reType) = 1;
1451 /* if result is a literal then make not so */
1452 if (IS_LITERAL (reType))
1453 SPEC_SCLS (reType) = S_REGISTER;
1458 /*------------------------------------------------------------------*/
1459 /* compareType - will do type check return 1 if match */
1460 /*------------------------------------------------------------------*/
1462 compareType (sym_link * dest, sym_link * src)
1473 /* if dest is a declarator then */
1478 if (DCL_TYPE (src) == DCL_TYPE (dest))
1479 return compareType (dest->next, src->next);
1480 else if (IS_PTR (src) && IS_PTR (dest))
1482 else if (IS_PTR (dest) && IS_ARRAY (src))
1484 else if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1485 return -1 * compareType (dest->next, src);
1489 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1495 /* if one is a specifier and the other is not */
1496 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1497 (IS_SPEC (dest) && !IS_SPEC (src)))
1500 /* if one of them is a void then ok */
1501 if (SPEC_NOUN (dest) == V_VOID &&
1502 SPEC_NOUN (src) != V_VOID)
1505 if (SPEC_NOUN (dest) != V_VOID &&
1506 SPEC_NOUN (src) == V_VOID)
1509 /* if they are both bitfields then if the lengths
1510 and starts don't match */
1511 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1512 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1513 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1516 /* it is a specifier */
1517 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1519 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1520 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1521 getSize (dest) == getSize (src))
1523 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1528 else if (IS_STRUCT (dest))
1530 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1535 if (SPEC_LONG (dest) != SPEC_LONG (src))
1538 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1544 /*------------------------------------------------------------------*/
1545 /* inCalleeSaveList - return 1 if found in callee save list */
1546 /*------------------------------------------------------------------*/
1548 inCalleeSaveList (char *s)
1552 for (i = 0; options.calleeSaves[i]; i++)
1553 if (strcmp (options.calleeSaves[i], s) == 0)
1559 /*-----------------------------------------------------------------*/
1560 /* aggregateArgToPointer: change an agggregate type function */
1561 /* argument to a pointer to that type. */
1562 /*-----------------------------------------------------------------*/
1564 aggregateArgToPointer (value * val)
1566 if (IS_AGGREGATE (val->type))
1568 /* if this is a structure */
1569 /* then we need to add a new link */
1570 if (IS_STRUCT (val->type))
1572 /* first lets add DECLARATOR type */
1573 sym_link *p = val->type;
1575 werror (W_STRUCT_AS_ARG, val->name);
1576 val->type = newLink ();
1577 val->type->next = p;
1580 /* change to a pointer depending on the */
1581 /* storage class specified */
1582 switch (SPEC_SCLS (val->etype))
1585 DCL_TYPE (val->type) = IPOINTER;
1588 DCL_TYPE (val->type) = PPOINTER;
1591 if (TARGET_IS_DS390)
1593 /* The AUTO and REGISTER classes should probably
1594 * also become generic pointers, but I haven't yet
1595 * devised a test case for that.
1597 DCL_TYPE (val->type) = GPOINTER;
1604 DCL_TYPE (val->type) = POINTER;
1607 DCL_TYPE (val->type) = CPOINTER;
1610 DCL_TYPE (val->type) = FPOINTER;
1613 DCL_TYPE (val->type) = EEPPOINTER;
1616 DCL_TYPE (val->type) = GPOINTER;
1619 /* is there is a symbol associated then */
1620 /* change the type of the symbol as well */
1623 val->sym->type = copyLinkChain (val->type);
1624 val->sym->etype = getSpec (val->sym->type);
1628 /*------------------------------------------------------------------*/
1629 /* checkFunction - does all kinds of check on a function */
1630 /*------------------------------------------------------------------*/
1632 checkFunction (symbol * sym)
1635 value *exargs, *acargs;
1639 if (getenv("DEBUG_SANITY")) {
1640 fprintf (stderr, "checkFunction: %s ", sym->name);
1643 /* make sure the type is complete and sane */
1644 checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1646 /* if not type then some kind of error */
1650 /* if the function has no type then make it return int */
1651 if (!sym->type->next)
1652 sym->type->next = sym->etype = newIntLink ();
1654 /* function cannot return aggregate */
1655 if (IS_AGGREGATE (sym->type->next))
1657 werror (E_FUNC_AGGR, sym->name);
1661 /* function cannot return bit */
1662 if (IS_BITVAR (sym->type->next))
1664 werror (E_FUNC_BIT, sym->name);
1668 /* check if this function is defined as calleeSaves
1669 then mark it as such */
1670 sym->calleeSave = inCalleeSaveList (sym->name);
1672 /* if interrupt service routine */
1673 /* then it cannot have arguments */
1674 if (sym->args && IS_ISR (sym->etype) && !IS_VOID (sym->args->type))
1676 werror (E_INT_ARGS, sym->name);
1680 if (!(csym = findSym (SymbolTab, sym, sym->name)))
1681 return 1; /* not defined nothing more to check */
1683 /* check if body already present */
1684 if (csym && csym->fbody)
1686 werror (E_FUNC_BODY, sym->name);
1690 /* check the return value type */
1691 if (compareType (csym->type, sym->type) <= 0)
1693 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1694 werror (E_CONTINUE, "previous definition type ");
1695 printTypeChain (csym->type, stderr);
1696 fprintf (stderr, "\n");
1697 werror (E_CONTINUE, "current definition type ");
1698 printTypeChain (sym->type, stderr);
1699 fprintf (stderr, "\n");
1703 if (SPEC_INTRTN (csym->etype) != SPEC_INTRTN (sym->etype))
1705 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1708 if (SPEC_BANK (csym->etype) != SPEC_BANK (sym->etype))
1710 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1713 if (SPEC_NAKED (csym->etype) != SPEC_NAKED (sym->etype))
1715 werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
1718 /* compare expected agrs with actual args */
1719 exargs = csym->args;
1722 /* for all the expected args do */
1725 exargs = exargs->next, acargs = acargs->next, argCnt++)
1727 if (getenv("DEBUG_SANITY")) {
1728 fprintf (stderr, "checkFunction: %s ", exargs->name);
1730 /* make sure the type is complete and sane */
1731 checkTypeSanity(exargs->etype, exargs->name);
1733 /* If the actual argument is an array, any prototype
1734 * will have modified it to a pointer. Duplicate that
1737 if (IS_AGGREGATE (acargs->type))
1739 checkValue = copyValue (acargs);
1740 aggregateArgToPointer (checkValue);
1744 checkValue = acargs;
1747 if (compareType (exargs->type, checkValue->type) <= 0)
1749 werror (E_ARG_TYPE, argCnt);
1754 /* if one them ended we have a problem */
1755 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1756 (!exargs && acargs && !IS_VOID (acargs->type)))
1757 werror (E_ARG_COUNT);
1759 /* replace with this defition */
1760 sym->cdef = csym->cdef;
1761 deleteSym (SymbolTab, csym, csym->name);
1762 addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1763 if (IS_EXTERN (csym->etype) && !
1764 IS_EXTERN (sym->etype))
1766 addSet (&publics, sym);
1771 /*-----------------------------------------------------------------*/
1772 /* processFuncArgs - does some processing with function args */
1773 /*-----------------------------------------------------------------*/
1775 processFuncArgs (symbol * func, int ignoreName)
1780 /* if this function has variable argument list */
1781 /* then make the function a reentrant one */
1783 SPEC_RENT (func->etype) = 1;
1785 /* check if this function is defined as calleeSaves
1786 then mark it as such */
1787 func->calleeSave = inCalleeSaveList (func->name);
1789 val = func->args; /* loop thru all the arguments */
1791 /* if it is void then remove parameters */
1792 if (val && IS_VOID (val->type))
1798 /* reset regparm for the port */
1799 (*port->reset_regparms) ();
1800 /* if any of the arguments is an aggregate */
1801 /* change it to pointer to the same type */
1804 /* mark it as a register parameter if
1805 the function does not have VA_ARG
1806 and as port dictates */
1807 if (!func->hasVargs &&
1808 (*port->reg_parm) (val->type))
1810 SPEC_REGPARM (val->etype) = 1;
1813 if (IS_AGGREGATE (val->type))
1815 aggregateArgToPointer (val);
1821 /* if this is an internal generated function call */
1823 /* ignore --stack-auto for this one, we don't know how it is compiled */
1824 /* simply trust on --int-long-reent or --float-reent */
1825 if (IS_RENT(func->etype)) {
1829 /* if this function is reentrant or */
1830 /* automatics r 2b stacked then nothing */
1831 if (IS_RENT (func->etype) || options.stackAuto)
1840 /* if a symbolname is not given */
1841 /* synthesize a variable name */
1845 sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
1846 val->sym = newSymbol (val->name, 1);
1847 SPEC_OCLS (val->etype) = port->mem.default_local_map;
1848 val->sym->type = copyLinkChain (val->type);
1849 val->sym->etype = getSpec (val->sym->type);
1850 val->sym->_isparm = 1;
1851 strcpy (val->sym->rname, val->name);
1852 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1853 SPEC_STAT (func->etype);
1854 addSymChain (val->sym);
1857 else /* symbol name given create synth name */
1860 sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
1861 strcpy (val->sym->rname, val->name);
1862 val->sym->_isparm = 1;
1863 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
1864 (options.model != MODEL_SMALL ? xdata : data);
1865 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1866 SPEC_STAT (func->etype);
1872 /*-----------------------------------------------------------------*/
1873 /* isSymbolEqual - compares two symbols return 1 if they match */
1874 /*-----------------------------------------------------------------*/
1876 isSymbolEqual (symbol * dest, symbol * src)
1878 /* if pointers match then equal */
1882 /* if one of them is null then don't match */
1886 /* if both of them have rname match on rname */
1887 if (dest->rname[0] && src->rname[0])
1888 return (!strcmp (dest->rname, src->rname));
1890 /* otherwise match on name */
1891 return (!strcmp (dest->name, src->name));
1894 void PT(sym_link *type)
1896 printTypeChain(type,0);
1898 /*-----------------------------------------------------------------*/
1899 /* printTypeChain - prints the type chain in human readable form */
1900 /*-----------------------------------------------------------------*/
1902 printTypeChain (sym_link * type, FILE * of)
1916 if (DCL_PTR_VOLATILE(type)) {
1917 fprintf (of, "volatile ");
1919 switch (DCL_TYPE (type))
1922 fprintf (of, "function ");
1925 fprintf (of, "_generic * ");
1926 if (DCL_PTR_CONST (type))
1927 fprintf (of, "const ");
1930 fprintf (of, "_code * ");
1931 if (DCL_PTR_CONST (type))
1932 fprintf (of, "const ");
1935 fprintf (of, "_far * ");
1936 if (DCL_PTR_CONST (type))
1937 fprintf (of, "const ");
1940 fprintf (of, "_eeprom * ");
1941 if (DCL_PTR_CONST (type))
1942 fprintf (of, "const ");
1946 fprintf (of, "_near * ");
1947 if (DCL_PTR_CONST (type))
1948 fprintf (of, "const ");
1951 fprintf (of, "_idata *");
1952 if (DCL_PTR_CONST (type))
1953 fprintf (of, "const ");
1956 fprintf (of, "_pdata *");
1957 if (DCL_PTR_CONST (type))
1958 fprintf (of, "const ");
1961 fprintf (of, " _unkown *");
1962 if (DCL_PTR_CONST (type))
1963 fprintf (of, "const ");
1966 fprintf (of, "array of ");
1972 if (SPEC_VOLATILE (type))
1973 fprintf (of, "volatile ");
1974 if (SPEC_USIGN (type))
1975 fprintf (of, "unsigned ");
1976 if (SPEC_CONST (type))
1977 fprintf (of, "const ");
1979 switch (SPEC_NOUN (type))
1983 fprintf (of, "long ");
1984 fprintf (of, "int ");
1988 fprintf (of, "char ");
1992 fprintf (of, "void ");
1996 fprintf (of, "float ");
2000 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2004 fprintf (of, "sbit ");
2008 fprintf (of, "bit {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2012 fprintf (of, "double ");
2016 fprintf (of, "unknown type ");
2026 /*-----------------------------------------------------------------*/
2027 /* cdbTypeInfo - print the type information for debugger */
2028 /*-----------------------------------------------------------------*/
2030 cdbTypeInfo (sym_link * type, FILE * of)
2032 fprintf (of, "{%d}", getSize (type));
2037 switch (DCL_TYPE (type))
2040 fprintf (of, "DF,");
2043 fprintf (of, "DG,");
2046 fprintf (of, "DC,");
2049 fprintf (of, "DX,");
2052 fprintf (of, "DD,");
2055 fprintf (of, "DI,");
2058 fprintf (of, "DP,");
2061 fprintf (of, "DA,");
2064 fprintf (of, "DA%d,", DCL_ELEM (type));
2072 switch (SPEC_NOUN (type))
2094 fprintf (of, "ST%s", SPEC_STRUCT (type)->tag);
2102 fprintf (of, "SB%d$%d", SPEC_BSTR (type), SPEC_BLEN (type));
2109 if (SPEC_USIGN (type))
2117 /*-----------------------------------------------------------------*/
2118 /* cdbSymbol - prints a symbol & its type information for debugger */
2119 /*-----------------------------------------------------------------*/
2121 cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc)
2133 fprintf (of, "S:"); /* symbol record */
2134 /* if this is not a structure symbol then
2135 we need to figure out the scope information */
2141 if (IS_STATIC (sym->etype))
2142 fprintf (of, "F%s$", moduleName); /* scope is file */
2144 fprintf (of, "G$"); /* scope is global */
2147 /* symbol is local */
2148 fprintf (of, "L%s$", (sym->localof ? sym->localof->name : "-null-"));
2151 fprintf (of, "S$"); /* scope is structure */
2153 /* print the name, & mangled name */
2154 fprintf (of, "%s$%d$%d(", sym->name,
2155 sym->level, sym->block);
2157 cdbTypeInfo (sym->type, of);
2160 /* print the address space */
2161 map = SPEC_OCLS (sym->etype);
2162 fprintf (of, "%c,%d,%d",
2163 (map ? map->dbName : 'Z'), sym->onStack, SPEC_STAK (sym->etype));
2165 /* if assigned to registers then output register names */
2166 /* if this is a function then print
2167 if is it an interrupt routine & interrupt number
2168 and the register bank it is using */
2170 fprintf (of, ",%d,%d,%d", SPEC_INTRTN (sym->etype),
2171 SPEC_INTN (sym->etype), SPEC_BANK (sym->etype));
2172 /* alternate location to find this symbol @ : eg registers
2179 /*-----------------------------------------------------------------*/
2180 /* cdbStruct - print a structure for debugger */
2181 /*-----------------------------------------------------------------*/
2183 cdbStruct (structdef * sdef, int block, FILE * of,
2184 int inStruct, char *tag)
2189 /* if block # then must have function scope */
2190 fprintf (of, "F%s$", moduleName);
2191 fprintf (of, "%s[", (tag ? tag : sdef->tag));
2192 for (sym = sdef->fields; sym; sym = sym->next)
2194 fprintf (of, "({%d}", sym->offset);
2195 cdbSymbol (sym, of, TRUE, FALSE);
2203 /*------------------------------------------------------------------*/
2204 /* cdbStructBlock - calls struct printing for a blcks */
2205 /*------------------------------------------------------------------*/
2207 cdbStructBlock (int block, FILE * of)
2210 bucket **table = StructTab;
2214 /* go thru the entire table */
2215 for (i = 0; i < 256; i++)
2217 for (chain = table[i]; chain; chain = chain->next)
2219 if (chain->block >= block)
2221 cdbStruct ((structdef *) chain->sym, chain->block, of, 0, NULL);
2227 /*-----------------------------------------------------------------*/
2228 /* powof2 - returns power of two for the number if number is pow 2 */
2229 /*-----------------------------------------------------------------*/
2231 powof2 (unsigned long num)
2244 if (n1s > 1 || nshifts == 0)
2260 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2261 symbol *__muldiv[3][3][2];
2262 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2263 sym_link *__multypes[3][2];
2264 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2265 symbol *__conv[2][3][2];
2266 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2267 symbol *__rlrr[2][3][2];
2269 sym_link *floatType;
2272 _mangleFunctionName(char *in)
2274 if (port->getMangledFunctionName)
2276 return port->getMangledFunctionName(in);
2284 /*-----------------------------------------------------------------*/
2285 /* initCSupport - create functions for C support routines */
2286 /*-----------------------------------------------------------------*/
2290 const char *smuldivmod[] =
2294 const char *sbwd[] =
2296 "char", "int", "long"
2302 const char *srlrr[] =
2307 int bwd, su, muldivmod, tofrom, rlrr;
2309 floatType = newFloatLink ();
2311 for (bwd = 0; bwd < 3; bwd++)
2328 __multypes[bwd][0] = l;
2329 __multypes[bwd][1] = copyLinkChain (l);
2330 SPEC_USIGN (__multypes[bwd][1]) = 1;
2333 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2334 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2335 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2336 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2337 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2338 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2339 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2340 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2341 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2342 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2344 for (tofrom = 0; tofrom < 2; tofrom++)
2346 for (bwd = 0; bwd < 3; bwd++)
2348 for (su = 0; su < 2; su++)
2352 sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]);
2353 __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], floatType, 1, options.float_rent);
2357 sprintf (buffer, "__%s%s2fs", ssu[su], sbwd[bwd]);
2358 __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), floatType, __multypes[bwd][su], 1, options.float_rent);
2364 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2366 for (bwd = 0; bwd < 3; bwd++)
2368 for (su = 0; su < 2; su++)
2370 sprintf (buffer, "_%s%s%s",
2371 smuldivmod[muldivmod],
2374 __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2375 SPEC_NONBANKED (__muldiv[muldivmod][bwd][su]->etype) = 1;
2380 for (rlrr = 0; rlrr < 2; rlrr++)
2382 for (bwd = 0; bwd < 3; bwd++)
2384 for (su = 0; su < 2; su++)
2386 sprintf (buffer, "_%s%s%s",
2390 __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2391 SPEC_NONBANKED (__rlrr[rlrr][bwd][su]->etype) = 1;