X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCglue.c;h=c4ef6f2f5e4ef2f02c53992e1dcbb2b561904220;hb=13c4a266f057acdfbd8faa30832e0d042d9089ab;hp=2657dbfaf0c8409f9ea28cf7d7f47e93a7aa9c20;hpb=4eee1f5d91f90e8b3e24168c0f14a4d771adc697;p=fw%2Fsdcc diff --git a/src/SDCCglue.c b/src/SDCCglue.c index 2657dbfa..c4ef6f2f 100644 --- a/src/SDCCglue.c +++ b/src/SDCCglue.c @@ -60,7 +60,7 @@ DEFSETFUNC (closeTmpFiles) } /*-----------------------------------------------------------------*/ -/* rmTmpFiles - closes all tmp files created by the compiler */ +/* rmTmpFiles - unlinks all tmp files created by the compiler */ /* because of BRAIN DEAD MS/DOS & CYGNUS Libraries */ /*-----------------------------------------------------------------*/ DEFSETFUNC (rmTmpFiles) @@ -70,11 +70,26 @@ DEFSETFUNC (rmTmpFiles) if (name) { unlink (name); - free (name); + Safe_free (name); } return 0; } +/*-----------------------------------------------------------------*/ +/* rm_tmpfiles - close and remove temporary files and delete sets */ +/*-----------------------------------------------------------------*/ +void +rm_tmpfiles (void) +{ + /* close temporary files */ + applyToSet (tmpfileSet, closeTmpFiles); + /* remove temporary files */ + applyToSet (tmpfileNameSet, rmTmpFiles); + /* delete temorary file sets */ + deleteSet (&tmpfileSet); + deleteSet (&tmpfileNameSet); +} + /*-----------------------------------------------------------------*/ /* copyFile - copies source file to destination file */ /*-----------------------------------------------------------------*/ @@ -92,13 +107,17 @@ copyFile (FILE * dest, FILE * src) char * aopLiteralLong (value * val, int offset, int size) { - char *rs; union { float f; unsigned char c[4]; } fl; + if (!val) { + // assuming we have been warned before + val=constVal("0"); + } + /* if it is a float then it gets tricky */ /* otherwise it is fairly simple */ if (!IS_FLOAT (val->type)) { @@ -107,17 +126,18 @@ aopLiteralLong (value * val, int offset, int size) v >>= (offset * 8); switch (size) { case 1: - tsprintf (buffer, "!immedbyte", (unsigned int) v & 0xff); + tsprintf (buffer, sizeof(buffer), + "!immedbyte", (unsigned int) v & 0xff); break; case 2: - tsprintf (buffer, "!immedword", (unsigned int) v & 0xffff); + tsprintf (buffer, sizeof(buffer), + "!immedword", (unsigned int) v & 0xffff); break; default: /* Hmm. Too big for now. */ assert (0); } - rs = Safe_calloc (1, strlen (buffer) + 1); - return strcpy (rs, buffer); + return Safe_strdup (buffer); } /* PENDING: For now size must be 1 */ @@ -126,12 +146,13 @@ aopLiteralLong (value * val, int offset, int size) /* it is type float */ fl.f = (float) floatFromVal (val); #ifdef _BIG_ENDIAN - tsprintf (buffer, "!immedbyte", fl.c[3 - offset]); + tsprintf (buffer, sizeof(buffer), + "!immedbyte", fl.c[3 - offset]); #else - tsprintf (buffer, "!immedbyte", fl.c[offset]); + tsprintf (buffer, sizeof(buffer), + "!immedbyte", fl.c[offset]); #endif - rs = Safe_calloc (1, strlen (buffer) + 1); - return strcpy (rs, buffer); + return Safe_strdup (buffer); } /*-----------------------------------------------------------------*/ @@ -149,9 +170,11 @@ aopLiteral (value * val, int offset) static void emitRegularMap (memmap * map, bool addPublics, bool arFlag) { - symbol *sym, *symIval; + symbol *sym; ast *ival = NULL; - memmap *segment; + + if (!map) + return; if (addPublics) { @@ -165,34 +188,41 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) else tfprintf (map->oFile, "\t!area\n", map->sname); } - - /* print the area name */ + for (sym = setFirstItem (map->syms); sym; sym = setNextItem (map->syms)) { + symbol *newSym=NULL; /* if extern then add it into the extern list */ if (IS_EXTERN (sym->etype)) { - addSetHead (&externs, sym); + addSetHead (&externs, sym); continue; } /* if allocation required check is needed then check if the symbol really requires allocation only for local variables */ + if (arFlag && !IS_AGGREGATE (sym->type) && !(sym->_isparm && !IS_REGPARM (sym->etype)) && !sym->allocreq && sym->level) continue; + /* for bitvar locals and parameters */ + if (!arFlag && !sym->allocreq && sym->level + && !SPEC_ABSA (sym->etype)) { + continue; + } + /* if global variable & not static or extern and addPublics allowed then add it to the public set */ if ((sym->level == 0 || (sym->_isparm && !IS_REGPARM (sym->etype))) && addPublics && !IS_STATIC (sym->etype) && - (sym->used || sym->fbody)) + (IS_FUNC(sym->type) ? (sym->used || IFFUNC_HASBODY(sym->type)) : 1)) { addSetHead (&publics, sym); } @@ -216,56 +246,86 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) fprintf (map->oFile, "%s$%d$%d", sym->name, sym->level, sym->block); } + /* if it has an initial value then do it only if + it is a global variable */ + if (sym->ival && sym->level == 0) { + if (SPEC_OCLS(sym->etype)==xidata) { + // create a new "XINIT (CODE)" symbol, that will be emitted later + newSym=copySymbol (sym); + SPEC_OCLS(newSym->etype)=xinit; + SNPRINTF (newSym->name, sizeof(newSym->name), "__xinit_%s", sym->name); + SNPRINTF (newSym->rname, sizeof(newSym->rname), "__xinit_%s", sym->rname); + SPEC_CONST(newSym->etype)=1; + SPEC_STAT(newSym->etype)=1; + resolveIvalSym(newSym->ival); + + // add it to the "XINIT (CODE)" segment + addSet(&xinit->syms, newSym); + sym->ival=NULL; + } else { + if (IS_AGGREGATE (sym->type)) { + ival = initAggregates (sym, sym->ival, NULL); + } else { + if (getNelements(sym->type, sym->ival)>1) { + werror (W_EXCESS_INITIALIZERS, "scalar", + sym->name, sym->lineDef); + } + ival = newNode ('=', newAst_VALUE (symbolVal (sym)), + decorateType (resolveSymbols (list2expr (sym->ival)))); + } + codeOutFile = statsg->oFile; + + if (ival) { + // set ival's lineno to where the symbol was defined + setAstLineno (ival, lineno=sym->lineDef); + // check if this is not a constant expression + if (!constExprTree(ival)) { + werror (E_CONST_EXPECTED, "found expression"); + // but try to do it anyway + } + allocInfo = 0; + eBBlockFromiCode (iCodeFromAst (ival)); + allocInfo = 1; + } + } + sym->ival = NULL; + } + /* if is has an absolute address then generate an equate for this no need to allocate space */ if (SPEC_ABSA (sym->etype)) { + char *equ="="; if (options.debug) { fprintf (map->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); } - fprintf (map->oFile, "%s\t=\t0x%04x\n", - sym->rname, + if (TARGET_IS_XA51) { + if (map==sfr) { + equ="sfr"; + } else if (map==bit || map==sfrbit) { + equ="bit"; + } + } + fprintf (map->oFile, "%s\t%s\t0x%04x\n", + sym->rname, equ, SPEC_ADDR (sym->etype)); } - else - { - /* allocate space */ - if (options.debug) { - fprintf (map->oFile, "==.\n"); - } - if (IS_STATIC (sym->etype)) - tfprintf (map->oFile, "!slabeldef\n", sym->rname); - else - tfprintf (map->oFile, "!labeldef\n", sym->rname); - tfprintf (map->oFile, "\t!ds\n", - (unsigned int) getSize (sym->type) & 0xffff); + else { + int size = getSize (sym->type); + if (size==0) { + werror(E_UNKNOWN_SIZE,sym->name); } - - /* if it has an initial value then do it only if - it is a global variable */ - if (sym->ival && sym->level == 0) - { - if (IS_AGGREGATE (sym->type)) - ival = initAggregates (sym, sym->ival, NULL); - else - ival = newNode ('=', newAst_VALUE (symbolVal (sym)), - decorateType (resolveSymbols (list2expr (sym->ival)))); - codeOutFile = statsg->oFile; - allocInfo = 0; - - // set ival's lineno to where the symbol was defined - ival->lineno=sym->lineDef; - - eBBlockFromiCode (iCodeFromAst (ival)); - allocInfo = 1; - - /* if the ival was a symbol, delete it from its segment */ - if (symIval=AST_SYMBOL(sym->ival->init.node)) { - segment = SPEC_OCLS (symIval->etype); - deleteSetItem (&segment->syms, symIval); - } - sym->ival = NULL; + /* allocate space */ + if (options.debug) { + fprintf (map->oFile, "==.\n"); } + if (IS_STATIC (sym->etype)) + tfprintf (map->oFile, "!slabeldef\n", sym->rname); + else + tfprintf (map->oFile, "!labeldef\n", sym->rname); + tfprintf (map->oFile, "\t!ds\n", + (unsigned int) size & 0xffff); + } } } @@ -273,7 +333,7 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) /* initPointer - pointer initialization code massaging */ /*-----------------------------------------------------------------*/ value * -initPointer (initList * ilist) +initPointer (initList * ilist, sym_link *toType) { value *val; ast *expr = list2expr (ilist); @@ -285,6 +345,29 @@ initPointer (initList * ilist) if ((val = constExprValue (expr, FALSE))) return val; + /* ( ptr + constant ) */ + if (IS_AST_OP (expr) && + (expr->opval.op == '+' || expr->opval.op == '-') && + IS_AST_SYM_VALUE (expr->left) && + (IS_ARRAY(expr->left->ftype) || IS_PTR(expr->left->ftype)) && + compareType(toType, expr->left->ftype) && + IS_AST_LIT_VALUE (expr->right)) { + return valForCastAggr (expr->left, expr->left->ftype, + expr->right, + expr->opval.op); + } + + /* (char *)&a */ + if (IS_AST_OP(expr) && expr->opval.op==CAST && + IS_AST_OP(expr->right) && expr->right->opval.op=='&') { + if (compareType(toType, expr->left->ftype)!=1) { + werror (W_INIT_WRONG); + printFromToType(expr->left->ftype, toType); + } + // skip the cast ??? + expr=expr->right; + } + /* no then we have to do these cludgy checks */ /* pointers can be initialized with address of a variable or address of an array element */ @@ -328,10 +411,10 @@ initPointer (initList * ilist) (&some_struct)->element */ if (IS_AST_OP (expr->left) && expr->left->opval.op == PTR_OP && - IS_ADDRESS_OF_OP (expr->left->left)) - return valForStructElem (expr->left->left->left, - expr->left->right); - + IS_ADDRESS_OF_OP (expr->left->left)) { + return valForStructElem (expr->left->left->left, + expr->left->right); + } } /* case 3. (((char *) &a) +/- constant) */ if (IS_AST_OP (expr) && @@ -346,7 +429,6 @@ initPointer (initList * ilist) expr->right, expr->opval.op); } - /* case 4. (char *)(array type) */ if (IS_CAST_OP(expr) && IS_AST_SYM_VALUE (expr->right) && IS_ARRAY(expr->right->ftype)) { @@ -372,7 +454,7 @@ initPointer (initList * ilist) return val; } wrong: - werror (E_INIT_WRONG); + werror (E_INCOMPAT_PTYPES); return NULL; } @@ -436,20 +518,18 @@ pointerTypeToGPByte (const int p_type, const char *iname, const char *oname) { case IPOINTER: case POINTER: - return 0; + return GPTYPE_NEAR; case GPOINTER: - /* hack - if we get a generic pointer, we just assume - * it's an FPOINTER (i.e. in XDATA space). - */ - werror (E_CANNOT_USE_GENERIC_POINTER, iname, oname); + werror (E_CANNOT_USE_GENERIC_POINTER, + iname ? iname : "", + oname ? oname : ""); exit (1); - // fall through case FPOINTER: - return 1; + return GPTYPE_FAR; case CPOINTER: - return 2; + return GPTYPE_CODE; case PPOINTER: - return 3; + return GPTYPE_XSTACK; default: fprintf (stderr, "*** internal error: unknown pointer type %d in GPByte.\n", p_type); @@ -501,7 +581,7 @@ printGPointerType (FILE * oFile, const char *iname, const char *oname, /* printIvalType - generates ival for int/char */ /*-----------------------------------------------------------------*/ void -printIvalType (sym_link * type, initList * ilist, FILE * oFile) +printIvalType (symbol *sym, sym_link * type, initList * ilist, FILE * oFile) { value *val; @@ -509,7 +589,19 @@ printIvalType (sym_link * type, initList * ilist, FILE * oFile) if (ilist->type == INIT_DEEP) ilist = ilist->init.deep; - val = list2val (ilist); + if (!IS_AGGREGATE(sym->type) && getNelements(type, ilist)>1) { + werror (W_EXCESS_INITIALIZERS, "scalar", sym->name, sym->lineDef); + } + + if (!(val = list2val (ilist))) { + // assuming a warning has been thrown + val=constVal("0"); + } + + if (val->type != type) { + val = valCastLiteral(type, floatFromVal(val)); + } + switch (getSize (type)) { case 1: if (!val) @@ -611,9 +703,12 @@ printIvalStruct (symbol * sym, sym_link * type, if (IS_BITFIELD(sflds->type)) { printIvalBitFields(&sflds,&iloop,oFile); } else { - printIval (sflds, sflds->type, iloop, oFile); + printIval (sym, sflds->type, iloop, oFile); } } + if (iloop) { + werror (W_EXCESS_INITIALIZERS, "struct", sym->name, sym->lineDef); + } return; } @@ -655,22 +750,27 @@ printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) /*-----------------------------------------------------------------*/ /* printIvalArray - generates code for array initialization */ /*-----------------------------------------------------------------*/ -void +void printIvalArray (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) { initList *iloop; int lcnt = 0, size = 0; + sym_link *last_type; /* take care of the special case */ /* array of characters can be init */ /* by a string */ - if (IS_CHAR (type->next)) + if (IS_CHAR (type->next)) { + if (!IS_LITERAL(list2val(ilist)->etype)) { + werror (E_CONST_EXPECTED); + return; + } if (printIvalChar (type, (ilist->type == INIT_DEEP ? ilist->init.deep : ilist), oFile, SPEC_CVAL (sym->etype).v_char)) return; - + } /* not the special case */ if (ilist->type != INIT_DEEP) { @@ -680,6 +780,8 @@ printIvalArray (symbol * sym, sym_link * type, initList * ilist, iloop = ilist->init.deep; lcnt = DCL_ELEM (type); + for (last_type = type->next; last_type && DCL_ELEM (last_type); last_type = last_type->next) + lcnt *= DCL_ELEM (last_type); for (;;) { @@ -698,7 +800,7 @@ printIvalArray (symbol * sym, sym_link * type, initList * ilist, if (!--lcnt) { /* if initializers left */ if (iloop) { - werror (W_EXESS_ARRAY_INITIALIZERS, sym->name, sym->lineDef); + werror (W_EXCESS_INITIALIZERS, "array", sym->name, sym->lineDef); } break; } @@ -721,6 +823,21 @@ printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) int dLvl = 0; val = list2val (ilist); + + if (!val) { + // an error has been thrown allready + val=constVal("0"); + } + + if (IS_LITERAL(val->etype)) { + if (compareType(type,val->etype)==0) { + werror (E_INCOMPAT_TYPES); + printFromToType (val->type, type); + } + printIvalCharPtr (NULL, type, val, oFile); + return; + } + /* check the types */ if ((dLvl = compareType (val->type, type->next)) <= 0) { @@ -806,7 +923,7 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) } else { - /* What is this case? Are these pointers? */ + // these are literals assigned to pointers switch (size) { case 1: @@ -820,9 +937,25 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) aopLiteral (val, 0), aopLiteral (val, 1)); break; case 3: - /* PENDING: 0x02 or 0x%02x, CDATA? */ - fprintf (oFile, "\t.byte %s,%s,#0x02\n", - aopLiteral (val, 0), aopLiteral (val, 1)); + if (IS_GENPTR(type) && floatFromVal(val)!=0) { + // non-zero mcs51 generic pointer + werror (E_LITERAL_GENERIC); + } + fprintf (oFile, "\t.byte %s,%s,%s\n", + aopLiteral (val, 0), + aopLiteral (val, 1), + aopLiteral (val, 2)); + break; + case 4: + if (IS_GENPTR(type) && floatFromVal(val)!=0) { + // non-zero ds390 generic pointer + werror (E_LITERAL_GENERIC); + } + fprintf (oFile, "\t.byte %s,%s,%s,%s\n", + aopLiteral (val, 0), + aopLiteral (val, 1), + aopLiteral (val, 2), + aopLiteral (val, 3)); break; default: assert (0); @@ -856,7 +989,7 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) return; } - if (!(val = initPointer (ilist))) + if (!(val = initPointer (ilist, type))) return; /* if character pointer */ @@ -865,8 +998,10 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) return; /* check the type */ - if (compareType (type, val->type) == 0) - werror (E_INIT_WRONG); + if (compareType (type, val->type) == 0) { + werror (W_INIT_WRONG); + printFromToType (val->type, type); + } /* if val is literal */ if (IS_LITERAL (val->etype)) @@ -882,9 +1017,9 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) else tfprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); break; - case 3: - fprintf (oFile, "\t.byte %s,%s,#0x02\n", - aopLiteral (val, 0), aopLiteral (val, 1)); + case 3: // how about '390?? + fprintf (oFile, "\t.byte %s,%s,#0x%d\n", + aopLiteral (val, 0), aopLiteral (val, 1), GPTYPE_CODE); } return; } @@ -922,6 +1057,9 @@ printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) if (!ilist) return; + /* update line number for error msgs */ + lineno=sym->lineDef; + /* if structure then */ if (IS_STRUCT (type)) { @@ -946,7 +1084,7 @@ printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) /* if type is SPECIFIER */ if (IS_SPEC (type)) { - printIvalType (type, ilist, oFile); + printIvalType (sym, type, ilist, oFile); return; } } @@ -959,9 +1097,7 @@ emitStaticSeg (memmap * map, FILE * out) { symbol *sym; - /* fprintf(map->oFile,"\t.area\t%s\n",map->sname); */ - if (!out) - out = code->oFile; + /* fprintf(out, "\t.area\t%s\n", map->sname); */ /* for all variables in this segment do */ for (sym = setFirstItem (map->syms); sym; @@ -975,7 +1111,9 @@ emitStaticSeg (memmap * map, FILE * out) /* if it is not static add it to the public table */ if (!IS_STATIC (sym->etype)) - addSetHead (&publics, sym); + { + addSetHead (&publics, sym); + } /* print extra debug info if required */ if (options.debug) { @@ -1017,19 +1155,28 @@ emitStaticSeg (memmap * map, FILE * out) resolveIvalSym (sym->ival); printIval (sym, sym->type, sym->ival, out); noAlloc--; + // if sym->ival is a string, WE don't need it anymore + if (IS_AST_SYM_VALUE(list2expr(sym->ival)) && + list2val(sym->ival)->sym->isstrlit) { + freeStringSymbol(list2val(sym->ival)->sym); + } } - else - { + else { /* allocate space */ + int size = getSize (sym->type); + + if (size==0) { + werror(E_UNKNOWN_SIZE,sym->name); + } fprintf (out, "%s:\n", sym->rname); /* special case for character strings */ if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) && SPEC_CVAL (sym->etype).v_char) - printChar (out, - SPEC_CVAL (sym->etype).v_char, - strlen (SPEC_CVAL (sym->etype).v_char) + 1); + printChar (out, + SPEC_CVAL (sym->etype).v_char, + strlen (SPEC_CVAL (sym->etype).v_char) + 1); else - tfprintf (out, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff); + tfprintf (out, "\t!ds\n", (unsigned int) size & 0xffff); } } } @@ -1039,7 +1186,7 @@ emitStaticSeg (memmap * map, FILE * out) /* emitMaps - emits the code for the data portion the code */ /*-----------------------------------------------------------------*/ void -emitMaps () +emitMaps (void) { inInitMode++; /* no special considerations for the following @@ -1048,12 +1195,19 @@ emitMaps () emitRegularMap (idata, TRUE, TRUE); emitRegularMap (bit, TRUE, FALSE); emitRegularMap (xdata, TRUE, TRUE); + if (port->genXINIT) { + emitRegularMap (xidata, TRUE, TRUE); + } emitRegularMap (sfr, FALSE, FALSE); emitRegularMap (sfrbit, FALSE, FALSE); emitRegularMap (home, TRUE, FALSE); emitRegularMap (code, TRUE, FALSE); emitStaticSeg (statsg, code->oFile); + if (port->genXINIT) { + tfprintf (code->oFile, "\t!area\n", xinit->sname); + emitStaticSeg (xinit, code->oFile); + } inInitMode--; } @@ -1081,13 +1235,13 @@ createInterruptVect (FILE * vFile) /* only if the main function exists */ if (!(mainf = findSymWithLevel (SymbolTab, mainf))) { - if (!options.cc_only && !noAssemble) + if (!options.cc_only && !noAssemble && !options.c1mode) werror (E_NO_MAIN); return; } /* if the main is only a prototype ie. no body then do nothing */ - if (!mainf->fbody) + if (!IFFUNC_HASBODY(mainf->type)) { /* if ! compile only then main function should be present */ if (!options.cc_only && !noAssemble) @@ -1102,7 +1256,6 @@ createInterruptVect (FILE * vFile) if (!port->genIVT || !(port->genIVT (vFile, interrupts, maxInterrupts))) { /* "generic" interrupt table header (if port doesn't specify one). - * Look suspiciously like 8051 code to me... */ @@ -1174,7 +1327,7 @@ printExterns (FILE * afile) for (sym = setFirstItem (externs); sym; sym = setNextItem (externs)) - tfprintf (afile, "\t!global\n", sym->rname); + tfprintf (afile, "\t!extern\n", sym->rname); } /*-----------------------------------------------------------------*/ @@ -1197,11 +1350,6 @@ emitOverlay (FILE * afile) if (elementsInSet (ovrset)) { - /* this dummy area is used to fool the assembler - otherwise the assembler will append each of these - declarations into one chunk and will not overlay - sad but true */ - fprintf (afile, "\t.area _DUMMY\n"); /* output the area informtion */ fprintf (afile, "\t.area\t%s\n", port->mem.overlay_name); /* MOF */ } @@ -1209,8 +1357,7 @@ emitOverlay (FILE * afile) for (sym = setFirstItem (ovrset); sym; sym = setNextItem (ovrset)) { - - /* if extern then add it to the publics tabledo nothing */ + /* if extern then it is in the publics table: do nothing */ if (IS_EXTERN (sym->etype)) continue; @@ -1226,7 +1373,9 @@ emitOverlay (FILE * afile) and addPublics allowed then add it to the public set */ if ((sym->_isparm && !IS_REGPARM (sym->etype)) && !IS_STATIC (sym->etype)) - addSetHead (&publics, sym); + { + addSetHead (&publics, sym); + } /* if extern then do nothing or is a function then do nothing */ @@ -1264,16 +1413,20 @@ emitOverlay (FILE * afile) sym->rname, SPEC_ADDR (sym->etype)); } - else - { + else { + int size = getSize(sym->type); + + if (size==0) { + werror(E_UNKNOWN_SIZE,sym->name); + } if (options.debug) - fprintf (afile, "==.\n"); + fprintf (afile, "==.\n"); /* allocate space */ tfprintf (afile, "!labeldef\n", sym->rname); tfprintf (afile, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff); - } - + } + } } } @@ -1282,7 +1435,7 @@ emitOverlay (FILE * afile) /* glue - the final glue that hold the whole thing together */ /*-----------------------------------------------------------------*/ void -glue () +glue (void) { FILE *vFile; FILE *asmFile; @@ -1311,14 +1464,15 @@ glue () /* now put it all together into the assembler file */ /* create the assembler file name */ - if (!options.c1mode) + /* -o option overrides default name? */ + if ((noAssemble || options.c1mode) && fullDstFileName) { - sprintf (scratchFileName, srcFileName); - strcat (scratchFileName, port->assembler.file_ext); + strncpyz (scratchFileName, fullDstFileName, PATH_MAX); } else { - strcpy (scratchFileName, options.out_name); + strncpyz (scratchFileName, dstFileName, PATH_MAX); + strncatz (scratchFileName, port->assembler.file_ext, PATH_MAX); } if (!(asmFile = fopen (scratchFileName, "w"))) @@ -1356,6 +1510,26 @@ glue () fprintf (asmFile, "; special function bits \n"); fprintf (asmFile, "%s", iComments2); copyFile (asmFile, sfrbit->oFile); + + /*JCF: Create the areas for the register banks*/ + if(port->general.glue_up_main && + (TARGET_IS_MCS51 || TARGET_IS_DS390 || TARGET_IS_XA51)) + { + if(RegBankUsed[0]||RegBankUsed[1]||RegBankUsed[2]||RegBankUsed[3]) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; overlayable register banks \n"); + fprintf (asmFile, "%s", iComments2); + if(RegBankUsed[0]) + fprintf (asmFile, "\t.area REG_BANK_0\t(REL,OVR,DATA)\n\t.ds 8\n"); + if(RegBankUsed[1]||options.parms_in_bank1) + fprintf (asmFile, "\t.area REG_BANK_1\t(REL,OVR,DATA)\n\t.ds 8\n"); + if(RegBankUsed[2]) + fprintf (asmFile, "\t.area REG_BANK_2\t(REL,OVR,DATA)\n\t.ds 8\n"); + if(RegBankUsed[3]) + fprintf (asmFile, "\t.area REG_BANK_3\t(REL,OVR,DATA)\n\t.ds 8\n"); + } + } /* copy the data segment */ fprintf (asmFile, "%s", iComments2); @@ -1365,13 +1539,15 @@ glue () /* create the overlay segments */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; overlayable items in internal ram \n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, ovrFile); + if (overlay) { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; overlayable items in internal ram \n"); + fprintf (asmFile, "%s", iComments2); + copyFile (asmFile, ovrFile); + } /* create the stack segment MOF */ - if (mainf && mainf->fbody) + if (mainf && IFFUNC_HASBODY(mainf->type)) { fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; Stack segment in internal ram \n"); @@ -1381,10 +1557,12 @@ glue () } /* create the idata segment */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; indirectly addressable internal ram data\n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, idata->oFile); + if (idata) { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; indirectly addressable internal ram data\n"); + fprintf (asmFile, "%s", iComments2); + copyFile (asmFile, idata->oFile); + } /* copy the bit segment */ fprintf (asmFile, "%s", iComments2); @@ -1393,7 +1571,7 @@ glue () copyFile (asmFile, bit->oFile); /* if external stack then reserve space of it */ - if (mainf && mainf->fbody && options.useXstack) + if (mainf && IFFUNC_HASBODY(mainf->type) && options.useXstack) { fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; external stack \n"); @@ -1409,8 +1587,14 @@ glue () fprintf (asmFile, "%s", iComments2); copyFile (asmFile, xdata->oFile); + /* copy xternal initialized ram data */ + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; external initialized ram data\n"); + fprintf (asmFile, "%s", iComments2); + copyFile (asmFile, xidata->oFile); + /* copy the interrupt vector table */ - if (mainf && mainf->fbody) + if (mainf && IFFUNC_HASBODY(mainf->type)) { fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; interrupt vector \n"); @@ -1433,7 +1617,7 @@ glue () tfprintf (asmFile, "\t!area\n", port->mem.post_static_name); tfprintf (asmFile, "\t!area\n", port->mem.static_name); - if (mainf && mainf->fbody) + if (mainf && IFFUNC_HASBODY(mainf->type)) { fprintf (asmFile, "__sdcc_gsinit_startup:\n"); /* if external stack is specified then the @@ -1448,16 +1632,8 @@ glue () (unsigned int) options.xdata_loc & 0xff); } - /* initialise the stack pointer */ - /* if the user specified a value then use it */ - if (options.stack_loc) - fprintf (asmFile, "\tmov\tsp,#%d\n", options.stack_loc); - else - /* no: we have to compute it */ - if (!options.stackOnData && maxRegBank <= 3) - fprintf (asmFile, "\tmov\tsp,#%d\n", ((maxRegBank + 1) * 8) - 1); - else - fprintf (asmFile, "\tmov\tsp,#__start__stack\n"); /* MOF */ + /* initialise the stack pointer. JCF: aslink takes care of the location */ + fprintf (asmFile, "\tmov\tsp,#__start__stack - 1\n"); /* MOF */ fprintf (asmFile, "\tlcall\t__sdcc_external_startup\n"); fprintf (asmFile, "\tmov\ta,dpl\n"); @@ -1465,10 +1641,15 @@ glue () fprintf (asmFile, "\tljmp\t__sdcc_program_startup\n"); fprintf (asmFile, "__sdcc_init_data:\n"); + // if the port can copy the XINIT segment to XISEG + if (port->genXINIT) { + port->genXINIT(asmFile); + } + } copyFile (asmFile, statsg->oFile); - if (port->general.glue_up_main && mainf && mainf->fbody) + if (port->general.glue_up_main && mainf && IFFUNC_HASBODY(mainf->type)) { /* This code is generated in the post-static area. * This area is guaranteed to follow the static area @@ -1490,7 +1671,7 @@ glue () fprintf (asmFile, "; code\n"); fprintf (asmFile, "%s", iComments2); tfprintf (asmFile, "\t!areacode\n", CODE_NAME); - if (mainf && mainf->fbody) + if (mainf && IFFUNC_HASBODY(mainf->type)) { /* entry point @ start of CSEG */ @@ -1514,19 +1695,38 @@ glue () } copyFile (asmFile, code->oFile); + if (port->genAssemblerEnd) { + port->genAssemblerEnd(asmFile); + } fclose (asmFile); - applyToSet (tmpfileSet, closeTmpFiles); - applyToSet (tmpfileNameSet, rmTmpFiles); + + rm_tmpfiles (); } -#if defined (__MINGW32__) || defined (__CYGWIN__) || defined (_MSC_VER) -void -rm_tmpfiles (void) +/** Creates a temporary file name a'la tmpnam which avoids the bugs + in cygwin wrt c:\tmp. + Scans, in order: TMP, TEMP, TMPDIR, else uses tmpfile(). +*/ +char * +tempfilename (void) { - applyToSet (tmpfileSet, closeTmpFiles); - applyToSet (tmpfileNameSet, rmTmpFiles); + const char *tmpdir = NULL; + if (getenv ("TMP")) + tmpdir = getenv ("TMP"); + else if (getenv ("TEMP")) + tmpdir = getenv ("TEMP"); + else if (getenv ("TMPDIR")) + tmpdir = getenv ("TMPDIR"); + if (tmpdir) + { + char *name = tempnam (tmpdir, "sdcc"); + if (name) + { + return name; + } + } + return tmpnam (NULL); } -#endif /** Creates a temporary file a'la tmpfile which avoids the bugs in cygwin wrt c:\tmp. @@ -1535,7 +1735,6 @@ rm_tmpfiles (void) FILE * tempfile (void) { -#if !defined(_MSC_VER) const char *tmpdir = NULL; if (getenv ("TMP")) tmpdir = getenv ("TMP"); @@ -1545,7 +1744,7 @@ tempfile (void) tmpdir = getenv ("TMPDIR"); if (tmpdir) { - char *name = tempnam (tmpdir, "sdcc"); + char *name = Safe_strdup( tempnam (tmpdir, "sdcc")); if (name) { FILE *fp = fopen (name, "w+b"); @@ -1557,15 +1756,5 @@ tempfile (void) } return NULL; } -#endif return tmpfile (); } - -char * -gc_strdup (const char *s) -{ - char *ret; - ret = Safe_calloc (1, strlen (s) + 1); - strcpy (ret, s); - return ret; -}