X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCsymt.c;h=ed9c4fb5bfef072be5a6be12c3b4123861881872;hb=24db07e65dc37c465c586f173fcf7d591d5bd7bc;hp=e83e56f3116336ab452de3c04eae6e917dcf72bc;hpb=98bdd67eafd3fe4b5c0001fac2f21a55c6fb00dc;p=fw%2Fsdcc diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c index e83e56f3..ed9c4fb5 100644 --- a/src/SDCCsymt.c +++ b/src/SDCCsymt.c @@ -24,6 +24,16 @@ #include "common.h" #include "newalloc.h" +value *aggregateToPointer (value *val); + +void printFromToType(sym_link *from, sym_link *to) { + fprintf (stderr, "from type '"); + printTypeChain (from, stderr); + fprintf (stderr, "'\nto type '"); + printTypeChain (to, stderr); + fprintf (stderr, "'\n"); +} + /* noun strings */ char *nounName(sym_link *sl) { switch (SPEC_NOUN(sl)) @@ -72,7 +82,7 @@ newBucket () { bucket *bp; - bp = Safe_calloc (1, sizeof (bucket)); + bp = Safe_alloc ( sizeof (bucket)); return bp; } @@ -98,24 +108,32 @@ 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) { + symbol *csym = (symbol *)sym; + + if (getenv("DEBUG_SANITY")) { + fprintf (stderr, "addSym: %s ", sname); + } /* make sure the type is complete and sane */ - checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name); + checkTypeSanity(csym->etype, csym->name); + } + + /* prevent overflow of the (r)name buffers */ + if (strlen(sname)>SDCC_SYMNAME_MAX) { + werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX); + sname[SDCC_SYMNAME_MAX]='\0'; } /* the symbols are always added at the head of the list */ i = hashKey (sname); /* get a free entry */ - bp = Safe_calloc (1, sizeof (bucket)); + bp = Safe_alloc ( sizeof (bucket)); bp->sym = sym; /* update the symbol pointer */ bp->level = level; /* update the nest level */ @@ -217,13 +235,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 */ @@ -268,7 +285,7 @@ newSymbol (char *name, int scope) { symbol *sym; - sym = Safe_calloc (1, sizeof (symbol)); + sym = Safe_alloc ( sizeof (symbol)); strcpy (sym->name, name); /* copy the name */ sym->level = scope; /* set the level */ @@ -285,7 +302,7 @@ newLink () { sym_link *p; - p = Safe_calloc (1, sizeof (sym_link)); + p = Safe_alloc ( sizeof (sym_link)); return p; } @@ -298,7 +315,7 @@ newStruct (char *tag) { structdef *s; - s = Safe_calloc (1, sizeof (structdef)); + s = Safe_alloc ( sizeof (structdef)); strcpy (s->tag, tag); /* copy the tag */ return s; @@ -318,9 +335,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 */ @@ -350,7 +371,7 @@ pointerTypes (sym_link * ptr, sym_link * type) DCL_TYPE (ptr) = EEPPOINTER; break; default: - DCL_TYPE (ptr) = GPOINTER; + DCL_TYPE (ptr) = port->unqualified_pointer; break; } /* the storage class of type ends here */ @@ -364,7 +385,7 @@ pointerTypes (sym_link * ptr, sym_link * type) while (ptr) { if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER) - DCL_TYPE (ptr) = GPOINTER; + DCL_TYPE (ptr) = port->unqualified_pointer; ptr = ptr->next; } @@ -373,7 +394,7 @@ pointerTypes (sym_link * ptr, sym_link * type) while (type) { if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER) - DCL_TYPE (type) = GPOINTER; + DCL_TYPE (type) = port->unqualified_pointer; type = type->next; } @@ -389,6 +410,9 @@ addDecl (symbol * sym, int type, sym_link * p) sym_link *tail; sym_link *t; + if (getenv("SDCC_DEBUG_FUNCTION_POINTERS")) + fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p); + /* if we are passed a link then set head & tail */ if (p) { @@ -412,7 +436,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 +456,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)) @@ -451,6 +475,12 @@ addDecl (symbol * sym, int type, sym_link * p) SPEC_VOLATILE (sym->etype) = SPEC_VOLATILE (DCL_TSPEC (p)); DCL_TSPEC (p) = NULL; } + + // if there is a function in this type chain + if (p && funcInChain(sym->type)) { + processFuncArgs (sym); + } + return; } @@ -478,7 +508,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 +529,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,8 +555,20 @@ 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 (!IS_SPEC(dest) || !IS_SPEC(src)) { +#if 0 + werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator"); + exit (1); +#else + werror (E_SYNTAX_ERROR, yytext); + // the show must go on + return newIntLink(); +#endif + } if (SPEC_NOUN(src)) { if (!SPEC_NOUN(dest)) { @@ -536,7 +578,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 +590,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); } } @@ -571,24 +613,36 @@ mergeSpec (sym_link * dest, sym_link * src) dest->select.s._signed|=src->select.s._signed; SPEC_STAT (dest) |= SPEC_STAT (src); SPEC_EXTR (dest) |= SPEC_EXTR (src); + SPEC_CONST(dest) |= SPEC_CONST (src); SPEC_ABSA (dest) |= SPEC_ABSA (src); - SPEC_RENT (dest) |= SPEC_RENT (src); - SPEC_INTN (dest) |= SPEC_INTN (src); - SPEC_BANK (dest) |= SPEC_BANK (src); SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src); - SPEC_CRTCL (dest) |= SPEC_CRTCL (src); SPEC_ADDR (dest) |= SPEC_ADDR (src); SPEC_OCLS (dest) = SPEC_OCLS (src); SPEC_BLEN (dest) |= SPEC_BLEN (src); SPEC_BSTR (dest) |= SPEC_BSTR (src); SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src); - SPEC_NONBANKED (dest) |= SPEC_NONBANKED (src); - SPEC_NAKED (dest) |= SPEC_NAKED (src); - + SPEC_ENUM (dest) |= SPEC_ENUM (src); + if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest)) + SPEC_ARGREG(dest) = SPEC_ARGREG(src); + if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL) SPEC_STRUCT (dest) = SPEC_STRUCT (src); - return dest; + /* these are the only function attributes that will be set + in a specifier while parsing */ + FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src); + FUNC_BANKED(dest) |= FUNC_BANKED(src); + FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src); + FUNC_ISREENT(dest) |= FUNC_ISREENT(src); + FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src); + FUNC_ISISR(dest) |= FUNC_ISISR(src); + FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src); + FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src); + FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src); + FUNC_INTNO(dest) |= FUNC_INTNO(src); + FUNC_REGBANK(dest) |= FUNC_REGBANK(src); + + return symlink; } /*------------------------------------------------------------------*/ @@ -734,10 +788,14 @@ getSize (sym_link * p) /* this is a specifier */ switch (DCL_TYPE (p)) { - case FUNCTION: - return 2; case ARRAY: - return DCL_ELEM (p) * getSize (p->next); + if (DCL_ELEM(p)) { + return DCL_ELEM (p) * getSize (p->next); + } else { + // werror (E_INTERNAL_ERROR, __FILE__, __LINE__, + // "can not tell the size of an array[]"); + return 0; + } case IPOINTER: case PPOINTER: case POINTER: @@ -745,6 +803,7 @@ getSize (sym_link * p) case EEPPOINTER: case FPOINTER: case CPOINTER: + case FUNCTION: return (FPTRSIZE); case GPOINTER: return (GPTRSIZE); @@ -793,8 +852,6 @@ bitsForType (sym_link * p) /* this is a specifier */ switch (DCL_TYPE (p)) { - case FUNCTION: - return 2; case ARRAY: return DCL_ELEM (p) * getSize (p->next) * 8; case IPOINTER: @@ -804,6 +861,7 @@ bitsForType (sym_link * p) case EEPPOINTER: case FPOINTER: case CPOINTER: + case FUNCTION: return (FPTRSIZE * 8); case GPOINTER: return (GPTRSIZE * 8); @@ -848,9 +906,7 @@ copySymbol (symbol * src) dest->type = copyLinkChain (src->type); dest->etype = getSpec (dest->type); dest->next = NULL; - dest->args = copyValueChain (src->args); dest->key = src->key; - dest->calleeSave = src->calleeSave; dest->allocreq = src->allocreq; return dest; } @@ -914,49 +970,38 @@ 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); + deleteFromSeg(csym); + } 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); } } @@ -980,35 +1025,33 @@ funcInChain (sym_link * lnk) /* structElemType - returns the type info of a sturct member */ /*------------------------------------------------------------------*/ sym_link * -structElemType (sym_link * stype, value * id, value ** argsp) +structElemType (sym_link * stype, value * id) { symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL); sym_link *type, *etype; sym_link *petype = getSpec (stype); - if (!fields || !id) - return NULL; + if (fields && id) { + + /* look for the id */ + while (fields) + { + if (strcmp (fields->rname, id->name) == 0) + { + type = copyLinkChain (fields->type); + etype = getSpec (type); + SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ? + SPEC_SCLS (etype) : SPEC_SCLS (petype)); + return type; + } + fields = fields->next; + } + } - /* look for the id */ - while (fields) - { - if (strcmp (fields->rname, id->name) == 0) - { - if (argsp) - { - *argsp = fields->args; - } - type = copyLinkChain (fields->type); - etype = getSpec (type); - SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ? - SPEC_SCLS (etype) : SPEC_SCLS (petype)); - return type; - } - fields = fields->next; - } werror (E_NOT_MEMBER, id->name); - - return NULL; + + // the show must go on + return newIntLink(); } /*------------------------------------------------------------------*/ @@ -1074,15 +1117,10 @@ compStructSize (int su, structdef * sdef) } } else { - checkDecl (loop); + checkDecl (loop, 1); sum += getSize (loop->type); } - /* if function then do the arguments for it */ - if (funcInChain (loop->type)) { - processFuncArgs (loop, 1); - } - loop = loop->next; /* if this is not a bitfield but the */ @@ -1106,13 +1144,17 @@ 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); + } + /* 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 */ @@ -1129,26 +1171,33 @@ 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; + volatile -- except in the PIC port */ + +#if !OPT_DISABLE_PIC + /* The PIC port uses a different peep hole optimizer based on "pCode" */ + if (!TARGET_IS_PIC) +#endif + + if (IS_ABSOLUTE (sym->etype)) + SPEC_VOLATILE (sym->etype) = 1; + /* global variables declared const put into code */ + /* if no other storage class specified */ 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_FIXED) { + 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 */ @@ -1169,23 +1218,22 @@ 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 && - SPEC_SCLS (sym->etype) != S_CONSTANT)) - { - 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 */ if (sym->level && @@ -1212,22 +1260,24 @@ 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 */ if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED && !IS_STATIC(sym->etype)) { - if (options.stackAuto || (currFunc && IS_RENT (currFunc->etype))) + if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type))) { SPEC_SCLS (sym->etype) = (options.useXstack ? S_XSTACK : S_STACK); @@ -1260,7 +1310,7 @@ changePointer (symbol * sym) for (p = sym->type; p; p = p->next) { if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER) - DCL_TYPE (p) = GPOINTER; + DCL_TYPE (p) = port->unqualified_pointer; if (IS_PTR (p) && IS_FUNC (p->next)) DCL_TYPE (p) = CPOINTER; } @@ -1270,10 +1320,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 @@ -1377,11 +1427,11 @@ computeType (sym_link * type1, sym_link * type2) else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1)) rType = copyLinkChain (type1); else - /* if one of them is a pointer then that + /* if one of them is a pointer or array then that prevails */ - if (IS_PTR (type1)) + if (IS_PTR (type1) || IS_ARRAY (type1)) rType = copyLinkChain (type1); - else if (IS_PTR (type2)) + else if (IS_PTR (type2) || IS_ARRAY (type2)) rType = copyLinkChain (type2); else if (getSize (type1) > getSize (type2)) rType = copyLinkChain (type1); @@ -1390,10 +1440,14 @@ computeType (sym_link * type1, sym_link * type2) reType = getSpec (rType); - /* if either of them unsigned then make this unsigned */ - if ((SPEC_USIGN (etype1) || SPEC_USIGN (etype2)) && !IS_FLOAT (reType)) + /* if either of them unsigned but not val then make this unsigned */ + if (((!IS_LITERAL(type1) && SPEC_USIGN (etype1)) || + (!IS_LITERAL(type2) && SPEC_USIGN (etype2))) && + !IS_FLOAT (reType)) SPEC_USIGN (reType) = 1; - + else + SPEC_USIGN (reType) = 0; + /* if result is a literal then make not so */ if (IS_LITERAL (reType)) SPEC_SCLS (reType) = S_REGISTER; @@ -1401,11 +1455,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; @@ -1421,16 +1475,25 @@ 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 -1; - else if (IS_PTR (dest) && IS_ARRAY (src)) + if (DCL_TYPE (src) == DCL_TYPE (dest)) { + if (IS_FUNC(src)) { + //checkFunction(src,dest); + } + return compareType (dest->next, src->next); + } + if (IS_PTR (src) && IS_GENPTR (dest)) 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_ARRAY (src)) { + value *val=aggregateToPointer (valFromType(src)); + int res=compareType (dest, val->type); + Safe_free(val->type); + Safe_free(val); + //return res ? -1 : 0; + return res; + } + if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src)) + return compareType (dest->next, src); + return 0; } else if (IS_PTR (dest) && IS_INTEGRAL (src)) return -1; @@ -1482,19 +1545,20 @@ checkType (sym_link * dest, sym_link * src) return -1; if (SPEC_USIGN (dest) != SPEC_USIGN (src)) - return -2; + return -1; return 1; } /*------------------------------------------------------------------*/ -/* inCalleeSaveList - return 1 if found in calle save list */ +/* inCalleeSaveList - return 1 if found in callee save list */ /*------------------------------------------------------------------*/ bool inCalleeSaveList (char *s) { int i; + if (options.all_callee_saves) return 1; for (i = 0; options.calleeSaves[i]; i++) if (strcmp (options.calleeSaves[i], s) == 0) return 1; @@ -1503,11 +1567,11 @@ inCalleeSaveList (char *s) } /*-----------------------------------------------------------------*/ -/* aggregateArgToPointer: change an agggregate type function */ +/* aggregateToPointer: change an agggregate type function */ /* argument to a pointer to that type. */ /*-----------------------------------------------------------------*/ -void -aggregateArgToPointer (value * val) +value * +aggregateToPointer (value * val) { if (IS_AGGREGATE (val->type)) { @@ -1534,16 +1598,28 @@ aggregateArgToPointer (value * val) DCL_TYPE (val->type) = PPOINTER; break; case S_FIXED: - if (TARGET_IS_DS390) - { + if (SPEC_OCLS(val->etype)) { + DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype)); + } else { +#if 1 + // this happens for (external) function parameters + DCL_TYPE (val->type) = port->unqualified_pointer; +#else + if (TARGET_IS_DS390) { /* The AUTO and REGISTER classes should probably * also become generic pointers, but I haven't yet * devised a test case for that. */ - DCL_TYPE (val->type) = GPOINTER; + DCL_TYPE (val->type) = port->unqualified_pointer; break; } - /* fall through! */ + if (options.model==MODEL_LARGE) { + DCL_TYPE (val->type) = FPOINTER; + break; + } +#endif + } + break; case S_AUTO: case S_DATA: case S_REGISTER: @@ -1559,9 +1635,9 @@ aggregateArgToPointer (value * val) DCL_TYPE (val->type) = EEPPOINTER; break; default: - DCL_TYPE (val->type) = GPOINTER; + DCL_TYPE (val->type) = port->unqualified_pointer; } - + /* is there is a symbol associated then */ /* change the type of the symbol as well */ if (val->sym) @@ -1570,15 +1646,16 @@ aggregateArgToPointer (value * val) val->sym->etype = getSpec (val->sym->type); } } + return val; } /*------------------------------------------------------------------*/ /* checkFunction - does all kinds of check on a function */ /*------------------------------------------------------------------*/ int -checkFunction (symbol * sym) +checkFunction (symbol * sym, symbol *csym) { - symbol *csym; value *exargs, *acargs; + value *checkValue; int argCnt = 0; if (getenv("DEBUG_SANITY")) { @@ -1612,61 +1689,86 @@ checkFunction (symbol * sym) /* check if this function is defined as calleeSaves then mark it as such */ - sym->calleeSave = inCalleeSaveList (sym->name); + FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name); /* if interrupt service routine */ /* then it cannot have arguments */ - if (sym->args && IS_ISR (sym->etype) && !IS_VOID (sym->args->type)) + if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type)) { - werror (E_INT_ARGS, sym->name); - sym->args = NULL; + if (!IS_VOID(FUNC_ARGS(sym->type)->type)) { + werror (E_INT_ARGS, sym->name); + FUNC_ARGS(sym->type)=NULL; + } } - if (!(csym = findSym (SymbolTab, sym, sym->name))) + for (argCnt=1, acargs = FUNC_ARGS(sym->type); + acargs; + acargs=acargs->next, argCnt++) { + if (!acargs->sym) { + // this can happen for reentrant functions + werror(E_PARAM_NAME_OMITTED, sym->name, argCnt); + // the show must go on: synthesize a name and symbol + sprintf (acargs->name, "_%s_PARM_%d", sym->name, argCnt); + acargs->sym = newSymbol (acargs->name, 1); + SPEC_OCLS (acargs->etype) = istack; + acargs->sym->type = copyLinkChain (acargs->type); + acargs->sym->etype = getSpec (acargs->sym->type); + acargs->sym->_isparm = 1; + strcpy (acargs->sym->rname, acargs->name); + } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) { + // synthesized name + werror(E_PARAM_NAME_OMITTED, sym->name, argCnt); + } + } + + if (!csym && !(csym = findSym (SymbolTab, sym, sym->name))) return 1; /* not defined nothing more to check */ /* check if body already present */ - if (csym && csym->fbody) + if (csym && IFFUNC_HASBODY(csym->type)) { werror (E_FUNC_BODY, sym->name); return 0; } /* 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 "); - printTypeChain (csym->type, stderr); - fprintf (stderr, "\n"); - werror (E_CONTINUE, "current definition type "); - printTypeChain (sym->type, stderr); - fprintf (stderr, "\n"); + printFromToType(csym->type, sym->type); return 0; } - if (SPEC_INTRTN (csym->etype) != SPEC_INTRTN (sym->etype)) + if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type)) { werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt"); - return 0; } - if (SPEC_BANK (csym->etype) != SPEC_BANK (sym->etype)) + if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type)) { werror (E_PREV_DEF_CONFLICT, csym->name, "using"); - return 0; } - /* compare expected agrs with actual args */ - exargs = csym->args; - acargs = sym->args; + if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type)) + { + werror (E_PREV_DEF_CONFLICT, csym->name, "_naked"); + } + + /* compare expected args with actual args */ + exargs = FUNC_ARGS(csym->type); + acargs = FUNC_ARGS(sym->type); /* for all the expected args do */ for (argCnt = 1; 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. @@ -1674,16 +1776,17 @@ checkFunction (symbol * sym) if (IS_AGGREGATE (acargs->type)) { checkValue = copyValue (acargs); - aggregateArgToPointer (checkValue); + aggregateToPointer (checkValue); } else { checkValue = acargs; } - if (checkType (exargs->type, checkValue->type) <= 0) + if (compareType (exargs->type, checkValue->type) <= 0) { werror (E_ARG_TYPE, argCnt); + printFromToType(exargs->type, checkValue->type); return 0; } } @@ -1696,7 +1799,8 @@ 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); + deleteFromSeg(csym); + addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1); if (IS_EXTERN (csym->etype) && ! IS_EXTERN (sym->etype)) { @@ -1709,26 +1813,36 @@ checkFunction (symbol * sym) /* processFuncArgs - does some processing with function args */ /*-----------------------------------------------------------------*/ void -processFuncArgs (symbol * func, int ignoreName) +processFuncArgs (symbol * func) { value *val; int pNum = 1; + sym_link *funcType=func->type; + + if (getenv("SDCC_DEBUG_FUNCTION_POINTERS")) + fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name); + + // if this is a pointer to a function + if (IS_PTR(funcType)) { + funcType=funcType->next; + } /* if this function has variable argument list */ /* then make the function a reentrant one */ - if (func->hasVargs) - SPEC_RENT (func->etype) = 1; + if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef)) + FUNC_ISREENT(funcType)=1; /* check if this function is defined as calleeSaves then mark it as such */ - func->calleeSave = inCalleeSaveList (func->name); + FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name); - val = func->args; /* loop thru all the arguments */ + /* loop thru all the arguments */ + val = FUNC_ARGS(funcType); /* if it is void then remove parameters */ if (val && IS_VOID (val->type)) { - func->args = NULL; + FUNC_ARGS(funcType) = NULL; return; } @@ -1738,19 +1852,24 @@ processFuncArgs (symbol * func, int ignoreName) /* change it to pointer to the same type */ while (val) { + int argreg = 0; /* mark it as a register parameter if the function does not have VA_ARG and as port dictates */ - if (!func->hasVargs && - (*port->reg_parm) (val->type)) + if (!IFFUNC_HASVARARGS(funcType) && + (argreg = (*port->reg_parm) (val->type))) { SPEC_REGPARM (val->etype) = 1; + SPEC_ARGREG(val->etype) = argreg; + } else if (IFFUNC_ISREENT(funcType)) { + FUNC_HASSTACKPARM(funcType) = 1; } if (IS_AGGREGATE (val->type)) { - aggregateArgToPointer (val); + aggregateToPointer (val); } + val = val->next; pNum++; } @@ -1759,17 +1878,17 @@ processFuncArgs (symbol * func, int ignoreName) if (func->cdef) { /* ignore --stack-auto for this one, we don't know how it is compiled */ /* simply trust on --int-long-reent or --float-reent */ - if (IS_RENT(func->etype)) { + if (IFFUNC_ISREENT(funcType)) { return; } } else { /* if this function is reentrant or */ /* automatics r 2b stacked then nothing */ - if (IS_RENT (func->etype) || options.stackAuto) + if (IFFUNC_ISREENT (funcType) || options.stackAuto) return; } - val = func->args; + val = FUNC_ARGS(funcType); pNum = 1; while (val) { @@ -1778,7 +1897,6 @@ processFuncArgs (symbol * func, int ignoreName) /* synthesize a variable name */ if (!val->sym) { - sprintf (val->name, "_%s_PARM_%d", func->name, pNum++); val->sym = newSymbol (val->name, 1); SPEC_OCLS (val->etype) = port->mem.default_local_map; @@ -1835,10 +1953,11 @@ void PT(sym_link *type) /*-----------------------------------------------------------------*/ /* printTypeChain - prints the type chain in human readable form */ /*-----------------------------------------------------------------*/ -void -printTypeChain (sym_link * type, FILE * of) +void +printTypeChain (sym_link * start, FILE * of) { int nlr = 0; + sym_link * type, * search; if (!of) { @@ -1846,91 +1965,122 @@ printTypeChain (sym_link * type, FILE * of) nlr = 1; } + if (start==NULL) { + fprintf (of, "void"); + return; + } + + /* print the chain as it is written in the source: */ + /* start with the last entry */ + for (type = start; type && type->next; type = type->next) + ; while (type) { if (IS_DECL (type)) { - if (DCL_PTR_VOLATILE(type)) { + if (DCL_PTR_VOLATILE (type)) { fprintf (of, "volatile "); } switch (DCL_TYPE (type)) { case FUNCTION: - fprintf (of, "function "); + fprintf (of, "function %s %s", + (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "), + (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " ")); break; case GPOINTER: - fprintf (of, "_generic * "); if (DCL_PTR_CONST (type)) fprintf (of, "const "); + fprintf (of, "generic * "); break; case CPOINTER: - fprintf (of, "_code * "); if (DCL_PTR_CONST (type)) fprintf (of, "const "); + fprintf (of, "code * "); break; case FPOINTER: - fprintf (of, "_far * "); if (DCL_PTR_CONST (type)) fprintf (of, "const "); + fprintf (of, "xdata * "); break; case EEPPOINTER: - fprintf (of, "_eeprom * "); if (DCL_PTR_CONST (type)) fprintf (of, "const "); + fprintf (of, "eeprom * "); break; case POINTER: - fprintf (of, "_near * "); if (DCL_PTR_CONST (type)) fprintf (of, "const "); + fprintf (of, "near *"); break; case IPOINTER: - fprintf (of, "_idata *"); if (DCL_PTR_CONST (type)) fprintf (of, "const "); + fprintf (of, "idata * "); break; case PPOINTER: - fprintf (of, "_pdata *"); if (DCL_PTR_CONST (type)) fprintf (of, "const "); + fprintf (of, "pdata * "); break; case UPOINTER: - fprintf (of, " _unkown *"); if (DCL_PTR_CONST (type)) fprintf (of, "const "); + fprintf (of, "unkown * "); break; case ARRAY: - fprintf (of, "array of "); + if (DCL_ELEM(type)) { + fprintf (of, "[%d] ", DCL_ELEM(type)); + } else { + fprintf (of, "[] "); + } break; } } else { + switch (SPEC_SCLS(type)) + { + case S_DATA: fprintf (of, "data "); break; + case S_XDATA: fprintf (of, "xdata "); break; + case S_SFR: fprintf (of, "sfr "); break; + case S_SBIT: fprintf (of, "sbit "); break; + case S_CODE: fprintf (of, "code "); break; + case S_IDATA: fprintf (of, "idata "); break; + case S_PDATA: fprintf (of, "pdata "); break; + case S_LITERAL: fprintf (of, "literal "); break; + case S_STACK: fprintf (of, "stack "); break; + case S_XSTACK: fprintf (of, "xstack "); break; + case S_BIT: fprintf (of, "bit "); break; + case S_EEPROM: fprintf (of, "eeprom "); break; + default: break; + } + if (SPEC_VOLATILE (type)) fprintf (of, "volatile "); if (SPEC_USIGN (type)) fprintf (of, "unsigned "); if (SPEC_CONST (type)) fprintf (of, "const "); - switch (SPEC_NOUN (type)) { case V_INT: if (IS_LONG (type)) fprintf (of, "long "); - fprintf (of, "int "); + fprintf (of, "int"); break; case V_CHAR: - fprintf (of, "char "); + fprintf (of, "char"); break; case V_VOID: - fprintf (of, "void "); + fprintf (of, "void"); break; case V_FLOAT: - fprintf (of, "float "); + fprintf (of, "float"); break; case V_STRUCT: @@ -1938,7 +2088,7 @@ printTypeChain (sym_link * type, FILE * of) break; case V_SBIT: - fprintf (of, "sbit "); + fprintf (of, "sbit"); break; case V_BIT: @@ -1946,15 +2096,20 @@ printTypeChain (sym_link * type, FILE * of) break; case V_DOUBLE: - fprintf (of, "double "); + fprintf (of, "double"); break; default: - fprintf (of, "unknown type "); + fprintf (of, "unknown type"); break; } } - type = type->next; + /* search entry in list before "type" */ + for (search = start; search && search->next != type;) + search = search->next; + type = search; + if (type) + fputc (' ', of); } if (nlr) fprintf (of, "\n"); @@ -1963,7 +2118,7 @@ printTypeChain (sym_link * type, FILE * of) /*-----------------------------------------------------------------*/ /* cdbTypeInfo - print the type information for debugger */ /*-----------------------------------------------------------------*/ -void +void cdbTypeInfo (sym_link * type, FILE * of) { fprintf (of, "{%d}", getSize (type)); @@ -2104,8 +2259,8 @@ cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc) if is it an interrupt routine & interrupt number and the register bank it is using */ if (isFunc) - fprintf (of, ",%d,%d,%d", SPEC_INTRTN (sym->etype), - SPEC_INTN (sym->etype), SPEC_BANK (sym->etype)); + fprintf (of, ",%d,%d,%d", FUNC_ISISR (sym->type), + FUNC_INTNO (sym->type), FUNC_REGBANK (sym->type)); /* alternate location to find this symbol @ : eg registers or spillication */ @@ -2200,23 +2355,127 @@ 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; + } +} + +/*-----------------------------------------------------------------*/ +/* typeFromStr - create a typechain from an encoded string */ +/* basic types - 'c' - char */ +/* 's' - short */ +/* 'i' - int */ +/* 'l' - long */ +/* 'f' - float */ +/* 'v' - void */ +/* '*' - pointer - default (GPOINTER) */ +/* modifiers - 'u' - unsigned */ +/* pointer modifiers - 'g' - generic */ +/* 'x' - xdata */ +/* 'p' - code */ +/* 'd' - data */ +/* 'F' - function */ +/* examples : "ig*" - generic int * */ +/* "cx*" - char xdata * */ +/* "ui" - unsigned int */ +/*-----------------------------------------------------------------*/ +sym_link *typeFromStr (char *s) +{ + sym_link *r = newLink(); + int usign = 0; + + do { + sym_link *nr; + switch (*s) { + case 'u' : + usign = 1; + s++; + continue ; + break ; + case 'c': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_CHAR; + break; + case 's': + case 'i': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_INT; + break; + case 'l': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_INT; + SPEC_LONG(r) = 1; + break; + case 'f': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_FLOAT; + break; + case 'v': + r->class = SPECIFIER; + SPEC_NOUN(r) = V_VOID; + break; + case '*': + DCL_TYPE(r) = port->unqualified_pointer; + break; + case 'g': + case 'x': + case 'p': + case 'd': + case 'F': + assert(*(s+1)=='*'); + nr = newLink(); + nr->next = r; + r = nr; + r->class = DECLARATOR ; + switch (*s) { + case 'g': + DCL_TYPE(r) = GPOINTER; + break; + case 'x': + DCL_TYPE(r) = FPOINTER; + break; + case 'p': + DCL_TYPE(r) = CPOINTER; + break; + case 'd': + DCL_TYPE(r) = POINTER; + break; + case 'F': + DCL_TYPE(r) = FUNCTION; + nr = newLink(); + nr->next = r; + r = nr; + r->class = DECLARATOR ; + DCL_TYPE(r) = CPOINTER; + break; + } + s++; + break; + default: + werror(E_INTERNAL_ERROR, __FILE__, __LINE__, + "typeFromStr: unknown type"); + break; + } + if (IS_SPEC(r) && usign) { + SPEC_USIGN(r) = 1; + usign = 0; + } + s++; + } while (*s); + return r; } /*-----------------------------------------------------------------*/ @@ -2237,14 +2496,23 @@ initCSupport () { "s", "u" }; + const char *srlrr[] = + { + "rl", "rr" + }; - int bwd, su, muldivmod, tofrom; + int bwd, su, muldivmod, tofrom, rlrr; + + if (getenv("SDCC_NO_C_SUPPORT")) { + /* for debugging only */ + return; + } floatType = newFloatLink (); for (bwd = 0; bwd < 3; bwd++) { - sym_link *l; + sym_link *l = NULL; switch (bwd) { case 0: @@ -2305,11 +2573,43 @@ initCSupport () smuldivmod[muldivmod], ssu[su], sbwd[bwd]); - __muldiv[muldivmod][bwd][su] = funcOfType (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]); + __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent); + FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1; } } } + + 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); + FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1; + } + } + } +} + +/*-----------------------------------------------------------------*/ +/* initBuiltIns - create prototypes for builtin functions */ +/*-----------------------------------------------------------------*/ +void initBuiltIns() +{ + int i; + symbol *sym; + + if (!port->builtintable) return ; + + for (i = 0 ; port->builtintable[i].name ; i++) { + sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype, + port->builtintable[i].nParms,port->builtintable[i].parm_types); + FUNC_ISBUILTIN(sym->type) = 1; + FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */ + } }