X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCsymt.c;h=7dced18745cd139a6b365e60a3c55ec366822e8c;hb=c2029a0ae596f1a45bf8f0db2c4dd6d2a43f8f47;hp=6c199ee414895c94bf96c738e06d645b5554a4e4;hpb=49974e6371ce30581a87139d4c1e830e08153b0e;p=fw%2Fsdcc diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c index 6c199ee4..7dced187 100644 --- a/src/SDCCsymt.c +++ b/src/SDCCsymt.c @@ -217,13 +217,12 @@ findSymWithLevel (bucket ** stab, symbol * sym) **/ while (bp) { - if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level) { /* if this is parameter then nothing else need to be checked */ if (((symbol *) (bp->sym))->_isparm) return (bp->sym); - /* if levels match then block numbers hsould also match */ + /* if levels match then block numbers should also match */ if (bp->level && bp->level == sym->level && bp->block == sym->block) return (bp->sym); /* if levels don't match then we are okay */ @@ -318,9 +317,13 @@ pointerTypes (sym_link * ptr, sym_link * type) ptr = ptr->next; /* could not find it */ - if (!ptr || IS_SPEC (ptr) || - DCL_TYPE (ptr) != UPOINTER) + if (!ptr || IS_SPEC (ptr)) + return; + + if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) { + pointerTypes (ptr->next, type); return; + } /* change the pointer type depending on the storage class of the type */ @@ -412,7 +415,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 { @@ -432,13 +435,13 @@ addDecl (symbol * sym, int type, sym_link * p) } } - /* if the type is a unknown pointer and has + /* if the type is an unknown pointer and has a tspec then take the storage class const & volatile attribute from the tspec & make it those of this symbol */ if (p && !IS_SPEC (p) && - DCL_TYPE (p) == UPOINTER && + //DCL_TYPE (p) == UPOINTER && DCL_TSPEC (p)) { if (!IS_SPEC (sym->etype)) @@ -499,7 +502,7 @@ 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; } @@ -525,9 +528,40 @@ void checkTypeSanity(sym_link *etype, char *name) { /* mergeSpec - merges two specifiers and returns the new one */ /*------------------------------------------------------------------*/ sym_link * -mergeSpec (sym_link * dest, sym_link * src) +mergeSpec (sym_link * dest, sym_link * src, char *name) { + sym_link *symlink=dest; + +#if 0 + if (!IS_SPEC(dest)) { + // This can happen for pointers, find the end type + while (dest && !IS_SPEC(dest)) + dest=dest->next; + } + if (!IS_SPEC(src)) { + // here we have a declarator as source, reverse them + symlink=src; + src=dest; + dest=symlink; + while (dest && !IS_SPEC(dest)) { + // and find the specifier + dest=dest->next; + } + } else { + symlink=dest; + } +#endif + + if (!IS_SPEC(dest) || !IS_SPEC(src)) { + werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator"); + exit (1); + } + + if (getenv("DEBUG_mergeSpec")) { + fprintf (stderr, "mergeSpec: \"%s\"\n", name); + } + if (SPEC_NOUN(src)) { if (!SPEC_NOUN(dest)) { SPEC_NOUN(dest)=SPEC_NOUN(src); @@ -536,7 +570,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); } } @@ -548,7 +582,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); } } @@ -588,7 +622,7 @@ mergeSpec (sym_link * dest, sym_link * src) if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL) SPEC_STRUCT (dest) = SPEC_STRUCT (src); - return dest; + return symlink; } /*------------------------------------------------------------------*/ @@ -914,48 +948,36 @@ 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, 1); - } - 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); - } - } + /* add new entry */ addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1); } } @@ -1074,7 +1096,7 @@ compStructSize (int su, structdef * sdef) } } else { - checkDecl (loop); + checkDecl (loop, 1); sum += getSize (loop->type); } @@ -1106,7 +1128,7 @@ compStructSize (int su, structdef * sdef) /* checkSClass - check the storage class specification */ /*------------------------------------------------------------------*/ static void -checkSClass (symbol * sym) +checkSClass (symbol * sym, int isProto) { if (getenv("DEBUG_SANITY")) { fprintf (stderr, "checkSClass: %s \n", sym->name); @@ -1174,21 +1196,21 @@ checkSClass (symbol * sym) sym->ival = NULL; } - /* if this is an automatic symbol then */ - /* storage class will be ignored and */ - /* symbol will be allocated on stack/ */ - /* data depending on flag */ - if (sym->level && - (options.stackAuto || reentrant) && - (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)) - { - werror (E_AUTO_ASSUMED, sym->name); + /* 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); + } } + } /* automatic symbols cannot be given */ /* an absolute address ignore it */ @@ -1216,15 +1238,17 @@ checkSClass (symbol * sym) SPEC_BSTR (sym->etype) = 0; } - /* variables declared in CODE space must have */ - /* initializers if not an extern */ - if (SPEC_SCLS (sym->etype) == S_CODE && - sym->ival == NULL && - !sym->level && - port->mem.code_ro && - !IS_EXTERN (sym->etype) && - !funcInChain (sym->type)) - werror (E_CODE_NO_INIT, sym->name); + if (!isProto) { + /* variables declared in CODE space must have */ + /* initializers if not an extern */ + if (SPEC_SCLS (sym->etype) == S_CODE && + sym->ival == NULL && + //!sym->level && + port->mem.code_ro && + !IS_EXTERN (sym->etype) && + !funcInChain (sym->type)) + werror (E_CODE_NO_INIT, sym->name); + } /* if parameter or local variable then change */ /* the storage class to reflect where the var will go */ @@ -1274,10 +1298,10 @@ changePointer (symbol * sym) /* checkDecl - does semantic validation of a declaration */ /*------------------------------------------------------------------*/ int -checkDecl (symbol * sym) +checkDecl (symbol * sym, int isProto) { - checkSClass (sym); /* check the storage class */ + checkSClass (sym, isProto); /* check the storage class */ changePointer (sym); /* change pointers if required */ /* if this is an array without any dimension @@ -1405,11 +1429,11 @@ computeType (sym_link * type1, sym_link * type2) return rType; } -/*------------------------------------------------------------------*/ -/* checkType - will do type check return 1 if match */ -/*------------------------------------------------------------------*/ +/*--------------------------------------------------------------------*/ +/* compareType - will do type check return 1 if match, -1 if castable */ +/*--------------------------------------------------------------------*/ int -checkType (sym_link * dest, sym_link * src) +compareType (sym_link * dest, sym_link * src) { if (!dest && !src) return 1; @@ -1426,15 +1450,14 @@ checkType (sym_link * dest, sym_link * src) if (IS_DECL (src)) { if (DCL_TYPE (src) == DCL_TYPE (dest)) - return checkType (dest->next, src->next); - else if (IS_PTR (src) && IS_PTR (dest)) + return compareType (dest->next, src->next); + if (IS_PTR (src) && IS_PTR (dest)) return -1; - else if (IS_PTR (dest) && IS_ARRAY (src)) + 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); - else - return 0; + if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src)) + return -1 * compareType (dest->next, src); + return 0; } else if (IS_PTR (dest) && IS_INTEGRAL (src)) return -1; @@ -1486,7 +1509,7 @@ checkType (sym_link * dest, sym_link * src) return -1; if (SPEC_USIGN (dest) != SPEC_USIGN (src)) - return -2; + return -1; return 1; } @@ -1638,13 +1661,13 @@ 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 "); + werror (W_CONTINUE, "previous definition type "); printTypeChain (csym->type, stderr); fprintf (stderr, "\n"); - werror (E_CONTINUE, "current definition type "); + werror (W_CONTINUE, "current definition type "); printTypeChain (sym->type, stderr); fprintf (stderr, "\n"); return 0; @@ -1694,7 +1717,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; @@ -2213,22 +2236,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; } } @@ -2250,8 +2272,17 @@ initCSupport () { "s", "u" }; + const char *srlrr[] = + { + "rl", "rr" + }; + + int bwd, su, muldivmod, tofrom, rlrr; - int bwd, su, muldivmod, tofrom; + if (getenv("SDCC_NO_C_SUPPORT")) { + /* for debugging only */ + return; + } floatType = newFloatLink (); @@ -2297,12 +2328,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); } } } @@ -2318,10 +2349,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; } } }