X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCsymt.c;h=4717bf10b60664e0e99ea3d0424ed723a9ac5f44;hb=c4b55ee40ddb79b816c42b1567dc9b5858153b66;hp=bebf6f7449e05934c7b41a5f0b02945583b433a2;hpb=91de9714407a8df390127a3bdb92fec4668184d5;p=fw%2Fsdcc diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c index bebf6f74..4717bf10 100644 --- a/src/SDCCsymt.c +++ b/src/SDCCsymt.c @@ -98,16 +98,16 @@ addSym (bucket ** stab, void *sym, char *sname, int level, - int block) + int block, + int checkType) { int i; /* index into the hash Table */ bucket *bp; /* temp bucket * */ - if (getenv("DEBUG_SANITY")) { - fprintf (stderr, "addSym: %s ", sname); - } - /* Make sure sym is a symbol and not a structdef */ - if (StructTab!=stab) { + if (checkType) { + if (getenv("DEBUG_SANITY")) { + fprintf (stderr, "addSym: %s ", sname); + } /* make sure the type is complete and sane */ checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name); } @@ -412,7 +412,7 @@ addDecl (symbol * sym, int type, sym_link * p) { if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail) { - sym->etype = mergeSpec (sym->etype, head); + sym->etype = mergeSpec (sym->etype, head, sym->name); } else { @@ -478,7 +478,7 @@ void checkTypeSanity(sym_link *etype, char *name) { noun=nounName(etype); if (getenv("DEBUG_SANITY")) { - fprintf (stderr, "checking sanity for %s\n", name); + fprintf (stderr, "checking sanity for %s %x\n", name, (int)etype); } if ((SPEC_NOUN(etype)==V_CHAR || @@ -499,7 +499,8 @@ void checkTypeSanity(sym_link *etype, char *name) { // special case for "short" if (etype->select.s._short) { - SPEC_NOUN(etype) = options.shortisint ? V_INT : V_CHAR; + SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT; + etype->select.s._short = 0; } /* if no noun e.g. @@ -523,10 +524,36 @@ void checkTypeSanity(sym_link *etype, char *name) { /*------------------------------------------------------------------*/ /* mergeSpec - merges two specifiers and returns the new one */ /*------------------------------------------------------------------*/ +#define LAST_MINUTE_2_3_0_FIX sym_link * -mergeSpec (sym_link * dest, sym_link * src) +mergeSpec (sym_link * dest, sym_link * src, char *name) { +#ifdef LAST_MINUTE_2_3_0_FIX + sym_link *symlink; + + if (!IS_SPEC(dest)) { + // This should not happen + fprintf (stderr, "*** internal error: can't merge declarators\n"); + } + if (!IS_SPEC(src)) { + // here we have a declarator as source, reverse them + symlink=src; + src=dest; + dest=symlink; + while (!IS_SPEC(dest)) { + // and find the specifier + dest=dest->next; + } + } else { + symlink=dest; + } +#endif + + if (getenv("DEBUG_mergeSpec")) { + fprintf (stderr, "mergeSpec: \"%s\"\n", name); + } + if (SPEC_NOUN(src)) { if (!SPEC_NOUN(dest)) { SPEC_NOUN(dest)=SPEC_NOUN(src); @@ -535,7 +562,7 @@ mergeSpec (sym_link * dest, sym_link * src) if (getenv("DEBUG_SANITY")) { fprintf (stderr, "mergeSpec: "); } - werror(E_TWO_OR_MORE_DATA_TYPES, yylval.yychar); + werror(E_TWO_OR_MORE_DATA_TYPES, name); } } @@ -547,7 +574,7 @@ mergeSpec (sym_link * dest, sym_link * src) if (getenv("DEBUG_SANITY")) { fprintf (stderr, "mergeSpec: "); } - werror(E_TWO_OR_MORE_STORAGE_CLASSES, yylval.yychar); + werror(E_TWO_OR_MORE_STORAGE_CLASSES, name); } } @@ -587,7 +614,11 @@ mergeSpec (sym_link * dest, sym_link * src) if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL) SPEC_STRUCT (dest) = SPEC_STRUCT (src); +#ifdef LAST_MINUTE_2_3_0_FIX + return symlink; +#else return dest; +#endif } /*------------------------------------------------------------------*/ @@ -913,49 +944,37 @@ addSymChain (symbol * symHead) symbol *sym = symHead; symbol *csym = NULL; - for (; sym != NULL; sym = sym->next) { changePointer(sym); + checkTypeSanity(sym->etype, sym->name); /* if already exists in the symbol table then check if - the previous was an extern definition if yes then + one of them is an extern definition if yes then then check if the type match, if the types match then delete the current entry and add the new entry */ if ((csym = findSymWithLevel (SymbolTab, sym)) && - csym->level == sym->level) - { - - /* previous definition extern ? */ - if (IS_EXTERN (csym->etype)) - { - /* do types match ? */ - if (checkType (csym->type, sym->type) != 1) - /* no then error */ - werror (E_DUPLICATE, csym->name); - - /* delete current entry */ - deleteSym (SymbolTab, csym, csym->name); - /* add new entry */ - addSym (SymbolTab, sym, sym->name, sym->level, sym->block); - } - else /* not extern */ - werror (E_DUPLICATE, sym->name); + csym->level == sym->level) { + + /* one definition extern ? */ + if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) { + /* do types match ? */ + if (compareType (csym->type, sym->type) != 1) { + /* no then error */ + werror (E_EXTERN_MISMATCH, csym->name); + continue; + } + /* delete current entry */ + deleteSym (SymbolTab, csym, csym->name); + } else { + /* not extern */ + werror (E_DUPLICATE, sym->name); continue; } + } - /* check if previously defined */ - if (csym && csym->level == sym->level) - { - /* if the previous one was declared as extern */ - /* then check the type with the current one */ - if (IS_EXTERN (csym->etype)) - { - if (checkType (csym->type, sym->type) <= 0) - werror (W_EXTERN_MISMATCH, csym->name); - } - } - addSym (SymbolTab, sym, sym->name, sym->level, sym->block); + /* add new entry */ + addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1); } } @@ -1107,11 +1126,18 @@ compStructSize (int su, structdef * sdef) static void checkSClass (symbol * sym) { + if (getenv("DEBUG_SANITY")) { + fprintf (stderr, "checkSClass: %s \n", sym->name); + } + if (strcmp(sym->name, "_testsGlobal")==0) { + printf ("oach\n"); + } + /* type is literal can happen foe enums change to auto */ if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype)) SPEC_SCLS (sym->etype) = S_AUTO; - + /* if sfr or sbit then must also be */ /* volatile the initial value will be xlated */ /* to an absolute address */ @@ -1128,26 +1154,24 @@ checkSClass (symbol * sym) sym->ival = NULL; } } - + /* if absolute address given then it mark it as volatile */ if (IS_ABSOLUTE (sym->etype)) SPEC_VOLATILE (sym->etype) = 1; - + /* global variables declared const put into code */ if (sym->level == 0 && - SPEC_SCLS (sym->etype) == S_CONSTANT) - { - SPEC_SCLS (sym->etype) = S_CODE; - SPEC_CONST (sym->etype) = 1; - } - + SPEC_CONST (sym->etype)) { + SPEC_SCLS (sym->etype) = S_CODE; + } + /* global variable in code space is a constant */ if (sym->level == 0 && SPEC_SCLS (sym->etype) == S_CODE && port->mem.code_ro) SPEC_CONST (sym->etype) = 1; - + /* if bit variable then no storage class can be */ /* specified since bit is already a storage */ @@ -1168,6 +1192,7 @@ checkSClass (symbol * sym) sym->ival = NULL; } +#if 0 /* if this is an automatic symbol then */ /* storage class will be ignored and */ /* symbol will be allocated on stack/ */ @@ -1178,13 +1203,29 @@ checkSClass (symbol * sym) SPEC_SCLS (sym->etype) != S_FIXED && SPEC_SCLS (sym->etype) != S_REGISTER && SPEC_SCLS (sym->etype) != S_STACK && - SPEC_SCLS (sym->etype) != S_XSTACK && - SPEC_SCLS (sym->etype) != S_CONSTANT)) + SPEC_SCLS (sym->etype) != S_XSTACK)) { werror (E_AUTO_ASSUMED, sym->name); SPEC_SCLS (sym->etype) = S_AUTO; } - +#else + /* if this is an atomatic symbol */ + if (sym->level && (options.stackAuto || reentrant)) { + if ((SPEC_SCLS (sym->etype) == S_AUTO || + SPEC_SCLS (sym->etype) == S_FIXED || + SPEC_SCLS (sym->etype) == S_REGISTER || + SPEC_SCLS (sym->etype) == S_STACK || + SPEC_SCLS (sym->etype) == S_XSTACK)) { + SPEC_SCLS (sym->etype) = S_AUTO; + } else { + /* storage class may only be specified for statics */ + if (!IS_STATIC(sym->etype)) { + werror (E_AUTO_ASSUMED, sym->name); + } + } + } +#endif + /* automatic symbols cannot be given */ /* an absolute address ignore it */ if (sym->level && @@ -1401,10 +1442,10 @@ computeType (sym_link * type1, sym_link * type2) } /*------------------------------------------------------------------*/ -/* checkType - will do type check return 1 if match */ +/* compareType - will do type check return 1 if match */ /*------------------------------------------------------------------*/ int -checkType (sym_link * dest, sym_link * src) +compareType (sym_link * dest, sym_link * src) { if (!dest && !src) return 1; @@ -1421,13 +1462,13 @@ checkType (sym_link * dest, sym_link * src) if (IS_DECL (src)) { if (DCL_TYPE (src) == DCL_TYPE (dest)) - return checkType (dest->next, src->next); + return compareType (dest->next, src->next); else if (IS_PTR (src) && IS_PTR (dest)) return -1; else if (IS_PTR (dest) && IS_ARRAY (src)) return -1; else if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src)) - return -1 * checkType (dest->next, src); + return -1 * compareType (dest->next, src); else return 0; } @@ -1487,7 +1528,7 @@ checkType (sym_link * dest, sym_link * src) } /*------------------------------------------------------------------*/ -/* inCalleeSaveList - return 1 if found in calle save list */ +/* inCalleeSaveList - return 1 if found in callee save list */ /*------------------------------------------------------------------*/ bool inCalleeSaveList (char *s) @@ -1578,6 +1619,7 @@ checkFunction (symbol * sym) { symbol *csym; value *exargs, *acargs; + value *checkValue; int argCnt = 0; if (getenv("DEBUG_SANITY")) { @@ -1632,7 +1674,7 @@ checkFunction (symbol * sym) } /* check the return value type */ - if (checkType (csym->type, sym->type) <= 0) + if (compareType (csym->type, sym->type) <= 0) { werror (E_PREV_DEF_CONFLICT, csym->name, "type"); werror (E_CONTINUE, "previous definition type "); @@ -1647,13 +1689,16 @@ checkFunction (symbol * sym) if (SPEC_INTRTN (csym->etype) != SPEC_INTRTN (sym->etype)) { werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt"); - return 0; } if (SPEC_BANK (csym->etype) != SPEC_BANK (sym->etype)) { werror (E_PREV_DEF_CONFLICT, csym->name, "using"); - return 0; + } + + if (SPEC_NAKED (csym->etype) != SPEC_NAKED (sym->etype)) + { + werror (E_PREV_DEF_CONFLICT, csym->name, "_naked"); } /* compare expected agrs with actual args */ @@ -1665,7 +1710,12 @@ checkFunction (symbol * sym) exargs && acargs; exargs = exargs->next, acargs = acargs->next, argCnt++) { - value *checkValue; + if (getenv("DEBUG_SANITY")) { + fprintf (stderr, "checkFunction: %s ", exargs->name); + } + /* make sure the type is complete and sane */ + checkTypeSanity(exargs->etype, exargs->name); + /* If the actual argument is an array, any prototype * will have modified it to a pointer. Duplicate that * change here. @@ -1680,7 +1730,7 @@ checkFunction (symbol * sym) checkValue = acargs; } - if (checkType (exargs->type, checkValue->type) <= 0) + if (compareType (exargs->type, checkValue->type) <= 0) { werror (E_ARG_TYPE, argCnt); return 0; @@ -1695,7 +1745,7 @@ checkFunction (symbol * sym) /* replace with this defition */ sym->cdef = csym->cdef; deleteSym (SymbolTab, csym, csym->name); - addSym (SymbolTab, sym, sym->name, sym->level, sym->block); + addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1); if (IS_EXTERN (csym->etype) && ! IS_EXTERN (sym->etype)) { @@ -2199,22 +2249,21 @@ symbol *__muldiv[3][3][2]; sym_link *__multypes[3][2]; /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */ symbol *__conv[2][3][2]; +/* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */ +symbol *__rlrr[2][3][2]; sym_link *floatType; -static void -_makeRegParam (symbol * sym) +static char * +_mangleFunctionName(char *in) { - value *val; - - val = sym->args; /* loop thru all the arguments */ - - /* reset regparm for the port */ - (*port->reset_regparms) (); - while (val) + if (port->getMangledFunctionName) { - SPEC_REGPARM (val->etype) = 1; - val = val->next; + return port->getMangledFunctionName(in); + } + else + { + return in; } } @@ -2236,8 +2285,12 @@ initCSupport () { "s", "u" }; + const char *srlrr[] = + { + "rl", "rr" + }; - int bwd, su, muldivmod, tofrom; + int bwd, su, muldivmod, tofrom, rlrr; floatType = newFloatLink (); @@ -2283,12 +2336,12 @@ initCSupport () if (tofrom) { sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]); - __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent); + __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], floatType, 1, options.float_rent); } else { sprintf (buffer, "__%s%s2fs", ssu[su], sbwd[bwd]); - __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent); + __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), floatType, __multypes[bwd][su], 1, options.float_rent); } } } @@ -2304,10 +2357,24 @@ initCSupport () smuldivmod[muldivmod], ssu[su], sbwd[bwd]); - __muldiv[muldivmod][bwd][su] = funcOfType (buffer, __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent); + __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent); SPEC_NONBANKED (__muldiv[muldivmod][bwd][su]->etype) = 1; - if (bwd < port->muldiv.force_reg_param_below) - _makeRegParam (__muldiv[muldivmod][bwd][su]); + } + } + } + + for (rlrr = 0; rlrr < 2; rlrr++) + { + for (bwd = 0; bwd < 3; bwd++) + { + for (su = 0; su < 2; su++) + { + sprintf (buffer, "_%s%s%s", + srlrr[rlrr], + ssu[su], + sbwd[bwd]); + __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent); + SPEC_NONBANKED (__rlrr[rlrr][bwd][su]->etype) = 1; } } }