X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCsymt.c;h=afedc3e53ce77719f6e3e7e93bd23e0b8de3c4de;hb=f9491cd966a55530cd527e8ce1d91f99067cc581;hp=534b0cd18f2a20fc812eb7157dfeb6f666a5c4f6;hpb=d1384fdade8c1858cbcb5a05ac6fb8b84461d8e2;p=fw%2Fsdcc diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c index 534b0cd1..afedc3e5 100644 --- a/src/SDCCsymt.c +++ b/src/SDCCsymt.c @@ -26,6 +26,14 @@ 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)) @@ -107,11 +115,13 @@ addSym (bucket ** stab, bucket *bp; /* temp bucket * */ 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 */ @@ -400,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) { @@ -462,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; } @@ -538,36 +557,17 @@ void checkTypeSanity(sym_link *etype, char *name) { sym_link * 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)) { +#if 0 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator"); exit (1); - } - - if (getenv("DEBUG_mergeSpec")) { - fprintf (stderr, "mergeSpec: \"%s\"\n", name); +#else + werror (E_SYNTAX_ERROR, yytext); + // the show must go on + return newIntLink(); +#endif } if (SPEC_NOUN(src)) { @@ -613,23 +613,29 @@ mergeSpec (sym_link * dest, sym_link * src, char *name) 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); if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL) SPEC_STRUCT (dest) = SPEC_STRUCT (src); + /* 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_INTNO(dest) |= FUNC_INTNO(src); + FUNC_REGBANK(dest) |= FUNC_REGBANK(src); + return symlink; } @@ -890,9 +896,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; } @@ -1010,7 +1014,7 @@ 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; @@ -1024,10 +1028,6 @@ structElemType (sym_link * stype, value * id, value ** argsp) { 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 ? @@ -1108,10 +1108,12 @@ compStructSize (int su, structdef * sdef) sum += getSize (loop->type); } +#if 0 // jwk: this is done now in addDecl() /* if function then do the arguments for it */ if (funcInChain (loop->type)) { - processFuncArgs (loop, 1); + processFuncArgs (loop); } +#endif loop = loop->next; @@ -1141,9 +1143,6 @@ checkSClass (symbol * sym, int isProto) 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 */ @@ -1263,7 +1262,7 @@ checkSClass (symbol * sym, int isProto) 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); @@ -1461,8 +1460,12 @@ compareType (sym_link * dest, sym_link * src) { if (IS_DECL (src)) { - if (DCL_TYPE (src) == DCL_TYPE (dest)) + 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; if (IS_PTR (dest) && IS_ARRAY (src)) { @@ -1470,6 +1473,7 @@ compareType (sym_link * dest, sym_link * 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)) @@ -1553,8 +1557,6 @@ inCalleeSaveList (char *s) value * aggregateToPointer (value * val) { - int wasArray=IS_ARRAY(val->type); - if (IS_AGGREGATE (val->type)) { /* if this is a structure */ @@ -1580,6 +1582,8 @@ aggregateToPointer (value * val) DCL_TYPE (val->type) = PPOINTER; break; case S_FIXED: + DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype)); + if (TARGET_IS_DS390) { /* The AUTO and REGISTER classes should probably @@ -1589,7 +1593,11 @@ aggregateToPointer (value * val) DCL_TYPE (val->type) = GPOINTER; break; } - /* fall through! */ + if (options.model==MODEL_LARGE) { + DCL_TYPE (val->type) = FPOINTER; + break; + } + break; case S_AUTO: case S_DATA: case S_REGISTER: @@ -1608,12 +1616,6 @@ aggregateToPointer (value * val) DCL_TYPE (val->type) = GPOINTER; } - if (wasArray) { - /* there is NO way to specify the storage of the pointer - associated with an array, so we make it the default */ - SPEC_SCLS(val->etype) = S_FIXED; - } - /* is there is a symbol associated then */ /* change the type of the symbol as well */ if (val->sym) @@ -1628,9 +1630,8 @@ aggregateToPointer (value * 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; @@ -1666,21 +1667,23 @@ 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))) + 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; @@ -1690,33 +1693,28 @@ checkFunction (symbol * sym) if (compareType (csym->type, sym->type) <= 0) { werror (E_PREV_DEF_CONFLICT, csym->name, "type"); - werror (W_CONTINUE, "previous definition type "); - printTypeChain (csym->type, stderr); - fprintf (stderr, "\n"); - werror (W_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"); } - 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"); } - if (SPEC_NAKED (csym->etype) != SPEC_NAKED (sym->etype)) + if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type)) { werror (E_PREV_DEF_CONFLICT, csym->name, "_naked"); } /* compare expected args with actual args */ - exargs = csym->args; - acargs = sym->args; + exargs = FUNC_ARGS(csym->type); + acargs = FUNC_ARGS(sym->type); /* for all the expected args do */ for (argCnt = 1; @@ -1746,6 +1744,7 @@ checkFunction (symbol * sym) if (compareType (exargs->type, checkValue->type) <= 0) { werror (E_ARG_TYPE, argCnt); + printFromToType(exargs->type, checkValue->type); return 0; } } @@ -1771,26 +1770,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)) + 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; } @@ -1803,7 +1812,7 @@ processFuncArgs (symbol * func, int ignoreName) /* mark it as a register parameter if the function does not have VA_ARG and as port dictates */ - if (!func->hasVargs && + if (!IFFUNC_HASVARARGS(funcType) && (*port->reg_parm) (val->type)) { SPEC_REGPARM (val->etype) = 1; @@ -1813,6 +1822,7 @@ processFuncArgs (symbol * func, int ignoreName) { aggregateToPointer (val); } + val = val->next; pNum++; } @@ -1821,17 +1831,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) { @@ -1910,7 +1920,7 @@ printTypeChain (sym_link * start, FILE * of) } if (start==NULL) { - fprintf (of, "**err**"); + fprintf (of, "void"); return; } @@ -1933,43 +1943,43 @@ printTypeChain (sym_link * start, FILE * of) case GPOINTER: if (DCL_PTR_CONST (type)) fprintf (of, "const "); - fprintf (of, "* generic "); + fprintf (of, "generic * "); break; case CPOINTER: if (DCL_PTR_CONST (type)) fprintf (of, "const "); - fprintf (of, "* code "); + fprintf (of, "code * "); break; case FPOINTER: if (DCL_PTR_CONST (type)) fprintf (of, "const "); - fprintf (of, "* xdata "); + fprintf (of, "xdata * "); break; case EEPPOINTER: if (DCL_PTR_CONST (type)) fprintf (of, "const "); - fprintf (of, "* eeprom "); + fprintf (of, "eeprom * "); break; case POINTER: if (DCL_PTR_CONST (type)) fprintf (of, "const "); - fprintf (of, "* near "); + fprintf (of, "near *"); break; case IPOINTER: if (DCL_PTR_CONST (type)) fprintf (of, "const "); - fprintf (of, "* idata "); + fprintf (of, "idata * "); break; case PPOINTER: if (DCL_PTR_CONST (type)) fprintf (of, "const "); - fprintf (of, "* pdata "); + fprintf (of, "pdata * "); break; case UPOINTER: if (DCL_PTR_CONST (type)) fprintf (of, "const "); - fprintf (of, "* unkown "); + fprintf (of, "unkown * "); break; case ARRAY: fprintf (of, "[] "); @@ -2198,8 +2208,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 */ @@ -2408,7 +2418,7 @@ initCSupport () ssu[su], sbwd[bwd]); __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; + FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1; } } } @@ -2424,7 +2434,7 @@ initCSupport () 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; + FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1; } } }