X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCsymt.c;h=80ccfc5ad12bdb2bf82d3a5223113e415ea7890a;hb=256bce22d6b6abdc49735eef9b87f4685ca20bcc;hp=a25a369f4a0fc2909a9c7a2c841e1b6ddf8df889;hpb=a4f5942bd0c50ddb1dc42ea7fea25e69b4c04a76;p=fw%2Fsdcc diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c index a25a369f..80ccfc5a 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 */ @@ -128,7 +138,7 @@ addSym (bucket ** stab, bp->sym = sym; /* update the symbol pointer */ bp->level = level; /* update the nest level */ bp->block = block; - strcpy (bp->name, sname); /* copy the name into place */ + strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */ /* if this is the first entry */ if (stab[i] == NULL) @@ -277,7 +287,7 @@ newSymbol (char *name, int scope) sym = Safe_alloc ( sizeof (symbol)); - strcpy (sym->name, name); /* copy the name */ + strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */ sym->level = scope; /* set the level */ sym->block = currBlockno; sym->lineDef = yylineno; /* set the line number */ @@ -288,11 +298,12 @@ newSymbol (char *name, int scope) /* newLink - creates a new link (declarator,specifier) */ /*------------------------------------------------------------------*/ sym_link * -newLink () +newLink (SYM_LINK_CLASS select) { sym_link *p; p = Safe_alloc ( sizeof (sym_link)); + p->class=select; return p; } @@ -307,7 +318,7 @@ newStruct (char *tag) s = Safe_alloc ( sizeof (structdef)); - strcpy (s->tag, tag); /* copy the tag */ + strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */ return s; } @@ -361,11 +372,11 @@ 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 */ - SPEC_SCLS (type) = + SPEC_SCLS (type) = SPEC_CONST (type) = SPEC_VOLATILE (type) = 0; } @@ -375,7 +386,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; } @@ -384,7 +395,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; } @@ -400,6 +411,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) { @@ -409,7 +423,7 @@ addDecl (symbol * sym, int type, sym_link * p) } else { - head = tail = newLink (); + head = tail = newLink (DECLARATOR); DCL_TYPE (head) = type; } @@ -454,14 +468,19 @@ addDecl (symbol * sym, int type, sym_link * p) { if (!IS_SPEC (sym->etype)) { - sym->etype = sym->etype->next = newLink (); - sym->etype->class = SPECIFIER; + sym->etype = sym->etype->next = newLink (SPECIFIER); } SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p)); SPEC_CONST (sym->etype) = SPEC_CONST (DCL_TSPEC (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; } @@ -489,7 +508,7 @@ void checkTypeSanity(sym_link *etype, char *name) { noun=nounName(etype); if (getenv("DEBUG_SANITY")) { - fprintf (stderr, "checking sanity for %s %x\n", name, (int)etype); + fprintf (stderr, "checking sanity for %s %p\n", name, etype); } if ((SPEC_NOUN(etype)==V_CHAR || @@ -538,36 +557,15 @@ 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,41 +611,36 @@ 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); - + 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 symlink; -} + /* 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); -/*------------------------------------------------------------------*/ -/* cloneSpec - copies the entire spec and returns a new spec */ -/*------------------------------------------------------------------*/ -sym_link * -cloneSpec (sym_link * src) -{ - sym_link *spec; - - /* go thru chain till we find the specifier */ - while (src && src->class != SPECIFIER) - src = src->next; - - spec = newLink (); - memcpy (spec, src, sizeof (sym_link)); - return spec; + return dest; } /*------------------------------------------------------------------*/ @@ -659,7 +652,7 @@ genSymName (int level) static int gCount = 0; static char gname[SDCC_NAME_MAX + 1]; - sprintf (gname, "__%04d%04d", level, gCount++); + SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++); return gname; } @@ -686,8 +679,7 @@ newCharLink () { sym_link *p; - p = newLink (); - p->class = SPECIFIER; + p = newLink (SPECIFIER); SPEC_NOUN (p) = V_CHAR; return p; @@ -701,8 +693,7 @@ newFloatLink () { sym_link *p; - p = newLink (); - p->class = SPECIFIER; + p = newLink (SPECIFIER); SPEC_NOUN (p) = V_FLOAT; return p; @@ -716,8 +707,7 @@ newLongLink () { sym_link *p; - p = newLink (); - p->class = SPECIFIER; + p = newLink (SPECIFIER); SPEC_NOUN (p) = V_INT; SPEC_LONG (p) = 1; @@ -732,8 +722,7 @@ newIntLink () { sym_link *p; - p = newLink (); - p->class = SPECIFIER; + p = newLink (SPECIFIER); SPEC_NOUN (p) = V_INT; return p; @@ -776,10 +765,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: @@ -787,6 +780,7 @@ getSize (sym_link * p) case EEPPOINTER: case FPOINTER: case CPOINTER: + case FUNCTION: return (FPTRSIZE); case GPOINTER: return (GPTRSIZE); @@ -835,8 +829,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: @@ -846,6 +838,7 @@ bitsForType (sym_link * p) case EEPPOINTER: case FPOINTER: case CPOINTER: + case FUNCTION: return (FPTRSIZE * 8); case GPOINTER: return (GPTRSIZE * 8); @@ -890,9 +883,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; } @@ -976,13 +967,16 @@ addSymChain (symbol * symHead) werror (E_EXTERN_MISMATCH, csym->name); continue; } - /* delete current entry */ - deleteSym (SymbolTab, csym, csym->name); } else { /* not extern */ - werror (E_DUPLICATE, sym->name); - continue; + if (compareType (csym->type, sym->type) != 1) { + werror (E_DUPLICATE, sym->name); + continue; + } } + /* delete current entry */ + deleteSym (SymbolTab, csym, csym->name); + deleteFromSeg(csym); } /* add new entry */ @@ -1010,35 +1004,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(); } /*------------------------------------------------------------------*/ @@ -1073,7 +1065,7 @@ compStructSize (int su, structdef * sdef) while (loop) { /* create the internal name for this variable */ - sprintf (loop->rname, "_%s", loop->name); + SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name); loop->offset = (su == UNION ? sum = 0 : sum); SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0); @@ -1108,11 +1100,6 @@ compStructSize (int su, structdef * sdef) 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 */ @@ -1141,49 +1128,50 @@ 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 */ 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 */ + /* if sfr or sbit then must also be volatile */ if (SPEC_SCLS (sym->etype) == S_SBIT || SPEC_SCLS (sym->etype) == S_SFR) { SPEC_VOLATILE (sym->etype) = 1; - /* if initial value given */ - if (sym->ival) - { - SPEC_ABSA (sym->etype) = 1; - SPEC_ADDR (sym->etype) = - (int) list2int (sym->ival); - 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_CONST (sym->etype)) { + SPEC_CONST (sym->etype) && + SPEC_SCLS(sym->etype) == S_FIXED && + !IS_FUNC(sym->type)) { 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; - + port->mem.code_ro) { + if (IS_SPEC(sym->type)) { + SPEC_CONST (sym->type) = 1; + } else { + DCL_PTR_CONST (sym->type) = 1; + } + } /* if bit variable then no storage class can be */ /* specified since bit is already a storage */ @@ -1263,7 +1251,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); @@ -1274,7 +1262,8 @@ checkSClass (symbol * sym, int isProto) * control this allcoation, but the code was originally that way, and * changing it for non-390 ports breaks the compiler badly. */ - bool useXdata = TARGET_IS_DS390 ? 1 : options.useXstack; + bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ? + 1 : options.useXstack; SPEC_SCLS (sym->etype) = (useXdata ? S_XDATA : S_FIXED); } @@ -1296,7 +1285,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; } @@ -1329,11 +1318,11 @@ copyLinkChain (sym_link * p) sym_link *head, *curr, *loop; curr = p; - head = loop = (curr ? newLink () : (void *) NULL); + head = loop = (curr ? newLink (p->class) : (void *) NULL); while (curr) { memcpy (loop, curr, sizeof (sym_link)); /* copy it */ - loop->next = (curr->next ? newLink () : (void *) NULL); + loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL); loop = loop->next; curr = curr->next; } @@ -1413,11 +1402,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); @@ -1461,8 +1450,15 @@ 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 (dest) && IS_GENPTR (src) && IS_VOID(src->next)) { + return 1; + } if (IS_PTR (src) && IS_GENPTR (dest)) return -1; if (IS_PTR (dest) && IS_ARRAY (src)) { @@ -1539,6 +1535,7 @@ 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; @@ -1563,7 +1560,7 @@ aggregateToPointer (value * val) sym_link *p = val->type; werror (W_STRUCT_AS_ARG, val->name); - val->type = newLink (); + val->type = newLink (DECLARATOR); val->type->next = p; } @@ -1578,20 +1575,13 @@ aggregateToPointer (value * val) DCL_TYPE (val->type) = PPOINTER; break; case S_FIXED: - 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; - break; - } - if (options.model==MODEL_LARGE) { - DCL_TYPE (val->type) = FPOINTER; - break; + if (SPEC_OCLS(val->etype)) { + DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype)); + } else { + // this happens for (external) function parameters + DCL_TYPE (val->type) = port->unqualified_pointer; } - /* fall through! */ + break; case S_AUTO: case S_DATA: case S_REGISTER: @@ -1607,7 +1597,7 @@ aggregateToPointer (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 */ @@ -1624,9 +1614,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; @@ -1662,21 +1651,43 @@ 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 + SNPRINTF (acargs->name, sizeof(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; + strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname)); + } 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; @@ -1686,33 +1697,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; @@ -1742,6 +1748,7 @@ checkFunction (symbol * sym) if (compareType (exargs->type, checkValue->type) <= 0) { werror (E_ARG_TYPE, argCnt); + printFromToType(exargs->type, checkValue->type); return 0; } } @@ -1754,6 +1761,7 @@ checkFunction (symbol * sym) /* replace with this defition */ sym->cdef = csym->cdef; deleteSym (SymbolTab, csym, csym->name); + deleteFromSeg(csym); addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1); if (IS_EXTERN (csym->etype) && ! IS_EXTERN (sym->etype)) @@ -1763,30 +1771,63 @@ checkFunction (symbol * sym) return 1; } +/*------------------------------------------------------------------*/ +/* cdbStructBlock - calls struct printing for a blcks */ +/*------------------------------------------------------------------*/ +void cdbStructBlock (int block) +{ + int i; + bucket **table = StructTab; + bucket *chain; + + /* go thru the entire table */ + for (i = 0; i < 256; i++) + { + for (chain = table[i]; chain; chain = chain->next) + { + if (chain->block >= block) + { + if(debugFile) + debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL); + } + } + } +} + /*-----------------------------------------------------------------*/ /* 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; } @@ -1796,19 +1837,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)) { aggregateToPointer (val); } + val = val->next; pNum++; } @@ -1817,17 +1863,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) { @@ -1836,30 +1882,38 @@ processFuncArgs (symbol * func, int ignoreName) /* synthesize a variable name */ if (!val->sym) { - - sprintf (val->name, "_%s_PARM_%d", func->name, pNum++); + SNPRINTF (val->name, sizeof(val->name), + "_%s_PARM_%d", func->name, pNum++); val->sym = newSymbol (val->name, 1); SPEC_OCLS (val->etype) = port->mem.default_local_map; val->sym->type = copyLinkChain (val->type); val->sym->etype = getSpec (val->sym->type); val->sym->_isparm = 1; - strcpy (val->sym->rname, val->name); - SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) = - SPEC_STAT (func->etype); + strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname)); + if (IS_SPEC(func->etype)) { + SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) = + SPEC_STAT (func->etype); + } addSymChain (val->sym); } else /* symbol name given create synth name */ { - sprintf (val->name, "_%s_PARM_%d", func->name, pNum++); - strcpy (val->sym->rname, val->name); + SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++); + strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname)); val->sym->_isparm = 1; SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = (options.model != MODEL_SMALL ? xdata : data); - SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) = - SPEC_STAT (func->etype); + if (IS_SPEC(func->etype)) { + SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) = + SPEC_STAT (func->etype); + } } + if (!isinSet(operKeyReset, val->sym)) { + addSet (&operKeyReset, val->sym); + applyToSet (operKeyReset, resetParmKey); + } val = val->next; } } @@ -1898,6 +1952,7 @@ printTypeChain (sym_link * start, FILE * of) { int nlr = 0; sym_link * type, * search; + STORAGE_CLASS scls; if (!of) { @@ -1906,103 +1961,102 @@ printTypeChain (sym_link * start, FILE * of) } if (start==NULL) { - fprintf (of, "**err**"); + fprintf (of, "void"); return; } - /* print the chain as it is written in the source: */ - /* start with the last entry */ + /* Print the chain as it is written in the source: */ + /* start with the last entry. */ + /* However, the storage class at the end of the */ + /* chain reall applies to the first in the chain! */ + for (type = start; type && type->next; type = type->next) ; + scls=SPEC_SCLS(type); while (type) { + if (type==start) { + switch (scls) + { + 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 (IS_DECL (type)) { - if (DCL_PTR_VOLATILE (type)) { - fprintf (of, "volatile "); + if (!IS_FUNC(type)) { + if (DCL_PTR_VOLATILE (type)) { + fprintf (of, "volatile-"); + } + if (DCL_PTR_CONST (type)) { + fprintf (of, "const-"); + } } 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: - 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, "[] "); + 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 "); + fprintf (of, "volatile-"); if (SPEC_CONST (type)) - fprintf (of, "const "); - + fprintf (of, "const-"); + if (SPEC_USIGN (type)) + fprintf (of, "unsigned-"); switch (SPEC_NOUN (type)) { case V_INT: if (IS_LONG (type)) - fprintf (of, "long "); + fprintf (of, "long-"); fprintf (of, "int"); break; @@ -2039,217 +2093,17 @@ printTypeChain (sym_link * start, FILE * of) break; } } - /* search entry in list before "type" */ - for (search = start; search && search->next != type;) - search = search->next; - type = search; - if (type) - fputc (' ', of); + /* 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"); } -/*-----------------------------------------------------------------*/ -/* cdbTypeInfo - print the type information for debugger */ -/*-----------------------------------------------------------------*/ -void -cdbTypeInfo (sym_link * type, FILE * of) -{ - fprintf (of, "{%d}", getSize (type)); - while (type) - { - if (IS_DECL (type)) - { - switch (DCL_TYPE (type)) - { - case FUNCTION: - fprintf (of, "DF,"); - break; - case GPOINTER: - fprintf (of, "DG,"); - break; - case CPOINTER: - fprintf (of, "DC,"); - break; - case FPOINTER: - fprintf (of, "DX,"); - break; - case POINTER: - fprintf (of, "DD,"); - break; - case IPOINTER: - fprintf (of, "DI,"); - break; - case PPOINTER: - fprintf (of, "DP,"); - break; - case EEPPOINTER: - fprintf (of, "DA,"); - break; - case ARRAY: - fprintf (of, "DA%d,", DCL_ELEM (type)); - break; - default: - break; - } - } - else - { - switch (SPEC_NOUN (type)) - { - case V_INT: - if (IS_LONG (type)) - fprintf (of, "SL"); - else - fprintf (of, "SI"); - break; - - case V_CHAR: - fprintf (of, "SC"); - break; - - case V_VOID: - fprintf (of, "SV"); - break; - - case V_FLOAT: - fprintf (of, "SF"); - break; - - case V_STRUCT: - fprintf (of, "ST%s", SPEC_STRUCT (type)->tag); - break; - - case V_SBIT: - fprintf (of, "SX"); - break; - - case V_BIT: - fprintf (of, "SB%d$%d", SPEC_BSTR (type), SPEC_BLEN (type)); - break; - - default: - break; - } - fputs (":", of); - if (SPEC_USIGN (type)) - fputs ("U", of); - else - fputs ("S", of); - } - type = type->next; - } -} -/*-----------------------------------------------------------------*/ -/* cdbSymbol - prints a symbol & its type information for debugger */ -/*-----------------------------------------------------------------*/ -void -cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc) -{ - memmap *map; - - if (!sym) - return; - if (!of) - of = stdout; - - if (isFunc) - fprintf (of, "F:"); - else - fprintf (of, "S:"); /* symbol record */ - /* if this is not a structure symbol then - we need to figure out the scope information */ - if (!isStructSym) - { - if (!sym->level) - { - /* global */ - if (IS_STATIC (sym->etype)) - fprintf (of, "F%s$", moduleName); /* scope is file */ - else - fprintf (of, "G$"); /* scope is global */ - } - else - /* symbol is local */ - fprintf (of, "L%s$", (sym->localof ? sym->localof->name : "-null-")); - } - else - fprintf (of, "S$"); /* scope is structure */ - - /* print the name, & mangled name */ - fprintf (of, "%s$%d$%d(", sym->name, - sym->level, sym->block); - - cdbTypeInfo (sym->type, of); - fprintf (of, "),"); - - /* print the address space */ - map = SPEC_OCLS (sym->etype); - fprintf (of, "%c,%d,%d", - (map ? map->dbName : 'Z'), sym->onStack, SPEC_STAK (sym->etype)); - - /* if assigned to registers then output register names */ - /* if this is a function then print - 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)); - /* alternate location to find this symbol @ : eg registers - or spillication */ - - if (!isStructSym) - fprintf (of, "\n"); -} - -/*-----------------------------------------------------------------*/ -/* cdbStruct - print a structure for debugger */ -/*-----------------------------------------------------------------*/ -void -cdbStruct (structdef * sdef, int block, FILE * of, - int inStruct, char *tag) -{ - symbol *sym; - - fprintf (of, "T:"); - /* if block # then must have function scope */ - fprintf (of, "F%s$", moduleName); - fprintf (of, "%s[", (tag ? tag : sdef->tag)); - for (sym = sdef->fields; sym; sym = sym->next) - { - fprintf (of, "({%d}", sym->offset); - cdbSymbol (sym, of, TRUE, FALSE); - fprintf (of, ")"); - } - fprintf (of, "]"); - if (!inStruct) - fprintf (of, "\n"); -} - -/*------------------------------------------------------------------*/ -/* cdbStructBlock - calls struct printing for a blcks */ -/*------------------------------------------------------------------*/ -void -cdbStructBlock (int block, FILE * of) -{ - int i; - bucket **table = StructTab; - bucket *chain; - wassert (of); - - /* go thru the entire table */ - for (i = 0; i < 256; i++) - { - for (chain = table[i]; chain; chain = chain->next) - { - if (chain->block >= block) - { - cdbStruct ((structdef *) chain->sym, chain->block, of, 0, NULL); - } - } - } -} /*-----------------------------------------------------------------*/ /* powof2 - returns power of two for the number if number is pow 2 */ @@ -2308,6 +2162,109 @@ _mangleFunctionName(char *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(DECLARATOR); + 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(DECLARATOR); + nr->next = r; + r = nr; + 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(DECLARATOR); + nr->next = r; + r = nr; + 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; +} + /*-----------------------------------------------------------------*/ /* initCSupport - create functions for C support routines */ /*-----------------------------------------------------------------*/ @@ -2342,7 +2299,7 @@ initCSupport () for (bwd = 0; bwd < 3; bwd++) { - sym_link *l; + sym_link *l = NULL; switch (bwd) { case 0: @@ -2381,13 +2338,13 @@ initCSupport () { if (tofrom) { - sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]); - __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], floatType, 1, options.float_rent); + SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]); + __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent); } else { - sprintf (buffer, "__%s%s2fs", ssu[su], sbwd[bwd]); - __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), floatType, __multypes[bwd][su], 1, options.float_rent); + SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]); + __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent); } } } @@ -2399,12 +2356,13 @@ initCSupport () { for (su = 0; su < 2; su++) { - sprintf (buffer, "_%s%s%s", + SNPRINTF (buffer, sizeof(buffer), + "_%s%s%s", smuldivmod[muldivmod], 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; } } } @@ -2415,13 +2373,52 @@ initCSupport () { for (su = 0; su < 2; su++) { - sprintf (buffer, "_%s%s%s", + SNPRINTF (buffer, sizeof(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; + 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 */ + } +} + +sym_link *validateLink(sym_link *l, + const char *macro, + const char *args, + const char select, + const char *file, + unsigned line) +{ + if (l && l->class==select) + { + return l; + } + fprintf(stderr, + "Internal error: validateLink failed in %s(%s) @ %s:%u:" + " expected %s, got %s\n", + macro, args, file, line, + DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link"); + exit(-1); + return l; // never reached, makes compiler happy. +}