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 bucket *SymbolTab[256]; /* the symbol table */
28 bucket *StructTab[256]; /* the structure table */
29 bucket *TypedefTab[256]; /* the typedef table */
30 bucket *LabelTab[256]; /* the Label table */
31 bucket *enumTab[256]; /* enumerated table */
33 /*------------------------------------------------------------------*/
34 /* initSymt () - initialises symbol table related stuff */
35 /*------------------------------------------------------------------*/
41 for (i = 0; i < 256; i++)
42 SymbolTab[i] = StructTab[i] = (void *) NULL;
46 /*-----------------------------------------------------------------*/
47 /* newBucket - allocates & returns a new bucket */
48 /*-----------------------------------------------------------------*/
54 bp = Safe_calloc (1, sizeof (bucket));
59 /*-----------------------------------------------------------------*/
60 /* hashKey - computes the hashkey given a symbol name */
61 /*-----------------------------------------------------------------*/
63 hashKey (const char *s)
65 unsigned long key = 0;
72 /*-----------------------------------------------------------------*/
73 /* addSym - adds a symbol to the hash Table */
74 /*-----------------------------------------------------------------*/
76 addSym (bucket ** stab,
82 int i; /* index into the hash Table */
83 bucket *bp; /* temp bucket * */
85 /* the symbols are always added at the head of the list */
87 /* get a free entry */
88 bp = Safe_calloc (1, sizeof (bucket));
90 bp->sym = sym; /* update the symbol pointer */
91 bp->level = level; /* update the nest level */
93 strcpy (bp->name, sname); /* copy the name into place */
95 /* if this is the first entry */
98 bp->prev = bp->next = (void *) NULL; /* point to nothing */
101 /* not first entry then add @ head of list */
111 /*-----------------------------------------------------------------*/
112 /* deleteSym - deletes a symbol from the hash Table entry */
113 /*-----------------------------------------------------------------*/
115 deleteSym (bucket ** stab, void *sym, char *sname)
123 /* find the symbol */
126 if (bp->sym == sym) /* found it then break out */
127 break; /* of the loop */
131 if (!bp) /* did not find it */
133 /* if this is the first one in the chain */
137 if (stab[i]) /* if chain ! empty */
138 stab[i]->prev = (void *) NULL;
140 /* middle || end of chain */
143 if (bp->next) /* if not end of chain */
144 bp->next->prev = bp->prev;
146 bp->prev->next = bp->next;
151 /*-----------------------------------------------------------------*/
152 /* findSym - finds a symbol in a table */
153 /*-----------------------------------------------------------------*/
155 findSym (bucket ** stab, void *sym, const char *sname)
159 bp = stab[hashKey (sname)];
162 if (bp->sym == sym || strcmp (bp->name, sname) == 0)
167 return (bp ? bp->sym : (void *) NULL);
170 /*-----------------------------------------------------------------*/
171 /* findSymWithLevel - finds a symbol with a name & level */
172 /*-----------------------------------------------------------------*/
174 findSymWithLevel (bucket ** stab, symbol * sym)
178 bp = stab[hashKey (sym->name)];
181 ** do the search from the head of the list since the
182 ** elements are added at the head it is ensured that
183 ** we will find the deeper definitions before we find
184 ** the global ones. we need to check for symbols with
185 ** level <= to the level given, if levels match then block
186 ** numbers need to match as well
191 if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
193 /* if this is parameter then nothing else need to be checked */
194 if (((symbol *) (bp->sym))->_isparm)
196 /* if levels match then block numbers hsould also match */
197 if (bp->level && bp->level == sym->level && bp->block == sym->block)
199 /* if levels don't match then we are okay */
200 if (bp->level && bp->level != sym->level && bp->block <= sym->block)
202 /* if this is a global variable then we are ok too */
210 return (void *) NULL;
213 /*-----------------------------------------------------------------*/
214 /* findSymWithBlock - finds a symbol with name in with a block */
215 /*-----------------------------------------------------------------*/
217 findSymWithBlock (bucket ** stab, symbol * sym, int block)
221 bp = stab[hashKey (sym->name)];
224 if (strcmp (bp->name, sym->name) == 0 &&
230 return (bp ? bp->sym : (void *) NULL);
233 /*------------------------------------------------------------------*/
234 /* newSymbol () - returns a new pointer to a symbol */
235 /*------------------------------------------------------------------*/
237 newSymbol (char *name, int scope)
241 sym = Safe_calloc (1, sizeof (symbol));
243 strcpy (sym->name, name); /* copy the name */
244 sym->level = scope; /* set the level */
245 sym->block = currBlockno;
246 sym->lineDef = yylineno; /* set the line number */
250 /*------------------------------------------------------------------*/
251 /* newLink - creates a new link (declarator,specifier) */
252 /*------------------------------------------------------------------*/
258 p = Safe_calloc (1, sizeof (sym_link));
263 /*------------------------------------------------------------------*/
264 /* newStruct - creats a new structdef from the free list */
265 /*------------------------------------------------------------------*/
267 newStruct (char *tag)
271 s = Safe_calloc (1, sizeof (structdef));
273 strcpy (s->tag, tag); /* copy the tag */
277 /*------------------------------------------------------------------*/
278 /* pointerTypes - do the computation for the pointer types */
279 /*------------------------------------------------------------------*/
281 pointerTypes (sym_link * ptr, sym_link * type)
286 /* find the first pointer type */
287 while (ptr && !IS_PTR (ptr))
290 /* could not find it */
291 if (!ptr || IS_SPEC (ptr) ||
292 DCL_TYPE (ptr) != UPOINTER)
295 /* change the pointer type depending on the
296 storage class of the type */
299 DCL_PTR_CONST (ptr) = SPEC_CONST (type);
300 DCL_PTR_VOLATILE (ptr) = SPEC_VOLATILE (type);
301 switch (SPEC_SCLS (type))
304 DCL_TYPE (ptr) = FPOINTER;
307 DCL_TYPE (ptr) = IPOINTER;
310 DCL_TYPE (ptr) = PPOINTER;
313 DCL_TYPE (ptr) = POINTER;
316 DCL_PTR_CONST (ptr) = port->mem.code_ro;
317 DCL_TYPE (ptr) = CPOINTER;
320 DCL_TYPE (ptr) = EEPPOINTER;
323 DCL_TYPE (ptr) = GPOINTER;
326 /* the storage class of type ends here */
329 SPEC_VOLATILE (type) = 0;
332 /* now change all the remaining unknown pointers
333 to generic pointers */
336 if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
337 DCL_TYPE (ptr) = GPOINTER;
341 /* same for the type although it is highly unlikely that
342 type will have a pointer */
345 if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
346 DCL_TYPE (type) = GPOINTER;
352 /*------------------------------------------------------------------*/
353 /* addDecl - adds a declarator @ the end of a chain */
354 /*------------------------------------------------------------------*/
356 addDecl (symbol * sym, int type, sym_link * p)
362 /* if we are passed a link then set head & tail */
371 head = tail = newLink ();
372 DCL_TYPE (head) = type;
375 /* if this is the first entry */
383 if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
385 sym->etype = mergeSpec (sym->etype, head);
389 if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
392 while (t->next != sym->etype)
395 tail->next = sym->etype;
399 sym->etype->next = head;
405 /* if the type is a unknown pointer and has
406 a tspec then take the storage class const & volatile
407 attribute from the tspec & make it those of this
411 DCL_TYPE (p) == UPOINTER &&
414 if (!IS_SPEC (sym->etype))
416 sym->etype = sym->etype->next = newLink ();
417 sym->etype->class = SPECIFIER;
419 SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
420 SPEC_CONST (sym->etype) = SPEC_CONST (DCL_TSPEC (p));
421 SPEC_VOLATILE (sym->etype) = SPEC_VOLATILE (DCL_TSPEC (p));
422 DCL_TSPEC (p) = NULL;
427 /*------------------------------------------------------------------*/
428 /* mergeSpec - merges two specifiers and returns the new one */
429 /*------------------------------------------------------------------*/
431 mergeSpec (sym_link * dest, sym_link * src)
433 /* if noun different then src overrides */
434 if (SPEC_NOUN (dest) != SPEC_NOUN (src) && !SPEC_NOUN (dest))
435 SPEC_NOUN (dest) = SPEC_NOUN (src);
437 if (!SPEC_SCLS (dest)) /* if destination has no storage class */
438 SPEC_SCLS (dest) = SPEC_SCLS (src);
440 /* copy all the specifications */
441 SPEC_LONG (dest) |= SPEC_LONG (src);
442 SPEC_SHORT (dest) |= SPEC_SHORT (src);
443 SPEC_USIGN (dest) |= SPEC_USIGN (src);
444 SPEC_STAT (dest) |= SPEC_STAT (src);
445 SPEC_EXTR (dest) |= SPEC_EXTR (src);
446 SPEC_ABSA (dest) |= SPEC_ABSA (src);
447 SPEC_RENT (dest) |= SPEC_RENT (src);
448 SPEC_INTN (dest) |= SPEC_INTN (src);
449 SPEC_BANK (dest) |= SPEC_BANK (src);
450 SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
451 SPEC_CRTCL (dest) |= SPEC_CRTCL (src);
452 SPEC_ADDR (dest) |= SPEC_ADDR (src);
453 SPEC_OCLS (dest) = SPEC_OCLS (src);
454 SPEC_BLEN (dest) |= SPEC_BLEN (src);
455 SPEC_BSTR (dest) |= SPEC_BSTR (src);
456 SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
457 SPEC_NONBANKED (dest) |= SPEC_NONBANKED (src);
459 if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
460 SPEC_STRUCT (dest) = SPEC_STRUCT (src);
465 /*------------------------------------------------------------------*/
466 /* cloneSpec - copies the entire spec and returns a new spec */
467 /*------------------------------------------------------------------*/
469 cloneSpec (sym_link * src)
473 /* go thru chain till we find the specifier */
474 while (src && src->class != SPECIFIER)
478 memcpy (spec, src, sizeof (sym_link));
482 /*------------------------------------------------------------------*/
483 /* genSymName - generates and returns a name used for anonymous vars */
484 /*------------------------------------------------------------------*/
486 genSymName (int level)
488 static int gCount = 0;
489 static char gname[SDCC_NAME_MAX + 1];
491 sprintf (gname, "__%04d%04d", level, gCount++);
495 /*------------------------------------------------------------------*/
496 /* getSpec - returns the specifier part from a declaration chain */
497 /*------------------------------------------------------------------*/
499 getSpec (sym_link * p)
504 while (p && !(IS_SPEC (p)))
510 /*------------------------------------------------------------------*/
511 /* newCharLink() - creates an int type */
512 /*------------------------------------------------------------------*/
519 p->class = SPECIFIER;
520 SPEC_NOUN (p) = V_CHAR;
525 /*------------------------------------------------------------------*/
526 /* newFloatLink - a new Float type */
527 /*------------------------------------------------------------------*/
534 p->class = SPECIFIER;
535 SPEC_NOUN (p) = V_FLOAT;
540 /*------------------------------------------------------------------*/
541 /* newLongLink() - new long type */
542 /*------------------------------------------------------------------*/
549 p->class = SPECIFIER;
550 SPEC_NOUN (p) = V_INT;
556 /*------------------------------------------------------------------*/
557 /* newIntLink() - creates an int type */
558 /*------------------------------------------------------------------*/
565 p->class = SPECIFIER;
566 SPEC_NOUN (p) = V_INT;
571 /*------------------------------------------------------------------*/
572 /* getSize - returns size of a type chain in bits */
573 /*------------------------------------------------------------------*/
575 getSize (sym_link * p)
577 /* if nothing return 0 */
581 { /* if this is the specifier then */
582 switch (SPEC_NOUN (p))
583 { /* depending on the specifier type */
585 return (IS_LONG (p) ? LONGSIZE : (IS_SHORT (p) ? SHORTSIZE : INTSIZE));
593 return SPEC_STRUCT (p)->size;
599 return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
605 /* this is a specifier */
606 switch (DCL_TYPE (p))
611 return DCL_ELEM (p) * getSize (p->next);
628 /*------------------------------------------------------------------*/
629 /* bitsForType - returns # of bits required to store this type */
630 /*------------------------------------------------------------------*/
632 bitsForType (sym_link * p)
634 /* if nothing return 0 */
639 { /* if this is the specifier then */
641 switch (SPEC_NOUN (p))
642 { /* depending on the specifier type */
644 return (IS_LONG (p) ? LONGSIZE * 8 : (IS_SHORT (p) ? SHORTSIZE * 8 : INTSIZE * 8));
646 return FLOATSIZE * 8;
652 return SPEC_STRUCT (p)->size * 8;
658 return SPEC_BLEN (p);
664 /* this is a specifier */
665 switch (DCL_TYPE (p))
670 return DCL_ELEM (p) * getSize (p->next) * 8;
674 return (PTRSIZE * 8);
678 return (FPTRSIZE * 8);
680 return (GPTRSIZE * 8);
687 /*------------------------------------------------------------------*/
688 /* copySymbolChain - copies a symbol chain */
689 /*------------------------------------------------------------------*/
691 copySymbolChain (symbol * src)
698 dest = copySymbol (src);
699 dest->next = copySymbolChain (src->next);
703 /*------------------------------------------------------------------*/
704 /* copySymbol - makes a copy of a symbol */
705 /*------------------------------------------------------------------*/
707 copySymbol (symbol * src)
714 dest = newSymbol (src->name, src->level);
715 memcpy (dest, src, sizeof (symbol));
716 dest->level = src->level;
717 dest->block = src->block;
718 dest->ival = copyIlist (src->ival);
719 dest->type = copyLinkChain (src->type);
720 dest->etype = getSpec (dest->type);
722 dest->args = copyValueChain (src->args);
723 dest->key = src->key;
724 dest->calleeSave = src->calleeSave;
725 dest->allocreq = src->allocreq;
729 /*------------------------------------------------------------------*/
730 /* reverseSyms - reverses the links for a symbol chain */
731 /*------------------------------------------------------------------*/
733 reverseSyms (symbol * sym)
735 symbol *prev, *curr, *next;
750 sym->next = (void *) NULL;
754 /*------------------------------------------------------------------*/
755 /* reverseLink - reverses the links for a type chain */
756 /*------------------------------------------------------------------*/
758 reverseLink (sym_link * type)
760 sym_link *prev, *curr, *next;
775 type->next = (void *) NULL;
779 /*------------------------------------------------------------------*/
780 /* addSymChain - adds a symbol chain to the symboltable */
781 /*------------------------------------------------------------------*/
783 addSymChain (symbol * symHead)
785 symbol *sym = symHead;
788 for (; sym != NULL; sym = sym->next)
791 /* if already exists in the symbol table then check if
792 the previous was an extern definition if yes then
793 then check if the type match, if the types match then
794 delete the current entry and add the new entry */
795 if ((csym = findSymWithLevel (SymbolTab, sym)) &&
796 csym->level == sym->level)
799 /* previous definition extern ? */
800 if (IS_EXTERN (csym->etype))
802 /* do types match ? */
803 if (checkType (csym->type, sym->type) != 1)
805 werror (E_DUPLICATE, csym->name);
807 /* delete current entry */
808 deleteSym (SymbolTab, csym, csym->name);
810 addSym (SymbolTab, sym, sym->name, sym->level, sym->block);
812 else /* not extern */
813 werror (E_DUPLICATE, sym->name);
817 /* check if previously defined */
818 if (csym && csym->level == sym->level)
820 /* if the previous one was declared as extern */
821 /* then check the type with the current one */
822 if (IS_EXTERN (csym->etype))
824 if (checkType (csym->type, sym->type) <= 0)
825 werror (W_EXTERN_MISMATCH, csym->name);
829 addSym (SymbolTab, sym, sym->name, sym->level, sym->block);
834 /*------------------------------------------------------------------*/
835 /* funcInChain - DCL Type 'FUNCTION' found in type chain */
836 /*------------------------------------------------------------------*/
838 funcInChain (sym_link * lnk)
849 /*------------------------------------------------------------------*/
850 /* structElemType - returns the type info of a sturct member */
851 /*------------------------------------------------------------------*/
853 structElemType (sym_link * stype, value * id, value ** argsp)
855 symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
856 sym_link *type, *etype;
857 sym_link *petype = getSpec (stype);
862 /* look for the id */
865 if (strcmp (fields->rname, id->name) == 0)
869 *argsp = fields->args;
871 type = copyLinkChain (fields->type);
872 etype = getSpec (type);
873 SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
874 SPEC_SCLS (etype) : SPEC_SCLS (petype));
877 fields = fields->next;
879 werror (E_NOT_MEMBER, id->name);
884 /*------------------------------------------------------------------*/
885 /* getStructElement - returns element of a tructure definition */
886 /*------------------------------------------------------------------*/
888 getStructElement (structdef * sdef, symbol * sym)
892 for (field = sdef->fields; field; field = field->next)
893 if (strcmp (field->name, sym->name) == 0)
896 werror (E_NOT_MEMBER, sym->name);
901 /*------------------------------------------------------------------*/
902 /* compStructSize - computes the size of a structure */
903 /*------------------------------------------------------------------*/
905 compStructSize (int su, structdef * sdef)
907 int sum = 0, usum = 0;
911 /* for the identifiers */
916 /* create the internal name for this variable */
917 sprintf (loop->rname, "_%s", loop->name);
918 loop->offset = (su == UNION ? sum = 0 : sum);
919 SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
921 /* if this is a bit field */
925 /* change it to a unsigned bit */
926 SPEC_NOUN (loop->etype) = V_BIT;
927 SPEC_USIGN (loop->etype) = 1;
928 /* check if this fit into the remaining */
929 /* bits of this byte else align it to the */
930 /* next byte boundary */
931 if ((SPEC_BLEN (loop->etype) = loop->bitVar) <= (8 - bitOffset))
933 SPEC_BSTR (loop->etype) = bitOffset;
934 if ((bitOffset += (loop->bitVar % 8)) == 8)
941 SPEC_BSTR (loop->etype) = bitOffset;
942 sum += (loop->bitVar / 8);
943 bitOffset += (loop->bitVar % 8);
945 /* if this is the last field then pad */
946 if (!loop->next && bitOffset && bitOffset != 8)
955 sum += getSize (loop->type);
958 /* if function then do the arguments for it */
959 if (funcInChain (loop->type))
961 processFuncArgs (loop, 1);
966 /* if this is not a bitfield but the */
967 /* previous one was and did not take */
968 /* the whole byte then pad the rest */
969 if ((loop && !loop->bitVar) && bitOffset)
975 /* if union then size = sizeof larget field */
977 usum = max (usum, sum);
981 return (su == UNION ? usum : sum);
984 /*------------------------------------------------------------------*/
985 /* checkSClass - check the storage class specification */
986 /*------------------------------------------------------------------*/
988 checkSClass (symbol * sym)
990 /* type is literal can happen foe enums change
992 if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
993 SPEC_SCLS (sym->etype) = S_AUTO;
995 /* if sfr or sbit then must also be */
996 /* volatile the initial value will be xlated */
997 /* to an absolute address */
998 if (SPEC_SCLS (sym->etype) == S_SBIT ||
999 SPEC_SCLS (sym->etype) == S_SFR)
1001 SPEC_VOLATILE (sym->etype) = 1;
1002 /* if initial value given */
1005 SPEC_ABSA (sym->etype) = 1;
1006 SPEC_ADDR (sym->etype) =
1007 (int) list2int (sym->ival);
1012 /* if absolute address given then it mark it as
1014 if (IS_ABSOLUTE (sym->etype))
1015 SPEC_VOLATILE (sym->etype) = 1;
1017 /* global variables declared const put into code */
1018 if (sym->level == 0 &&
1019 SPEC_SCLS (sym->etype) == S_CONSTANT)
1021 SPEC_SCLS (sym->etype) = S_CODE;
1022 SPEC_CONST (sym->etype) = 1;
1025 /* global variable in code space is a constant */
1026 if (sym->level == 0 &&
1027 SPEC_SCLS (sym->etype) == S_CODE &&
1029 SPEC_CONST (sym->etype) = 1;
1032 /* if bit variable then no storage class can be */
1033 /* specified since bit is already a storage */
1034 if (IS_BITVAR (sym->etype) &&
1035 (SPEC_SCLS (sym->etype) != S_FIXED &&
1036 SPEC_SCLS (sym->etype) != S_SBIT &&
1037 SPEC_SCLS (sym->etype) != S_BIT)
1040 werror (E_BITVAR_STORAGE, sym->name);
1041 SPEC_SCLS (sym->etype) = S_FIXED;
1044 /* extern variables cannot be initialized */
1045 if (IS_EXTERN (sym->etype) && sym->ival)
1047 werror (E_EXTERN_INIT, sym->name);
1051 /* if this is an automatic symbol then */
1052 /* storage class will be ignored and */
1053 /* symbol will be allocated on stack/ */
1054 /* data depending on flag */
1056 (options.stackAuto || reentrant) &&
1057 (SPEC_SCLS (sym->etype) != S_AUTO &&
1058 SPEC_SCLS (sym->etype) != S_FIXED &&
1059 SPEC_SCLS (sym->etype) != S_REGISTER &&
1060 SPEC_SCLS (sym->etype) != S_STACK &&
1061 SPEC_SCLS (sym->etype) != S_XSTACK &&
1062 SPEC_SCLS (sym->etype) != S_CONSTANT))
1065 werror (E_AUTO_ASSUMED, sym->name);
1066 SPEC_SCLS (sym->etype) = S_AUTO;
1069 /* automatic symbols cannot be given */
1070 /* an absolute address ignore it */
1072 SPEC_ABSA (sym->etype) &&
1073 (options.stackAuto || reentrant))
1075 werror (E_AUTO_ABSA, sym->name);
1076 SPEC_ABSA (sym->etype) = 0;
1079 /* arrays & pointers cannot be defined for bits */
1080 /* SBITS or SFRs or BIT */
1081 if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1082 (SPEC_NOUN (sym->etype) == V_BIT ||
1083 SPEC_NOUN (sym->etype) == V_SBIT ||
1084 SPEC_SCLS (sym->etype) == S_SFR))
1085 werror (E_BIT_ARRAY, sym->name);
1087 /* if this is a bit|sbit then set length & start */
1088 if (SPEC_NOUN (sym->etype) == V_BIT ||
1089 SPEC_NOUN (sym->etype) == V_SBIT)
1091 SPEC_BLEN (sym->etype) = 1;
1092 SPEC_BSTR (sym->etype) = 0;
1095 /* variables declared in CODE space must have */
1096 /* initializers if not an extern */
1097 if (SPEC_SCLS (sym->etype) == S_CODE &&
1098 sym->ival == NULL &&
1100 port->mem.code_ro &&
1101 !IS_EXTERN (sym->etype) &&
1102 !funcInChain (sym->type))
1103 werror (E_CODE_NO_INIT, sym->name);
1105 /* if parameter or local variable then change */
1106 /* the storage class to reflect where the var will go */
1107 if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED)
1109 if (options.stackAuto || (currFunc && IS_RENT (currFunc->etype)))
1111 SPEC_SCLS (sym->etype) = (options.useXstack ?
1112 S_XSTACK : S_STACK);
1116 /* hack-o-matic! I see no reason why the useXstack option should ever
1117 * control this allcoation, but the code was originally that way, and
1118 * changing it for non-390 ports breaks the compiler badly.
1120 bool useXdata = IS_DS390_PORT ? options.model : options.useXstack;
1121 SPEC_SCLS (sym->etype) = (useXdata ?
1127 /*------------------------------------------------------------------*/
1128 /* changePointer - change pointer to functions */
1129 /*------------------------------------------------------------------*/
1131 changePointer (symbol * sym)
1135 /* go thru the chain of declarations */
1136 /* if we find a pointer to a function */
1137 /* unconditionally change it to a ptr */
1139 for (p = sym->type; p; p = p->next)
1141 if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1142 DCL_TYPE (p) = GPOINTER;
1143 if (IS_PTR (p) && IS_FUNC (p->next))
1144 DCL_TYPE (p) = CPOINTER;
1148 /*------------------------------------------------------------------*/
1149 /* checkDecl - does semantic validation of a declaration */
1150 /*------------------------------------------------------------------*/
1152 checkDecl (symbol * sym)
1155 checkSClass (sym); /* check the storage class */
1156 changePointer (sym); /* change pointers if required */
1158 /* if this is an array without any dimension
1159 then update the dimension from the initial value */
1160 if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1161 DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1166 /*------------------------------------------------------------------*/
1167 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1168 /*------------------------------------------------------------------*/
1170 copyLinkChain (sym_link * p)
1172 sym_link *head, *curr, *loop;
1175 head = loop = (curr ? newLink () : (void *) NULL);
1178 memcpy (loop, curr, sizeof (sym_link)); /* copy it */
1179 loop->next = (curr->next ? newLink () : (void *) NULL);
1188 /*------------------------------------------------------------------*/
1189 /* cleanUpBlock - cleansup the symbol table specified for all the */
1190 /* symbols in the given block */
1191 /*------------------------------------------------------------------*/
1193 cleanUpBlock (bucket ** table, int block)
1198 /* go thru the entire table */
1199 for (i = 0; i < 256; i++)
1201 for (chain = table[i]; chain; chain = chain->next)
1203 if (chain->block >= block)
1205 deleteSym (table, chain->sym, chain->name);
1211 /*------------------------------------------------------------------*/
1212 /* cleanUpLevel - cleansup the symbol table specified for all the */
1213 /* symbols in the given level */
1214 /*------------------------------------------------------------------*/
1216 cleanUpLevel (bucket ** table, int level)
1221 /* go thru the entire table */
1222 for (i = 0; i < 256; i++)
1224 for (chain = table[i]; chain; chain = chain->next)
1226 if (chain->level >= level)
1228 deleteSym (table, chain->sym, chain->name);
1234 /*------------------------------------------------------------------*/
1235 /* computeType - computes the resultant type from two types */
1236 /*------------------------------------------------------------------*/
1238 computeType (sym_link * type1, sym_link * type2)
1242 sym_link *etype1 = getSpec (type1);
1243 sym_link *etype2 = getSpec (type2);
1245 /* if one of them is a float then result is a float */
1246 /* here we assume that the types passed are okay */
1247 /* and can be cast to one another */
1248 /* which ever is greater in size */
1249 if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1250 rType = newFloatLink ();
1252 /* if only one of them is a bit variable
1253 then the other one prevails */
1254 if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1255 rType = copyLinkChain (type2);
1256 else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1257 rType = copyLinkChain (type1);
1259 /* if one of them is a pointer then that
1262 rType = copyLinkChain (type1);
1263 else if (IS_PTR (type2))
1264 rType = copyLinkChain (type2);
1265 else if (getSize (type1) > getSize (type2))
1266 rType = copyLinkChain (type1);
1268 rType = copyLinkChain (type2);
1270 reType = getSpec (rType);
1272 /* if either of them unsigned then make this unsigned */
1273 if ((SPEC_USIGN (etype1) || SPEC_USIGN (etype2)) && !IS_FLOAT (reType))
1274 SPEC_USIGN (reType) = 1;
1276 /* if result is a literal then make not so */
1277 if (IS_LITERAL (reType))
1278 SPEC_SCLS (reType) = S_REGISTER;
1283 /*------------------------------------------------------------------*/
1284 /* checkType - will do type check return 1 if match */
1285 /*------------------------------------------------------------------*/
1287 checkType (sym_link * dest, sym_link * src)
1298 /* if dest is a declarator then */
1303 if (DCL_TYPE (src) == DCL_TYPE (dest))
1304 return checkType (dest->next, src->next);
1305 else if (IS_PTR (src) && IS_PTR (dest))
1307 else if (IS_PTR (dest) && IS_ARRAY (src))
1309 else if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1310 return -1 * checkType (dest->next, src);
1314 else if (IS_PTR (dest) && IS_INTEGRAL (src))
1320 /* if one is a specifier and the other is not */
1321 if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1322 (IS_SPEC (dest) && !IS_SPEC (src)))
1325 /* if one of them is a void then ok */
1326 if (SPEC_NOUN (dest) == V_VOID &&
1327 SPEC_NOUN (src) != V_VOID)
1330 if (SPEC_NOUN (dest) != V_VOID &&
1331 SPEC_NOUN (src) == V_VOID)
1334 /* char === to short */
1335 if (SPEC_NOUN (dest) == V_CHAR &&
1336 SPEC_NOUN (src) == V_INT &&
1338 return (SPEC_USIGN (src) == SPEC_USIGN (dest) ? 1 : -2);
1340 if (SPEC_NOUN (src) == V_CHAR &&
1341 SPEC_NOUN (dest) == V_INT &&
1343 return (SPEC_USIGN (src) == SPEC_USIGN (dest) ? 1 : -2);
1345 /* if they are both bitfields then if the lengths
1346 and starts don't match */
1347 if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1348 (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1349 SPEC_BSTR (dest) != SPEC_BSTR (src)))
1352 /* it is a specifier */
1353 if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1355 if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1356 IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1357 getSize (dest) == getSize (src))
1359 else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1364 else if (IS_STRUCT (dest))
1366 if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1371 if (SPEC_LONG (dest) != SPEC_LONG (src))
1374 if (SPEC_SHORT (dest) != SPEC_SHORT (src))
1377 if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1383 /*------------------------------------------------------------------*/
1384 /* inCalleeSaveList - return 1 if found in calle save list */
1385 /*------------------------------------------------------------------*/
1387 inCalleeSaveList (char *s)
1391 for (i = 0; options.calleeSaves[i]; i++)
1392 if (strcmp (options.calleeSaves[i], s) == 0)
1398 /*-----------------------------------------------------------------*/
1399 /* aggregateArgToPointer: change an agggregate type function */
1400 /* argument to a pointer to that type. */
1401 /*-----------------------------------------------------------------*/
1403 aggregateArgToPointer (value * val)
1405 if (IS_AGGREGATE (val->type))
1407 /* if this is a structure */
1408 /* then we need to add a new link */
1409 if (IS_STRUCT (val->type))
1411 /* first lets add DECLARATOR type */
1412 sym_link *p = val->type;
1414 werror (W_STRUCT_AS_ARG, val->name);
1415 val->type = newLink ();
1416 val->type->next = p;
1419 /* change to a pointer depending on the */
1420 /* storage class specified */
1421 switch (SPEC_SCLS (val->etype))
1424 DCL_TYPE (val->type) = IPOINTER;
1427 DCL_TYPE (val->type) = PPOINTER;
1432 /* The AUTO and REGISTER classes should probably
1433 * also become generic pointers, but I haven't yet
1434 * devised a test case for that.
1436 DCL_TYPE (val->type) = GPOINTER;
1443 DCL_TYPE (val->type) = POINTER;
1446 DCL_TYPE (val->type) = CPOINTER;
1449 DCL_TYPE (val->type) = FPOINTER;
1452 DCL_TYPE (val->type) = EEPPOINTER;
1455 DCL_TYPE (val->type) = GPOINTER;
1458 /* is there is a symbol associated then */
1459 /* change the type of the symbol as well */
1462 val->sym->type = copyLinkChain (val->type);
1463 val->sym->etype = getSpec (val->sym->type);
1467 /*------------------------------------------------------------------*/
1468 /* checkFunction - does all kinds of check on a function */
1469 /*------------------------------------------------------------------*/
1471 checkFunction (symbol * sym)
1474 value *exargs, *acargs;
1477 /* if not type then some kind of error */
1481 /* if the function has no type then make it return int */
1482 if (!sym->type->next)
1483 sym->type->next = sym->etype = newIntLink ();
1485 /* function cannot return aggregate */
1486 if (IS_AGGREGATE (sym->type->next))
1488 werror (E_FUNC_AGGR, sym->name);
1492 /* function cannot return bit */
1493 if (IS_BITVAR (sym->type->next))
1495 werror (E_FUNC_BIT, sym->name);
1499 /* check if this function is defined as calleeSaves
1500 then mark it as such */
1501 sym->calleeSave = inCalleeSaveList (sym->name);
1503 /* if interrupt service routine */
1504 /* then it cannot have arguments */
1505 if (sym->args && IS_ISR (sym->etype) && !IS_VOID (sym->args->type))
1507 werror (E_INT_ARGS, sym->name);
1511 if (!(csym = findSym (SymbolTab, sym, sym->name)))
1512 return 1; /* not defined nothing more to check */
1514 /* check if body already present */
1515 if (csym && csym->fbody)
1517 werror (E_FUNC_BODY, sym->name);
1521 /* check the return value type */
1522 if (checkType (csym->type, sym->type) <= 0)
1524 werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1525 werror (E_CONTINUE, "previous defintion type ");
1526 printTypeChain (csym->type, stderr);
1527 fprintf (stderr, "\n");
1528 werror (E_CONTINUE, "current definition type ");
1529 printTypeChain (sym->type, stderr);
1530 fprintf (stderr, "\n");
1534 if (SPEC_INTRTN (csym->etype) != SPEC_INTRTN (sym->etype))
1536 werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1540 if (SPEC_BANK (csym->etype) != SPEC_BANK (sym->etype))
1542 werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1546 /* compare expected agrs with actual args */
1547 exargs = csym->args;
1550 /* for all the expected args do */
1553 exargs = exargs->next, acargs = acargs->next, argCnt++)
1556 /* If the actual argument is an array, any prototype
1557 * will have modified it to a pointer. Duplicate that
1560 if (IS_AGGREGATE (acargs->type))
1562 checkValue = copyValue (acargs);
1563 aggregateArgToPointer (checkValue);
1567 checkValue = acargs;
1570 if (checkType (exargs->type, checkValue->type) <= 0)
1572 werror (E_ARG_TYPE, argCnt);
1577 /* if one them ended we have a problem */
1578 if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1579 (!exargs && acargs && !IS_VOID (acargs->type)))
1580 werror (E_ARG_COUNT);
1582 /* replace with this defition */
1583 sym->cdef = csym->cdef;
1584 deleteSym (SymbolTab, csym, csym->name);
1585 addSym (SymbolTab, sym, sym->name, sym->level, sym->block);
1586 if (IS_EXTERN (csym->etype) && !
1587 IS_EXTERN (sym->etype))
1589 addSet (&publics, sym);
1594 /*-----------------------------------------------------------------*/
1595 /* processFuncArgs - does some processing with function args */
1596 /*-----------------------------------------------------------------*/
1598 processFuncArgs (symbol * func, int ignoreName)
1604 /* if this function has variable argument list */
1605 /* then make the function a reentrant one */
1607 SPEC_RENT (func->etype) = 1;
1609 /* check if this function is defined as calleeSaves
1610 then mark it as such */
1611 func->calleeSave = inCalleeSaveList (func->name);
1613 val = func->args; /* loop thru all the arguments */
1615 /* if it is void then remove parameters */
1616 if (val && IS_VOID (val->type))
1622 /* reset regparm for the port */
1623 (*port->reset_regparms) ();
1624 /* if any of the arguments is an aggregate */
1625 /* change it to pointer to the same type */
1628 /* mark it as a register parameter if
1629 the function does not have VA_ARG
1630 and as port dictates
1631 not inhibited by command line option or #pragma */
1632 if (!func->hasVargs &&
1633 !options.noregparms &&
1634 !IS_RENT (func->etype) &&
1635 (*port->reg_parm) (val->type))
1637 SPEC_REGPARM (val->etype) = 1;
1640 if (IS_AGGREGATE (val->type))
1642 aggregateArgToPointer (val);
1648 /* if this function is reentrant or */
1649 /* automatics r 2b stacked then nothing */
1650 if (IS_RENT (func->etype) || options.stackAuto)
1658 /* if a symbolname is not given */
1659 /* synthesize a variable name */
1663 sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
1664 val->sym = newSymbol (val->name, 1);
1665 SPEC_OCLS (val->etype) = port->mem.default_local_map;
1666 val->sym->type = copyLinkChain (val->type);
1667 val->sym->etype = getSpec (val->sym->type);
1668 val->sym->_isparm = 1;
1669 strcpy (val->sym->rname, val->name);
1670 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1671 SPEC_STAT (func->etype);
1672 addSymChain (val->sym);
1675 else /* symbol name given create synth name */
1678 sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
1679 strcpy (val->sym->rname, val->name);
1680 val->sym->_isparm = 1;
1681 SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
1682 (options.model != MODEL_SMALL ? xdata : data);
1683 SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
1684 SPEC_STAT (func->etype);
1690 /*-----------------------------------------------------------------*/
1691 /* isSymbolEqual - compares two symbols return 1 if they match */
1692 /*-----------------------------------------------------------------*/
1694 isSymbolEqual (symbol * dest, symbol * src)
1696 /* if pointers match then equal */
1700 /* if one of them is null then don't match */
1704 /* if both of them have rname match on rname */
1705 if (dest->rname[0] && src->rname[0])
1706 return (!strcmp (dest->rname, src->rname));
1708 /* otherwise match on name */
1709 return (!strcmp (dest->name, src->name));
1712 /*-----------------------------------------------------------------*/
1713 /* printTypeChain - prints the type chain in human readable form */
1714 /*-----------------------------------------------------------------*/
1716 printTypeChain (sym_link * type, FILE * of)
1730 switch (DCL_TYPE (type))
1733 fprintf (of, "function ");
1736 fprintf (of, "_generic * ");
1737 if (DCL_PTR_CONST (type))
1738 fprintf (of, "const ");
1741 fprintf (of, "_code * ");
1742 if (DCL_PTR_CONST (type))
1743 fprintf (of, "const ");
1746 fprintf (of, "_far * ");
1747 if (DCL_PTR_CONST (type))
1748 fprintf (of, "const ");
1751 fprintf (of, "_eeprom * ");
1752 if (DCL_PTR_CONST (type))
1753 fprintf (of, "const ");
1757 fprintf (of, "_near * ");
1758 if (DCL_PTR_CONST (type))
1759 fprintf (of, "const ");
1762 fprintf (of, "_idata *");
1763 if (DCL_PTR_CONST (type))
1764 fprintf (of, "const ");
1767 fprintf (of, "_pdata *");
1768 if (DCL_PTR_CONST (type))
1769 fprintf (of, "const ");
1772 fprintf (of, " _unkown *");
1773 if (DCL_PTR_CONST (type))
1774 fprintf (of, "const ");
1778 fprintf (of, "array of ");
1784 if (SPEC_VOLATILE (type))
1785 fprintf (of, "volatile ");
1786 if (SPEC_USIGN (type))
1787 fprintf (of, "unsigned ");
1788 if (SPEC_CONST (type))
1789 fprintf (of, "const ");
1791 switch (SPEC_NOUN (type))
1795 fprintf (of, "long ");
1796 else if (IS_SHORT (type))
1797 fprintf (of, "short ");
1799 fprintf (of, "int ");
1803 fprintf (of, "char ");
1807 fprintf (of, "void ");
1811 fprintf (of, "float ");
1815 fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
1819 fprintf (of, "sbit ");
1823 fprintf (of, "bit {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
1836 /*-----------------------------------------------------------------*/
1837 /* cdbTypeInfo - print the type information for debugger */
1838 /*-----------------------------------------------------------------*/
1840 cdbTypeInfo (sym_link * type, FILE * of)
1842 fprintf (of, "{%d}", getSize (type));
1847 switch (DCL_TYPE (type))
1850 fprintf (of, "DF,");
1853 fprintf (of, "DG,");
1856 fprintf (of, "DC,");
1859 fprintf (of, "DX,");
1862 fprintf (of, "DD,");
1865 fprintf (of, "DI,");
1868 fprintf (of, "DP,");
1871 fprintf (of, "DA,");
1874 fprintf (of, "DA%d,", DCL_ELEM (type));
1882 switch (SPEC_NOUN (type))
1887 else if (IS_SHORT (type))
1906 fprintf (of, "ST%s", SPEC_STRUCT (type)->tag);
1914 fprintf (of, "SB%d$%d", SPEC_BSTR (type), SPEC_BLEN (type));
1921 if (SPEC_USIGN (type))
1929 /*-----------------------------------------------------------------*/
1930 /* cdbSymbol - prints a symbol & its type information for debugger */
1931 /*-----------------------------------------------------------------*/
1933 cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc)
1945 fprintf (of, "S:"); /* symbol record */
1946 /* if this is not a structure symbol then
1947 we need to figure out the scope information */
1953 if (IS_STATIC (sym->etype))
1954 fprintf (of, "F%s$", moduleName); /* scope is file */
1956 fprintf (of, "G$"); /* scope is global */
1959 /* symbol is local */
1960 fprintf (of, "L%s$", (sym->localof ? sym->localof->name : "-null-"));
1963 fprintf (of, "S$"); /* scope is structure */
1965 /* print the name, & mangled name */
1966 fprintf (of, "%s$%d$%d(", sym->name,
1967 sym->level, sym->block);
1969 cdbTypeInfo (sym->type, of);
1972 /* print the address space */
1973 map = SPEC_OCLS (sym->etype);
1974 fprintf (of, "%c,%d,%d",
1975 (map ? map->dbName : 'Z'), sym->onStack, SPEC_STAK (sym->etype));
1977 /* if assigned to registers then output register names */
1978 /* if this is a function then print
1979 if is it an interrupt routine & interrupt number
1980 and the register bank it is using */
1982 fprintf (of, ",%d,%d,%d", SPEC_INTRTN (sym->etype),
1983 SPEC_INTN (sym->etype), SPEC_BANK (sym->etype));
1984 /* alternate location to find this symbol @ : eg registers
1991 /*-----------------------------------------------------------------*/
1992 /* cdbStruct - print a structure for debugger */
1993 /*-----------------------------------------------------------------*/
1995 cdbStruct (structdef * sdef, int block, FILE * of,
1996 int inStruct, char *tag)
2001 /* if block # then must have function scope */
2002 fprintf (of, "F%s$", moduleName);
2003 fprintf (of, "%s[", (tag ? tag : sdef->tag));
2004 for (sym = sdef->fields; sym; sym = sym->next)
2006 fprintf (of, "({%d}", sym->offset);
2007 cdbSymbol (sym, of, TRUE, FALSE);
2015 /*------------------------------------------------------------------*/
2016 /* cdbStructBlock - calls struct printing for a blcks */
2017 /*------------------------------------------------------------------*/
2019 cdbStructBlock (int block, FILE * of)
2022 bucket **table = StructTab;
2026 /* go thru the entire table */
2027 for (i = 0; i < 256; i++)
2029 for (chain = table[i]; chain; chain = chain->next)
2031 if (chain->block >= block)
2033 cdbStruct ((structdef *) chain->sym, chain->block, of, 0, NULL);
2039 /*-----------------------------------------------------------------*/
2040 /* powof2 - returns power of two for the number if number is pow 2 */
2041 /*-----------------------------------------------------------------*/
2043 powof2 (unsigned long num)
2056 if (n1s > 1 || nshifts == 0)
2072 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2073 symbol *__muldiv[3][3][2];
2074 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2075 sym_link *__multypes[3][2];
2076 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2077 symbol *__conv[2][3][2];
2079 sym_link *floatType;
2082 _makeRegParam (symbol * sym)
2086 val = sym->args; /* loop thru all the arguments */
2088 /* reset regparm for the port */
2089 (*port->reset_regparms) ();
2092 SPEC_REGPARM (val->etype) = 1;
2093 sym->argStack -= getSize (val->type);
2098 /*-----------------------------------------------------------------*/
2099 /* initCSupport - create functions for C support routines */
2100 /*-----------------------------------------------------------------*/
2104 const char *smuldivmod[] =
2108 const char *sbwd[] =
2110 "char", "int", "long"
2117 int bwd, su, muldivmod, tofrom;
2119 floatType = newFloatLink ();
2121 for (bwd = 0; bwd < 3; bwd++)
2138 __multypes[bwd][0] = l;
2139 __multypes[bwd][1] = copyLinkChain (l);
2140 SPEC_USIGN (__multypes[bwd][1]) = 1;
2143 __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2144 __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2145 __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2146 __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2147 __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2148 __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2149 __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2150 __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2151 __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2152 __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2154 for (tofrom = 0; tofrom < 2; tofrom++)
2156 for (bwd = 0; bwd < 3; bwd++)
2158 for (su = 0; su < 2; su++)
2162 sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]);
2163 __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2167 sprintf (buffer, "__%s%s2fs", ssu[su], sbwd[bwd]);
2168 __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2174 for (muldivmod = 0; muldivmod < 3; muldivmod++)
2176 for (bwd = 0; bwd < 3; bwd++)
2178 for (su = 0; su < 2; su++)
2180 sprintf (buffer, "_%s%s%s",
2181 smuldivmod[muldivmod],
2184 __muldiv[muldivmod][bwd][su] = funcOfType (buffer, __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2185 SPEC_NONBANKED (__muldiv[muldivmod][bwd][su]->etype) = 1;
2186 if (bwd < port->muldiv.force_reg_param_below)
2187 _makeRegParam (__muldiv[muldivmod][bwd][su]);