X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fpic%2Fglue.c;h=a85c11b1695333b561da4318f73113543f269b1d;hb=d04afe0d4051267636aa2afb1d781eaa8d7be511;hp=8ede432fa9a1e107b6366d971eebd355c2410baf;hpb=2ac436263eb41eda4ad7c56f84e2743c121e45b6;p=fw%2Fsdcc diff --git a/src/pic/glue.c b/src/pic/glue.c index 8ede432f..a85c11b1 100644 --- a/src/pic/glue.c +++ b/src/pic/glue.c @@ -27,13 +27,25 @@ #include "ralloc.h" #include "pcode.h" #include "newalloc.h" +#include "gen.h" +#include "main.h" +#include "device.h" +#ifdef WORDS_BIGENDIAN +#define _ENDIAN(x) (3-x) +#else +#define _ENDIAN(x) (x) +#endif + +#define BYTE_IN_LONG(x,b) ((x>>(8*_ENDIAN(b)))&0xff) + extern symbol *interrupts[256]; -void printIval (symbol *, sym_link *, initList *, FILE *); +static void printIval (symbol * sym, sym_link * type, initList * ilist, pBlock *pb); extern int noAlloc; extern set *publics; -extern int maxInterrupts; +extern set *externs; +extern unsigned maxInterrupts; extern int maxRegBank; extern symbol *mainf; extern char *VersionString; @@ -43,742 +55,907 @@ extern set *tmpfileNameSet; extern char *iComments1; extern char *iComments2; //extern void emitStaticSeg (memmap * map); +set *pic14_localFunctions = NULL; extern DEFSETFUNC (closeTmpFiles); extern DEFSETFUNC (rmTmpFiles); +extern void AnalyzeBanking (void); extern void copyFile (FILE * dest, FILE * src); +extern void ReuseReg(void); +extern void InlinepCode(void); +extern void writeUsedRegs(FILE *); - -//extern void emitMaps (); -//extern void createInterruptVect (FILE * vFile); extern void initialComments (FILE * afile); extern void printPublics (FILE * afile); extern void printChar (FILE * ofile, char *s, int plen); +void pCodeInitRegisters(void); +int getConfigWord(int address); +int getHasSecondConfigReg(void); +int pic14_getSharebankSize(void); +int pic14_getSharebankAddress(void); -#if 0 -char * -aopLiteral (value * val, int offset) - static void emitRegularMap (memmap * map, bool addPublics, bool arFlag) - value *initPointer (initList * ilist) - void printIvalType (sym_link * type, initList * ilist, FILE * oFile) - void printIvalStruct (symbol * sym, sym_link * type, - initList * ilist, FILE * oFile) - int printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) - void printIvalArray (symbol * sym, sym_link * type, initList * ilist, - FILE * oFile) - void printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) - int printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) - void printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) -#endif - -/*-----------------------------------------------------------------*/ -/* Allocation macros that replace those in SDCCalloc.h */ -/* Why? I dunno. I ran across a bug with those macros that */ -/* I couldn't fix, but I could work around... */ -/*-----------------------------------------------------------------*/ - -#define _ALLOC(x,sz) if (!(x = calloc((sz),1) )) \ - { \ - werror(E_OUT_OF_MEM,__FILE__,(long) sz);\ - exit (1); \ - } - -#define _ALLOC_ATOMIC(x,y) if (!((x) = malloc(y))) \ - { \ - werror(E_OUT_OF_MEM,__FILE__,(long) y); \ - exit (1); \ - } - +char *udata_section_name=0; // FIXME Temporary fix to change udata section name -- VR +int pic14_hasInterrupt = 0; // Indicates whether to emit interrupt handler or not /*-----------------------------------------------------------------*/ /* aopLiteral - string from a literal value */ /*-----------------------------------------------------------------*/ -int pic14aopLiteral (value *val, int offset) +unsigned int pic14aopLiteral (value *val, int offset) { - union { - float f; - unsigned char c[4]; - } fl; - - /* if it is a float then it gets tricky */ - /* otherwise it is fairly simple */ - if (!IS_FLOAT(val->type)) { - unsigned long v = (unsigned long) floatFromVal(val); - - //v >>= (offset * 8); - return ( (v >> (offset * 8)) & 0xff); - //sprintf(buffer,"0x%02x",((char) v) & 0xff); - //_ALLOC_ATOMIC(rs,strlen(buffer)+1); - //return strcpy (rs,buffer); - } - - /* it is type float */ - fl.f = (float) floatFromVal(val); -#ifdef _BIG_ENDIAN - return fl.c[3-offset]; + union { + float f; + unsigned char c[4]; + } fl; + + /* if it is a float then it gets tricky */ + /* otherwise it is fairly simple */ + if (!IS_FLOAT(val->type)) { + unsigned long v = (unsigned long) floatFromVal(val); + + return ( (v >> (offset * 8)) & 0xff); + } + + /* it is type float */ + fl.f = (float) floatFromVal(val); +#ifdef WORDS_BIGENDIAN + return fl.c[3-offset]; #else - return fl.c[offset]; + return fl.c[offset]; #endif - + } - -/*-----------------------------------------------------------------*/ -/* emitRegularMap - emit code for maps with no special cases */ -/*-----------------------------------------------------------------*/ -static void -pic14emitRegularMap (memmap * map, bool addPublics, bool arFlag) +/* Check whether the given reg is shared amongst all .o files of a project. + * This is true for the pseudo stack and WSAVE, SSAVE and PSAVE. */ +static int +is_shared_address (int addr) { - symbol *sym; - int i, size, bitvars = 0;; - - if (addPublics) - fprintf (map->oFile, ";\t.area\t%s\n", map->sname); - - /* print the area name */ - for (sym = setFirstItem (map->syms); sym; - sym = setNextItem (map->syms)) - { + return ((addr > Gstack_base_addr - 18) + && (addr <= Gstack_base_addr)); +} - /* if extern then do nothing */ - if (IS_EXTERN (sym->etype)) - 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; - - /* 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)) - addSetHead (&publics, sym); - - /* if extern then do nothing or is a function - then do nothing */ - if (IS_FUNC (sym->type)) - continue; -#if 0 - /* print extra debug info if required */ - if (options.debug || sym->level == 0) - { +int +pic14_is_shared (regs *reg) +{ + if (!reg) return 0; + return is_shared_address (reg->address); +} - cdbSymbol (sym, cdbFile, FALSE, FALSE); +static int +is_valid_identifier( const char *name ) +{ + char a; + if (!name) return 0; + a = *name; + + /* only accept [a-zA-Z_][a-zA-Z0-9_] */ + if (!((a >= 'a' && a <= 'z') + || (a >= 'A' && a <= 'z') + || (a == '_'))) + return 0; + + name++; + while ((a = *name++)) + { + if (!((a >= 'a' && a <= 'z') + || (a >= 'A' && a <= 'Z') + || (a >= '0' && a <= '9') + || (a == '_'))) + return 0; + } // while + + /* valid identifier */ + return 1; +} - if (!sym->level) /* global */ - if (IS_STATIC (sym->etype)) - fprintf (map->oFile, "F%s_", moduleName); /* scope is file */ - else - fprintf (map->oFile, "G_"); /* scope is global */ - else - /* symbol is local */ - fprintf (map->oFile, "L%s_", (sym->localof ? sym->localof->name : "-null-")); - fprintf (map->oFile, "%s_%d_%d", sym->name, sym->level, sym->block); - } -#endif +/* set of already emitted symbols; we store only pointers to the emitted + * symbol names so these MUST NO BE CHANGED afterwards... */ +static set *symbolsEmitted = NULL; - /* if is has an absolute address then generate - an equate for this no need to allocate space */ - if (SPEC_ABSA (sym->etype)) +/*-------------------------------------------------------------------*/ +/* emitSymbolToFile - write a symbol definition only if it is not */ +/* already present */ +/*-------------------------------------------------------------------*/ +void +emitSymbolToFile (FILE *of, const char *name, const char *section_type, int size, int addr, int useEQU, int globalize) +{ + const char *sym; + static unsigned int sec_idx = 0; + + /* workaround: variables declared via `sbit' result in a numeric + * identifier (0xHH), EQU'ing them is invalid, so just ignore it. + * sbit is heavily used in the inc2h-generated header files! + */ + if (!is_valid_identifier(name)) { - //if (options.debug || sym->level == 0) - //fprintf (map->oFile,"; == 0x%04x\n",SPEC_ADDR (sym->etype)); - - fprintf (map->oFile, "%s\tEQU\t0x%04x\n", - sym->rname, - SPEC_ADDR (sym->etype)); + //fprintf( stderr, "%s:%s:%u: ignored symbol: %s\n", __FILE__, __FUNCTION__, __LINE__, name ); + return; } - else + + /* check whether the symbol is already defined */ + for (sym = (const char *) setFirstItem (symbolsEmitted); + sym; + sym = (const char *) setNextItem (symbolsEmitted)) { - /* allocate space */ - - /* If this is a bit variable, then allocate storage after 8 bits have been declared */ - /* unlike the 8051, the pic does not have a separate bit area. So we emulate bit ram */ - /* by grouping the bits together into groups of 8 and storing them in the normal ram. */ - if (IS_BITVAR (sym->etype)) - { - if ((bitvars % 8) == 0) + if (!strcmp (sym, name)) { - fprintf (map->oFile, " cblock\n"); - fprintf (map->oFile, "\tbitfield%d\n", bitvars); - fprintf (map->oFile, " endc\n"); + //fprintf (stderr, "%s: already emitted: %s\n", __FUNCTION__, name); + return; } - - fprintf (map->oFile, "%s\tEQU\t( (bitfield%d<<3)+%d)\n", - sym->rname, - bitvars & 0xfff8, - bitvars & 0x0007); - - bitvars++; - } - else + } // for + + /* new symbol -- define it */ + //fprintf (stderr, "%s: emitting %s (%d)\n", __FUNCTION__, name, size); + if (useEQU) + fprintf (of, "%s\tEQU\t0x%04x\n", name, addr); + else + { + /* we place each symbol into a section of its own to allow the linker + * to distribute the data into all available memory banks */ + if (!section_type) section_type = "udata"; + if (addr != -1) + { + /* absolute symbols are handled in pic14_constructAbsMap */ + /* do nothing */ +#if 0 + /* workaround gpasm bug with symbols being EQUated and placed in absolute sections */ + if (1 || !is_shared_address (addr)) { - fprintf (map->oFile, "\t%s\n", sym->rname); - if ((size = (unsigned int) getSize (sym->type) & 0xffff) > 1) - { - for (i = 1; i < size; i++) - fprintf (map->oFile, "\t%s_%d\n", sym->rname, i); - } + if (globalize) fprintf (of, "\tglobal\t%s\n", name); + fprintf (of, "udata_%s_%u\t%s\t0x%04x\n", moduleName, + sec_idx++, "udata_ovr", addr); + fprintf (of, "%s\tres\t%d\n", name, size); } - //fprintf (map->oFile, "\t.ds\t0x%04x\n", (unsigned int)getSize (sym->type) & 0xffff); - } - - /* if it has a initial value then do it only if - it is a global variable */ - if (sym->ival && sym->level == 0) { - ast *ival = NULL; - - 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; - GcurMemmap = statsg; - eBBlockFromiCode (iCodeFromAst (ival)); - sym->ival = NULL; - } - } -} - - -#if 0 -/*-----------------------------------------------------------------*/ -/* initPointer - pointer initialization code massaging */ -/*-----------------------------------------------------------------*/ -value * -initPointer (initList * ilist) -{ - value *val; - ast *expr = list2expr (ilist); - - if (!expr) - goto wrong; - - /* try it the oldway first */ - if ((val = constExprValue (expr, FALSE))) - return val; - - /* no then we have to do these cludgy checks */ - /* pointers can be initialized with address of - a variable or address of an array element */ - if (IS_AST_OP (expr) && expr->opval.op == '&') - { - /* address of symbol */ - if (IS_AST_SYM_VALUE (expr->left)) - { - val = copyValue (AST_VALUE (expr->left)); - val->type = newLink (); - if (SPEC_SCLS (expr->left->etype) == S_CODE) { - DCL_TYPE (val->type) = CPOINTER; - DCL_PTR_CONST (val->type) = port->mem.code_ro; + /* EQUs cannot be exported... */ + fprintf (of, "%s\tEQU\t0x%04x\n", name, addr); } - else if (SPEC_SCLS (expr->left->etype) == S_XDATA) - DCL_TYPE (val->type) = FPOINTER; - else if (SPEC_SCLS (expr->left->etype) == S_XSTACK) - DCL_TYPE (val->type) = PPOINTER; - else if (SPEC_SCLS (expr->left->etype) == S_IDATA) - DCL_TYPE (val->type) = IPOINTER; - else if (SPEC_SCLS (expr->left->etype) == S_EEPROM) - DCL_TYPE (val->type) = EEPPOINTER; - else - DCL_TYPE (val->type) = POINTER; - val->type->next = expr->left->ftype; - val->etype = getSpec (val->type); - return val; - } - - /* if address of indexed array */ - if (IS_AST_OP (expr->left) && expr->left->opval.op == '[') - return valForArray (expr->left); - - /* if address of structure element then - case 1. a.b ; */ - if (IS_AST_OP (expr->left) && - expr->left->opval.op == '.') - { - return valForStructElem (expr->left->left, - expr->left->right); +#endif + } else { + if (globalize) fprintf (of, "\tglobal\t%s\n", name); + fprintf (of, "udata_%s_%u\t%s\n", moduleName, + sec_idx++, section_type); + fprintf (of, "%s\tres\t%d\n", name, size); + } } - /* case 2. (&a)->b ; - (&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); - } - -wrong: - werror (E_INIT_WRONG); - return NULL; - + //if (options.verbose) fprintf (stderr, "%s: emitted %s\n", __FUNCTION__, name); + addSet (&symbolsEmitted, (void *) name); } -/*-----------------------------------------------------------------*/ -/* printChar - formats and prints a characater string with DB */ -/*-----------------------------------------------------------------*/ -void -printChar (FILE * ofile, char *s, int plen) +#define IS_DEFINED_HERE(sym) (!IS_EXTERN(sym->etype)) +extern int IS_CONFIG_ADDRESS( int addr ); +static void +pic14_constructAbsMap (FILE *ofile) { + memmap *maps[] = { data, sfr, NULL }; int i; - int len = strlen (s); - int pplen = 0; - - while (len && pplen < plen) + hTab *ht = NULL; + symbol *sym; + set *aliases; + int addr, min=-1, max=-1; + int size; + + for (i=0; maps[i] != NULL; i++) + { + for (sym = (symbol *)setFirstItem (maps[i]->syms); + sym; sym = setNextItem (maps[i]->syms)) { + if (IS_DEFINED_HERE(sym) && SPEC_ABSA(sym->etype)) + { + addr = SPEC_ADDR(sym->etype); - fprintf (ofile, "\t.ascii /"); - i = 60; - while (i && *s && pplen < plen) + /* handle CONFIG words here */ + if (IS_CONFIG_ADDRESS( addr )) { - if (*s < ' ' || *s == '/') - { - fprintf (ofile, "/\n\t.byte 0x%02x\n\t.ascii /", *s++); - } - else - fprintf (ofile, "%c", *s++); - pplen++; - i--; + //fprintf( stderr, "%s: assignment to CONFIG@0x%x found\n", __FUNCTION__, addr ); + //fprintf( stderr, "ival: %p (0x%x)\n", sym->ival, (int)list2int( sym->ival ) ); + if (sym->ival) { + pic14_assignConfigWordValue( addr, (int)list2int( sym->ival ) ); + } else { + fprintf( stderr, "ERROR: Symbol %s, which is covering a __CONFIG word must be initialized!\n", sym->name ); + } + continue; } - fprintf (ofile, "/\n"); - - if (len > 60) - len -= 60; - else - len = 0; - } - if (pplen < plen) - fprintf (ofile, "\t.byte\t0\n"); + + if (max == -1 || addr > max) max = addr; + if (min == -1 || addr < min) min = addr; + //fprintf (stderr, "%s: sym %s @ 0x%x\n", __FUNCTION__, sym->name, addr); + aliases = hTabItemWithKey (ht, addr); + if (aliases) { + /* May not use addSetHead, as we cannot update the + * list's head in the hastable `ht'. */ + addSet (&aliases, sym); +#if 0 + fprintf( stderr, "%s: now %d aliases for %s @ 0x%x\n", + __FUNCTION__, elementsInSet(aliases), sym->name, addr); +#endif + } else { + addSet (&aliases, sym); + hTabAddItem (&ht, addr, aliases); + } // if + } // if + } // for sym + } // for i + + /* now emit definitions for all absolute symbols */ + fprintf (ofile, "%s", iComments2); + fprintf (ofile, "; absolute symbol definitions\n"); + fprintf (ofile, "%s", iComments2); + for (addr=min; addr <= max; addr++) + { + size = 1; + aliases = hTabItemWithKey (ht, addr); + if (aliases && elementsInSet(aliases)) { + fprintf (ofile, "udata_abs_%s_%x\tudata_ovr\t0x%04x", + moduleName, addr, addr); + for (sym = setFirstItem (aliases); sym; + sym = setNextItem (aliases)) + { + /* emit STATUS as well as _STATUS, required for SFRs only */ + fprintf (ofile, "\n%s", sym->name); + fprintf (ofile, "\n%s", sym->rname); + if (getSize(sym->type) > size) { + size = getSize(sym->type); + } + addSet (&symbolsEmitted, (void *) sym->name); + addSet (&symbolsEmitted, (void *) sym->rname); + } // for + fprintf (ofile, "\tres\t%d\n", size); + } // if + } // for i + + /* also emit STK symbols + * XXX: This is ugly and fails as soon as devices start to get + * differently sized sharebanks, since STK12 will be + * required by larger devices but only up to STK03 might + * be defined using smaller devices. */ + fprintf (ofile, "\n"); + if (!pic14_options.isLibrarySource) + { + fprintf (ofile, "\tglobal PSAVE\n"); + fprintf (ofile, "\tglobal SSAVE\n"); + fprintf (ofile, "\tglobal WSAVE\n"); + for (i=pic14_getSharebankSize()-4; i >= 0; i--) { + fprintf (ofile, "\tglobal STK%02d\n", i); + } // for i + fprintf (ofile, "sharebank udata_ovr 0x%04x\n", + pic14_getSharebankAddress() - pic14_getSharebankSize() + 1); + fprintf (ofile, "PSAVE\tres 1\n"); + fprintf (ofile, "SSAVE\tres 1\n"); + fprintf (ofile, "WSAVE\tres 1\n"); + /* fill rest of sharebank with stack STKxx .. STK00 */ + for (i=pic14_getSharebankSize()-4; i >= 0; i--) { + fprintf (ofile, "STK%02d\tres 1\n", i); + } // for i + } else { + /* declare STKxx as extern for all files + * except the one containing main() */ + fprintf (ofile, "\textern PSAVE\n"); + fprintf (ofile, "\textern SSAVE\n"); + fprintf (ofile, "\textern WSAVE\n"); + for (i=pic14_getSharebankSize()-4; i >= 0; i--) { + fprintf (ofile, "\textern STK%02d\n", i); + } // for i + } } /*-----------------------------------------------------------------*/ -/* printIvalType - generates ival for int/char */ +/* emitRegularMap - emit code for maps with no special cases */ /*-----------------------------------------------------------------*/ -void -printIvalType (sym_link * type, initList * ilist, FILE * oFile) +static void +pic14emitRegularMap (memmap * map, bool addPublics, bool arFlag) { - value *val; - - /* if initList is deep */ - if (ilist->type == INIT_DEEP) - ilist = ilist->init.deep; - - val = list2val (ilist); - switch (getSize (type)) - { - case 1: - if (!val) - fprintf (oFile, "\t.byte 0\n"); - else - fprintf (oFile, "\t.byte %s\n", - aopLiteral (val, 0)); - break; - - case 2: - if (!val) - fprintf (oFile, "\t.word 0\n"); - else - fprintf (oFile, "\t.byte %s,%s\n", - aopLiteral (val, 0), aopLiteral (val, 1)); - break; - - case 4: - if (!val) - fprintf (oFile, "\t.word 0,0\n"); - else - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", - aopLiteral (val, 0), aopLiteral (val, 1), - aopLiteral (val, 2), aopLiteral (val, 3)); - break; - } - - return; + symbol *sym; + int bitvars = 0;; + + /* print the area name */ + if (addPublics) + fprintf (map->oFile, ";\t.area\t%s\n", map->sname); + + for (sym = setFirstItem (map->syms); sym; + sym = setNextItem (map->syms)) { + + //printf("%s\n",sym->name); + + /* ignore if config word */ + if (SPEC_ABSA(sym->etype) + && IS_CONFIG_ADDRESS(SPEC_ADDR(sym->etype))) + continue; + + /* if extern then add it into the extern list */ + if (IS_EXTERN (sym->etype)) { + 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; + + /* 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)) + { + //fprintf( stderr, "%s: made public %s\n", __FUNCTION__, sym->name ); + addSetHead (&publics, sym); + } + + // PIC code allocates its own registers - so ignore parameter variable generated by processFuncArgs() + if (sym->_isparm) + continue; + /* if extern then do nothing or is a function + then do nothing */ + if (IS_FUNC (sym->type)) + continue; +#if 0 + /* print extra debug info if required */ + if (options.debug || sym->level == 0) + { + if (!sym->level) /* global */ + if (IS_STATIC (sym->etype)) + fprintf (map->oFile, "F%s_", moduleName); /* scope is file */ + else + fprintf (map->oFile, "G_"); /* scope is global */ + else + /* symbol is local */ + fprintf (map->oFile, "L%s_", (sym->localof ? sym->localof->name : "-null-")); + fprintf (map->oFile, "%s_%d_%d", sym->name, sym->level, sym->block); + } +#endif + /* absolute symbols are handled in pic14_constructAbsMap */ + if (SPEC_ABSA(sym->etype) && IS_DEFINED_HERE(sym)) + continue; + + /* if it has an absolute address then generate + an equate for this no need to allocate space */ + if (0 && SPEC_ABSA (sym->etype)) + { + //if (options.debug || sym->level == 0) + //fprintf (map->oFile,"; == 0x%04x\n",SPEC_ADDR (sym->etype)); + + fprintf (map->oFile, "%s\tEQU\t0x%04x\n", + sym->rname, + SPEC_ADDR (sym->etype)); + } + else + { + /* allocate space */ + + /* If this is a bit variable, then allocate storage after 8 bits have been declared */ + /* unlike the 8051, the pic does not have a separate bit area. So we emulate bit ram */ + /* by grouping the bits together into groups of 8 and storing them in the normal ram. */ + if (IS_BITVAR (sym->etype)) + { + bitvars++; + } + else + { + emitSymbolToFile (map->oFile, + sym->rname, + NULL, + getSize (sym->type) & 0xffff, + SPEC_ABSA(sym->etype) + ? SPEC_ADDR(sym->etype) + : -1, + 0, + 0); + /* + { + int i, size; + + if ((size = (unsigned int) getSize (sym->type) & 0xffff) > 1) + { + for (i = 1; i < size; i++) + fprintf (map->oFile, "\t%s_%d\n", sym->rname, i); + } + } + */ + } + //fprintf (map->oFile, "\t.ds\t0x%04x\n", (unsigned int)getSize (sym->type) & 0xffff); + } + + /* if it has a initial value then do it only if + it is a global variable */ + if (sym->ival && sym->level == 0) { + ast *ival = NULL; + + if (IS_AGGREGATE (sym->type)) + ival = initAggregates (sym, sym->ival, NULL); + else + ival = newNode ('=', newAst_VALUE(symbolVal (sym)), + decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_TYPE_NONE)); + codeOutFile = statsg->oFile; + GcurMemmap = statsg; + eBBlockFromiCode (iCodeFromAst (ival)); + sym->ival = NULL; + } + } } + /*-----------------------------------------------------------------*/ -/* printIvalStruct - generates initial value for structures */ +/* printIvalType - generates ival for int/char */ /*-----------------------------------------------------------------*/ -void -printIvalStruct (symbol * sym, sym_link * type, - initList * ilist, FILE * oFile) +static void +printIvalType (symbol *sym, sym_link * type, initList * ilist, pBlock *pb) { - symbol *sflds; - initList *iloop; - - sflds = SPEC_STRUCT (type)->fields; - if (ilist->type != INIT_DEEP) - { - werror (E_INIT_STRUCT, sym->name); - return; - } - - iloop = ilist->init.deep; - - for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL)) - printIval (sflds, sflds->type, iloop, oFile); - - return; + value *val; + unsigned long ulval; + + //fprintf(stderr, "%s\n",__FUNCTION__); + + /* if initList is deep */ + if (ilist->type == INIT_DEEP) + ilist = ilist->init.deep; + + 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)); + } + + if(val) + ulval = (unsigned long) floatFromVal (val); + else + ulval =0; + + switch (getSize (type)) { + case 1: + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0)))); + break; + + case 2: + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0)))); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,1)))); + break; + + case 4: + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0)))); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,1)))); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,2)))); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,3)))); + break; + } } /*-----------------------------------------------------------------*/ -/* printIvalChar - generates initital value for character array */ +/* printIvalBitFields - generate initializer for bitfields */ /*-----------------------------------------------------------------*/ -int -printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) +static void printIvalBitFields(symbol **sym, initList **ilist, pBlock *pb ) { - value *val; - int remain; - - if (!s) - { - - val = list2val (ilist); - /* if the value is a character string */ - if (IS_ARRAY (val->type) && IS_CHAR (val->etype)) - { - if (!DCL_ELEM (type)) - DCL_ELEM (type) = strlen (SPEC_CVAL (val->etype).v_char) + 1; - - /* if size mismatch */ -/* if (DCL_ELEM (type) < ((int) strlen (SPEC_CVAL (val->etype).v_char) + 1)) */ -/* werror (E_ARRAY_BOUND); */ - - printChar (oFile, SPEC_CVAL (val->etype).v_char, DCL_ELEM (type)); - - if ((remain = (DCL_ELEM (type) - strlen (SPEC_CVAL (val->etype).v_char) - 1)) > 0) - while (remain--) - fprintf (oFile, "\t.byte 0\n"); - - return 1; + value *val ; + symbol *lsym = *sym; + initList *lilist = *ilist ; + unsigned long ival = 0; + int size =0; + + + do { + unsigned long i; + val = list2val(lilist); + if (size) { + if (SPEC_BLEN(lsym->etype) > 8) { + size += ((SPEC_BLEN (lsym->etype) / 8) + + (SPEC_BLEN (lsym->etype) % 8 ? 1 : 0)); + } + } else { + size = ((SPEC_BLEN (lsym->etype) / 8) + + (SPEC_BLEN (lsym->etype) % 8 ? 1 : 0)); + } + i = (unsigned long)floatFromVal(val); + i <<= SPEC_BSTR (lsym->etype); + ival |= i; + if (! ( lsym->next && + (IS_BITFIELD(lsym->next->type)) && + (SPEC_BSTR(lsym->next->etype)))) break; + lsym = lsym->next; + lilist = lilist->next; + } while (1); + switch (size) { + case 1: + //tfprintf (oFile, "\t!db !constbyte\n",ival); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(ival))); + break; + + case 2: + //tfprintf (oFile, "\t!dw !constword\n",ival); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(ival>>8))); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(ival))); + break; + case 4: + //tfprintf (oFile, "\t!db !constword,!constword\n",(ival >> 8) & 0xffff, (ival & 0xffff)); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(ival>>24))); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(ival>>16))); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(ival>>8))); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(ival))); + break; } - else - return 0; - } - else - printChar (oFile, s, strlen (s) + 1); - return 1; + *sym = lsym; + *ilist = lilist; } /*-----------------------------------------------------------------*/ -/* printIvalArray - generates code for array initialization */ +/* printIvalStruct - generates initial value for structures */ /*-----------------------------------------------------------------*/ -void -printIvalArray (symbol * sym, sym_link * type, initList * ilist, - FILE * oFile) +static void printIvalStruct (symbol * sym, sym_link * type, initList * ilist, pBlock *pb) { - initList *iloop; - int lcnt = 0, size = 0; - - /* take care of the special case */ - /* array of characters can be init */ - /* by a string */ - if (IS_CHAR (type->next)) - 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) - { - werror (E_INIT_STRUCT, sym->name); - return; - } - - iloop = ilist->init.deep; - lcnt = DCL_ELEM (type); - - for (;;) - { - size++; - printIval (sym, type->next, iloop, oFile); - iloop = (iloop ? iloop->next : NULL); - - - /* if not array limits given & we */ - /* are out of initialisers then */ - if (!DCL_ELEM (type) && !iloop) - break; - - /* no of elements given and we */ - /* have generated for all of them */ - if (!--lcnt) - break; - } - - /* if we have not been given a size */ - if (!DCL_ELEM (type)) - DCL_ELEM (type) = size; - - return; + symbol *sflds; + initList *iloop = NULL; + + sflds = SPEC_STRUCT (type)->fields; + + if (ilist) { + if (ilist->type != INIT_DEEP) { + werrorfl (sym->fileDef, sym->lineDef, E_INIT_STRUCT, sym->name); + return; + } + + iloop = ilist->init.deep; + } + + for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL)) { + if (IS_BITFIELD(sflds->type)) { + printIvalBitFields(&sflds,&iloop,pb); + } else { + printIval (sym, sflds->type, iloop, pb); + } + } + if (iloop) { + werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "struct", sym->name); + } + return; } /*-----------------------------------------------------------------*/ -/* printIvalFuncPtr - generate initial value for function pointers */ +/* printIvalChar - generates initital value for character array */ /*-----------------------------------------------------------------*/ -void -printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) +static int +printIvalChar (sym_link * type, initList * ilist, pBlock *pb, char *s) { - value *val; - int dLvl = 0; - - val = list2val (ilist); - /* check the types */ - if ((dLvl = checkType (val->type, type->next)) <= 0) - { - - fprintf (oFile, "\t.word 0\n"); - return; - } - - /* now generate the name */ - if (!val->sym) - { - if (IS_LITERAL (val->etype)) - fprintf (oFile, "\t.byte %s,%s\n", - aopLiteral (val, 0), aopLiteral (val, 1)); - else - fprintf (oFile, "\t.byte %s,(%s >> 8)\n", - val->name, val->name); - } - else - fprintf (oFile, "\t.byte %s,(%s >> 8)\n", - val->sym->rname, val->sym->rname); + value *val; + int remain, ilen; + + if(!pb) + return 0; + + //fprintf(stderr, "%s\n",__FUNCTION__); + if (!s) + { + + val = list2val (ilist); - return; + /* if the value is a character string */ + if (IS_ARRAY (val->type) && IS_CHAR (val->etype)) + { + ilen = DCL_ELEM(val->type); + + if (!DCL_ELEM (type)) + DCL_ELEM (type) = ilen; + + /* emit string constant */ + for (remain = 0; remain < ilen; remain++) { + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(SPEC_CVAL(val->etype).v_char[remain]))); + } + + /* fill array up to desired size */ + if ((remain = (DCL_ELEM (type) - ilen)) > 0) + while (remain--) + //tfprintf (oFile, "\t!db !constbyte\n", 0); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(0))); + return 1; + } + else + return 0; + } + else { + //printChar (oFile, s, strlen (s) + 1); + + for(remain=0; remain<(int)strlen(s); remain++) { + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(s[remain]))); + //fprintf(stderr,"0x%02x ",s[remain]); + } + //fprintf(stderr,"\n"); + } + return 1; } /*-----------------------------------------------------------------*/ -/* printIvalCharPtr - generates initial values for character pointers */ +/* printIvalArray - generates code for array initialization */ /*-----------------------------------------------------------------*/ -int -printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) +static void +printIvalArray (symbol * sym, sym_link * type, initList * ilist, + pBlock *pb) { - int size = 0; - - size = getSize (type); - - if (size == 1) - fprintf (oFile, - "\t.byte %s", val->name); - else - fprintf (oFile, - "\t.byte %s,(%s >> 8)", - val->name, val->name); + initList *iloop; + unsigned size = 0; + + if(!pb) + return; + if (ilist) { + /* take care of the special case */ + /* array of characters can be init */ + /* by a string */ + if (IS_CHAR (type->next)) { + //fprintf(stderr,"%s:%d - is_char\n",__FUNCTION__,__LINE__); + if (!IS_LITERAL(list2val(ilist)->etype)) { + werror (W_INIT_WRONG); + return; + } + if (printIvalChar (type, + (ilist->type == INIT_DEEP ? ilist->init.deep : ilist), + pb, SPEC_CVAL (sym->etype).v_char)) + return; + } + /* not the special case */ + if (ilist->type != INIT_DEEP) { + werrorfl (ilist->filename, ilist->lineno, E_INIT_STRUCT, sym->name); + return; + } - if (size > 2) - fprintf (oFile, ",#0x02\n"); - else - fprintf (oFile, "\n"); + for (iloop=ilist->init.deep; iloop; iloop=iloop->next) { + if ((++size > DCL_ELEM(type)) && DCL_ELEM(type)) { + werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "array", sym->name); + break; + } + printIval (sym, type->next, iloop, pb); + } + } - if (val->sym && val->sym->isstrlit) - addSet (&statsg->syms, val->sym); + if (DCL_ELEM(type)) { + // pad with zeros if needed + if (sizenext); + while (size--) { + //tfprintf (oFile, "\t!db !constbyte\n", 0); + addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(0))); + } + } + } else { + // we have not been given a size, but we now know it + DCL_ELEM (type) = size; + } - return 1; + return; } /*-----------------------------------------------------------------*/ -/* printIvalPtr - generates initial value for pointers */ +/* printIvalPtr - generates code for initial value of pointers */ /*-----------------------------------------------------------------*/ -void -printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) -{ - value *val; +extern value *initPointer (initList *, sym_link *toType); - /* if deep then */ - if (ilist->type == INIT_DEEP) - ilist = ilist->init.deep; - - /* function pointer */ - if (IS_FUNC (type->next)) - { - printIvalFuncPtr (type, ilist, oFile); - return; - } +static void +printIvalPtr (symbol * sym, sym_link * type, initList * ilist, pBlock *pb) +{ + value *val; + + if (!ilist || !pb) + return; + + fprintf (stderr, "FIXME: initializers for pointers...\n"); + printTypeChain (type, stderr); + + fprintf (stderr, "symbol: %s, DCL_TYPE():%d, DCL_ELEM():%d, IS_ARRAY():%d", sym->rname, DCL_TYPE(type), DCL_ELEM(type), IS_ARRAY(type)); + fprintf (stderr, "ilist: type=%d (INIT_DEEP=%d, INIT_NODE=%d)\n", ilist->type, INIT_DEEP, INIT_NODE); - if (!(val = initPointer (ilist))) - return; + if (ilist && (ilist->type == INIT_DEEP)) + ilist = ilist->init.deep; + + /* function pointers */ + if (IS_FUNC (type->next)) + { + assert ( !"function pointers not yet handled" ); + //printIvalFuncPtr (type, ilist, pb); + } - /* if character pointer */ - if (IS_CHAR (type->next)) - if (printIvalCharPtr (sym, type, val, oFile)) - return; + if (!(val = initPointer (ilist, type))) + return; + + if (IS_CHAR (type->next)) + { + if (printIvalChar (type, ilist, pb, NULL)) return; + } - /* check the type */ - if (checkType (type, val->type) != 1) - werror (E_INIT_WRONG); + /* check the type */ + if (compareType (type, val->type) == 0) + { + werrorfl (ilist->filename, ilist->lineno, W_INIT_WRONG); + printFromToType (val->type, type); + } - /* if val is literal */ - if (IS_LITERAL (val->etype)) - { - switch (getSize (type)) + if (IS_LITERAL (val->etype)) + { + switch (getSize (type)) + { + case 1: + fprintf (stderr, "BYTE: %i\n", (unsigned char)floatFromVal (val) & 0x00FF); + break; + case 2: + fprintf (stderr, "WORD: %i\n", (unsigned int)floatFromVal (val) & 0x00FFFF); + break; + case 3: /* gneric pointers */ + assert ( !"generic pointers not yet handled" ); + case 4: + fprintf (stderr, "LONG: %i\n", (unsigned int)floatFromVal (val) & 0x0000FFFFFFFF); + break; + default: + assert ( !"invaild size of value -- aborting" ); + } // switch + + return; + } // if (IS_LITERAL) + + /* now handle symbolic values */ + switch (getSize (type)) { case 1: - fprintf (oFile, "\t.byte 0x%02x\n", ((char) floatFromVal (val)) & 0xff); - break; + fprintf (stderr, "BYTE: %s", val->name); + break; case 2: - fprintf (oFile, "\t.byte %s,%s\n", - aopLiteral (val, 0), aopLiteral (val, 1)); - - break; - case 3: - fprintf (oFile, "\t.byte %s,%s,0x%02x\n", - aopLiteral (val, 0), aopLiteral (val, 1), CPOINTER); - } - return; - } - - - switch (getSize (type)) - { - case 1: - fprintf (oFile, "\t.byte %s\n", val->name); - break; - case 2: - fprintf (oFile, "\t.byte %s,(%s >> 8)\n", val->name, val->name); - break; - - case 3: - fprintf (oFile, "\t.byte %s,(%s >> 8),0x%02x\n", - val->name, val->name, DCL_TYPE (val->type)); - } - return; + fprintf (stderr, "WORD: %s", val->name); + break; + case 4: + fprintf (stderr, "LONG: %s", val->name); + break; + default: + assert ( !"invalid size of (symbolic) value -- aborting" ); + } // switch } /*-----------------------------------------------------------------*/ /* printIval - generates code for initial value */ /*-----------------------------------------------------------------*/ -void -printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) +static void +printIval (symbol * sym, sym_link * type, initList * ilist, pBlock *pb) { - if (!ilist) - return; - - /* if structure then */ - if (IS_STRUCT (type)) - { - printIvalStruct (sym, type, ilist, oFile); - return; - } - - /* if this is a pointer */ - if (IS_PTR (type)) - { - printIvalPtr (sym, type, ilist, oFile); - return; - } - - /* if this is an array */ - if (IS_ARRAY (type)) - { - printIvalArray (sym, type, ilist, oFile); - return; - } - - /* if type is SPECIFIER */ - if (IS_SPEC (type)) - { - printIvalType (type, ilist, oFile); - return; - } + if (!ilist || !pb) + return; + + /* if structure then */ + if (IS_STRUCT (type)) + { + //fprintf(stderr,"%s struct: %s\n",__FUNCTION__, sym->rname); + printIvalStruct (sym, type, ilist, pb); + return; + } + + /* if this is an array */ + if (IS_ARRAY (type)) + { + //fprintf(stderr,"%s array: %s\n",__FUNCTION__, sym->rname); + printIvalArray (sym, type, ilist, pb); + return; + } + + /* if this is a pointer */ + if (IS_PTR (type)) + { + //fprintf(stderr,"%s pointer: %s\n",__FUNCTION__, sym->rname); + printIvalPtr (sym, type, ilist, pb); + return; + } + + /* if type is SPECIFIER */ + if (IS_SPEC (type)) + { + //fprintf(stderr,"%s spec %s\n",__FUNCTION__, sym->rname); + printIvalType (sym, type, ilist, pb); + return; + } } -#endif +extern void pCodeConstString(char *name, char *value); /*-----------------------------------------------------------------*/ /* emitStaticSeg - emitcode for the static segment */ /*-----------------------------------------------------------------*/ static void pic14emitStaticSeg (memmap * map) { - symbol *sym; - - fprintf (map->oFile, ";\t.area\t%s\n", map->sname); - - - /* for all variables in this segment do */ - for (sym = setFirstItem (map->syms); sym; - sym = setNextItem (map->syms)) - { - - /* if it is "extern" then do nothing */ - if (IS_EXTERN (sym->etype)) - continue; - - /* if it is not static add it to the public - table */ - if (!IS_STATIC (sym->etype)) - addSetHead (&publics, sym); - - /* print extra debug info if required */ - if (options.debug || sym->level == 0) - { - - cdbSymbol (sym, cdbFile, FALSE, FALSE); - - if (!sym->level) - { /* global */ - if (IS_STATIC (sym->etype)) - fprintf (code->oFile, "F%s_", moduleName); /* scope is file */ - else - fprintf (code->oFile, "G_"); /* scope is global */ - } - else - /* symbol is local */ - fprintf (code->oFile, "L%s_", - (sym->localof ? sym->localof->name : "-null-")); - fprintf (code->oFile, "%s_%d_%d", sym->name, sym->level, sym->block); - } - - /* if it has an absolute address */ - if (SPEC_ABSA (sym->etype)) - { - if (options.debug || sym->level == 0) - fprintf (code->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); - - fprintf (code->oFile, "%s\t=\t0x%04x\n", - sym->rname, - SPEC_ADDR (sym->etype)); - } - else + symbol *sym; + + fprintf (map->oFile, ";\t.area\t%s\n", map->sname); + + //fprintf(stderr, "%s\n",__FUNCTION__); + + /* for all variables in this segment do */ + for (sym = setFirstItem (map->syms); sym; + sym = setNextItem (map->syms)) { - if (options.debug || sym->level == 0) - fprintf (code->oFile, " == .\n"); - - /* if it has an initial value */ - if (sym->ival) - { - fprintf (code->oFile, "%s:\n", sym->rname); - noAlloc++; - resolveIvalSym (sym->ival); - printIval (sym, sym->type, sym->ival, code->oFile); - noAlloc--; - } - else - { - /* allocate space */ - fprintf (code->oFile, "%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 (code->oFile, - SPEC_CVAL (sym->etype).v_char, - strlen (SPEC_CVAL (sym->etype).v_char) + 1); - else - fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff); - } + /* if extern then add it into the extern list */ + if (IS_EXTERN (sym->etype)) { + addSetHead (&externs, sym); + continue; + } + + /* if it is not static add it to the public + table */ + if (!IS_STATIC (sym->etype)) + addSetHead (&publics, sym); + + /* print extra debug info if required */ + if (options.debug || sym->level == 0) + { + if (!sym->level) + { /* global */ + if (IS_STATIC (sym->etype)) + fprintf (code->oFile, "F%s_", moduleName); /* scope is file */ + else + fprintf (code->oFile, "G_"); /* scope is global */ + } + else + /* symbol is local */ + fprintf (code->oFile, "L%s_", + (sym->localof ? sym->localof->name : "-null-")); + fprintf (code->oFile, "%s_%d_%d", sym->name, sym->level, sym->block); + + } + + /* if it has an absolute address */ + if (SPEC_ABSA (sym->etype)) + { + if (options.debug || sym->level == 0) + fprintf (code->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); + + fprintf (code->oFile, "%s\t=\t0x%04x\n", + sym->rname, + SPEC_ADDR (sym->etype)); + } + else + { + if (options.debug || sym->level == 0) + fprintf (code->oFile, " == .\n"); + + /* if it has an initial value */ + if (sym->ival) + { + pBlock *pb; + + fprintf (code->oFile, "%s:\n", sym->rname); + noAlloc++; + resolveIvalSym (sym->ival, sym->type); + //printIval (sym, sym->type, sym->ival, code->oFile); + pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block for Ival")); + addpBlock(pb); + addpCode2pBlock(pb,newpCodeLabel(sym->rname,-1)); + + printIval (sym, sym->type, sym->ival, pb); + noAlloc--; + } + else + { + + /* allocate space */ + fprintf (code->oFile, "%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) + pCodeConstString(sym->rname , SPEC_CVAL (sym->etype).v_char); + /*printChar (code->oFile, + SPEC_CVAL (sym->etype).v_char, + strlen (SPEC_CVAL (sym->etype).v_char) + 1);*/ + else + fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff); + } + } } - } + } @@ -788,16 +965,18 @@ pic14emitStaticSeg (memmap * map) static void pic14emitMaps () { - /* no special considerations for the following - data, idata & bit & xdata */ - pic14emitRegularMap (data, TRUE, TRUE); - pic14emitRegularMap (idata, TRUE, TRUE); - pic14emitRegularMap (bit, TRUE, FALSE); - pic14emitRegularMap (xdata, TRUE, TRUE); - pic14emitRegularMap (sfr, FALSE, FALSE); - pic14emitRegularMap (sfrbit, FALSE, FALSE); - pic14emitRegularMap (code, TRUE, FALSE); - pic14emitStaticSeg (statsg); + pic14_constructAbsMap (sfr->oFile); +/* no special considerations for the following + data, idata & bit & xdata */ + pic14emitRegularMap (data, TRUE, TRUE); + pic14emitRegularMap (idata, TRUE, TRUE); + pic14emitRegularMap (bit, TRUE, FALSE); + pic14emitRegularMap (xdata, TRUE, TRUE); + pic14emitRegularMap (sfr, TRUE, FALSE); + pic14emitRegularMap (sfrbit, FALSE, FALSE); + pic14emitRegularMap (code, TRUE, FALSE); + pic14emitStaticSeg (statsg); + pic14emitStaticSeg (c_abs); } /*-----------------------------------------------------------------*/ @@ -806,63 +985,100 @@ pic14emitMaps () static void pic14createInterruptVect (FILE * vFile) { - int i = 0; - mainf = newSymbol ("main", 0); - mainf->block = 0; - - /* only if the main function exists */ - if (!(mainf = findSymWithLevel (SymbolTab, mainf))) - { - if (!options.cc_only) - werror (E_NO_MAIN); - return; - } - - /* if the main is only a prototype ie. no body then do nothing */ - if (!mainf->fbody) - { - /* if ! compile only then main function should be present */ - if (!options.cc_only) - werror (E_NO_MAIN); - return; - } + mainf = newSymbol ("main", 0); + mainf->block = 0; + + /* only if the main function exists */ + if (!(mainf = findSymWithLevel (SymbolTab, mainf))) + { + struct options *op = &options; + if (!(op->cc_only || noAssemble)) + // werror (E_NO_MAIN); + fprintf(stderr,"WARNING: function 'main' undefined\n"); + return; + } + + /* if the main is only a prototype ie. no body then do nothing */ + if (!IFFUNC_HASBODY(mainf->type)) + { + /* if ! compile only then main function should be present */ + if (!(options.cc_only || noAssemble)) + // werror (E_NO_MAIN); + fprintf(stderr,"WARNING: function 'main' undefined\n"); + return; + } + + fprintf (vFile, "%s", iComments2); + fprintf (vFile, "; reset vector \n"); + fprintf (vFile, "%s", iComments2); + fprintf (vFile, "STARTUP\t%s\n", CODE_NAME); // Lkr file should place section STARTUP at address 0x0 + fprintf (vFile, "\tnop\n"); /* first location for used by incircuit debugger */ + fprintf( vFile, "\tpagesel __sdcc_gsinit_startup\n"); + fprintf (vFile, "\tgoto\t__sdcc_gsinit_startup\n"); +} - fprintf (vFile, ";\t.area\t%s\n", CODE_NAME); - fprintf (vFile, ";__interrupt_vect:\n"); +/*-----------------------------------------------------------------*/ +/* initialComments - puts in some initial comments */ +/*-----------------------------------------------------------------*/ +static void +pic14initialComments (FILE * afile) +{ + initialComments (afile); + fprintf (afile, "; PIC port for the 14-bit core\n"); + fprintf (afile, iComments2); + +} - if (!port->genIVT || !(port->genIVT (vFile, interrupts, maxInterrupts))) - { - /* "generic" interrupt table header (if port doesn't specify one). +int +pic14_stringInSet(const char *str, set **world, int autoAdd) +{ + char *s; - * Look suspiciously like 8051 code to me... - */ + if (!str) return 1; + assert(world); - fprintf (vFile, ";\tljmp\t__sdcc_gsinit_startup\n"); + for (s = setFirstItem(*world); s; s = setNextItem(*world)) + { + /* found in set */ + if (0 == strcmp(s, str)) return 1; + } + /* not found */ + if (autoAdd) addSet(world, Safe_strdup(str)); + return 0; +} - /* now for the other interrupts */ - for (; i < maxInterrupts; i++) - { - if (interrupts[i]) - fprintf (vFile, ";\tljmp\t%s\n\t.ds\t5\n", interrupts[i]->rname); - else - fprintf (vFile, ";\treti\n;\t.ds\t7\n"); - } +static int +pic14_emitSymbolIfNew(FILE *file, const char *fmt, const char *sym, int checkLocals) +{ + static set *emitted = NULL; + + if (!pic14_stringInSet(sym, &emitted, 1)) { + /* sym was not in emittedSymbols */ + if (!checkLocals || !pic14_stringInSet(sym, &pic14_localFunctions, 0)) { + /* sym is not a locally defined function---avoid bug #1443651 */ + fprintf( file, fmt, sym ); + return 0; } + } + return 1; } - /*-----------------------------------------------------------------*/ -/* initialComments - puts in some initial comments */ +/* printExterns - generates extern for external variables */ /*-----------------------------------------------------------------*/ static void -pic14initialComments (FILE * afile) +pic14printExterns (FILE * afile) { - initialComments (afile); - fprintf (afile, "; PIC port for the 14-bit core\n"); - fprintf (afile, iComments2); - + symbol *sym; + + fprintf (afile, "%s", iComments2); + fprintf (afile, "; extern variables in this module\n"); + fprintf (afile, "%s", iComments2); + + for (sym = setFirstItem (externs); sym; sym = setNextItem (externs)) + pic14_emitSymbolIfNew(afile, "\textern %s\n", sym->rname, 1); } /*-----------------------------------------------------------------*/ @@ -878,11 +1094,19 @@ pic14printPublics (FILE * afile) fprintf (afile, "%s", iComments2); for (sym = setFirstItem (publics); sym; - sym = setNextItem (publics)) - fprintf (afile, ";\t.globl %s\n", sym->rname); -} - + sym = setNextItem (publics)) { + if(!IS_BITFIELD(sym->type) && ((IS_FUNC(sym->type) || sym->allocreq))) { + if (!IS_BITVAR(sym->type)) + pic14_emitSymbolIfNew(afile, "\tglobal %s\n", sym->rname, 0); + } else { + /* Absolute variables are defines in the asm file as equates and thus can not be made global. */ + /* Not any longer! */ + //if (!SPEC_ABSA (sym->etype)) + pic14_emitSymbolIfNew(afile, "\tglobal %s\n", sym->rname, 0); + } + } +} /*-----------------------------------------------------------------*/ /* emitOverlay - will emit code for the overlay stuff */ @@ -890,103 +1114,127 @@ pic14printPublics (FILE * afile) static void pic14emitOverlay (FILE * afile) { - set *ovrset; - - if (!elementsInSet (ovrSetSets)) - fprintf (afile, ";\t.area\t%s\n", port->mem.overlay_name); - - /* for each of the sets in the overlay segment do */ - for (ovrset = setFirstItem (ovrSetSets); ovrset; - ovrset = setNextItem (ovrSetSets)) - { - - symbol *sym; - - 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 */ - } - - for (sym = setFirstItem (ovrset); sym; - sym = setNextItem (ovrset)) + set *ovrset; + + /* if (!elementsInSet (ovrSetSets))*/ + + /* the hack below, fixes translates for devices which + * only have udata_shr memory */ + fprintf (afile, "%s\t%s\n", + (elementsInSet(ovrSetSets)?"":";"), + port->mem.overlay_name); + + /* for each of the sets in the overlay segment do */ + for (ovrset = setFirstItem (ovrSetSets); ovrset; + ovrset = setNextItem (ovrSetSets)) { - - /* if extern then do nothing */ - if (IS_EXTERN (sym->etype)) - continue; - - /* if allocation required check is needed - then check if the symbol really requires - allocation only for local variables */ - if (!IS_AGGREGATE (sym->type) && - !(sym->_isparm && !IS_REGPARM (sym->etype)) - && !sym->allocreq && sym->level) - continue; - - /* if global variable & not static or extern - and addPublics allowed then add it to the public set */ - if ((sym->_isparm && !IS_REGPARM (sym->etype)) - && !IS_STATIC (sym->etype)) - addSetHead (&publics, sym); - - /* if extern then do nothing or is a function - then do nothing */ - if (IS_FUNC (sym->type)) - continue; - - /* print extra debug info if required */ - if (options.debug || sym->level == 0) - { - - cdbSymbol (sym, cdbFile, FALSE, FALSE); - - if (!sym->level) - { /* global */ - if (IS_STATIC (sym->etype)) - fprintf (afile, "F%s_", moduleName); /* scope is file */ - else - fprintf (afile, "G_"); /* scope is global */ + + symbol *sym; + + 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 */ + + /* I don't think this applies to us. We are using gpasm. CRF */ + + fprintf (afile, ";\t.area _DUMMY\n"); + /* output the area informtion */ + fprintf (afile, ";\t.area\t%s\n", port->mem.overlay_name); /* MOF */ + } + + for (sym = setFirstItem (ovrset); sym; + sym = setNextItem (ovrset)) + { + + /* if extern then do nothing */ + if (IS_EXTERN (sym->etype)) + continue; + + /* if allocation required check is needed + then check if the symbol really requires + allocation only for local variables */ + if (!IS_AGGREGATE (sym->type) && + !(sym->_isparm && !IS_REGPARM (sym->etype)) + && !sym->allocreq && sym->level) + continue; + + /* if global variable & not static or extern + and addPublics allowed then add it to the public set */ + if ((sym->_isparm && !IS_REGPARM (sym->etype)) + && !IS_STATIC (sym->etype)) + addSetHead (&publics, sym); + + /* if extern then do nothing or is a function + then do nothing */ + if (IS_FUNC (sym->type)) + continue; + + /* print extra debug info if required */ + if (options.debug || sym->level == 0) + { + if (!sym->level) + { /* global */ + if (IS_STATIC (sym->etype)) + fprintf (afile, "F%s_", moduleName); /* scope is file */ + else + fprintf (afile, "G_"); /* scope is global */ + } + else + /* symbol is local */ + fprintf (afile, "L%s_", + (sym->localof ? sym->localof->name : "-null-")); + fprintf (afile, "%s_%d_%d", sym->name, sym->level, sym->block); + } + + /* if is has an absolute address then generate + an equate for this no need to allocate space */ + if (SPEC_ABSA (sym->etype)) + { + + if (options.debug || sym->level == 0) + fprintf (afile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); + + fprintf (afile, "%s\t=\t0x%04x\n", + sym->rname, + SPEC_ADDR (sym->etype)); + } + else + { + if (options.debug || sym->level == 0) + fprintf (afile, "==.\n"); + + /* allocate space */ + fprintf (afile, "%s:\n", sym->rname); + fprintf (afile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff); + } + } - else - /* symbol is local */ - fprintf (afile, "L%s_", - (sym->localof ? sym->localof->name : "-null-")); - fprintf (afile, "%s_%d_%d", sym->name, sym->level, sym->block); - } - - /* if is has an absolute address then generate - an equate for this no need to allocate space */ - if (SPEC_ABSA (sym->etype)) - { - - if (options.debug || sym->level == 0) - fprintf (afile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); - - fprintf (afile, "%s\t=\t0x%04x\n", - sym->rname, - SPEC_ADDR (sym->etype)); - } - else - { - if (options.debug || sym->level == 0) - fprintf (afile, "==.\n"); - - /* allocate space */ - fprintf (afile, "%s:\n", sym->rname); - fprintf (afile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff); - } - } - } } +void +pic14_emitInterruptHandler (FILE * asmFile) +{ + if (pic14_hasInterrupt) + { + + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; interrupt and initialization code\n"); + fprintf (asmFile, "%s", iComments2); + // Note - for mplink may have to enlarge section vectors in .lnk file + // Note: Do NOT name this code_interrupt to avoid nameclashes with + // source files's code segment (interrupt.c -> code_interrupt) + fprintf (asmFile, "c_interrupt\t%s\t0x4\n", CODE_NAME); + + /* interrupt service routine */ + fprintf (asmFile, "__sdcc_interrupt\n"); + copypCode(asmFile, 'I'); + } +} /*-----------------------------------------------------------------*/ /* glue - the final glue that hold the whole thing together */ @@ -994,264 +1242,254 @@ pic14emitOverlay (FILE * afile) void picglue () { + char udata_name[80]; + FILE *vFile; + FILE *asmFile; + FILE *ovrFile = tempfile(); + + addSetHead(&tmpfileSet,ovrFile); + pCodeInitRegisters(); - FILE *vFile; - FILE *asmFile; - FILE *ovrFile = tempfile(); - int i; - - addSetHead(&tmpfileSet,ovrFile); - - - if (mainf && mainf->fbody) { - - pBlock *pb = newpCodeChain(NULL,'X',newpCodeCharP("; Starting pCode block")); - addpBlock(pb); - - /* entry point @ start of CSEG */ - addpCode2pBlock(pb,newpCodeLabelStr("__sdcc_program_startup")); - /* put in the call to main */ - addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp("_main",PO_STR))); - - if (options.mainreturn) { - - addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will return to caller\n")); - addpCode2pBlock(pb,newpCode(POC_RETURN,NULL)); - - } else { - - addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will lock up\n")); - addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("$",PO_STR))); - - } - } - - - /* At this point we've got all the code in the form of pCode structures */ - /* Now it needs to be rearranged into the order it should be placed in the */ - /* code space */ - - movepBlock2Head(code->dbName); // Last - movepBlock2Head('X'); - movepBlock2Head(statsg->dbName); // First - - - AnalyzepCode('*'); //code->dbName); - printCallTree(stderr); - - pCodePeepInit(); - - OptimizepCode(code->dbName); - - - /* print the global struct definitions */ - if (options.debug) - cdbStructBlock (0,cdbFile); - - vFile = tempfile(); - /* PENDING: this isnt the best place but it will do */ - if (port->general.glue_up_main) { - /* create the interrupt vector table */ - pic14createInterruptVect (vFile); - } - - addSetHead(&tmpfileSet,vFile); - - /* emit code for the all the variables declared */ - pic14emitMaps (); - /* do the overlay segments */ - pic14emitOverlay(ovrFile); - - - pcode_test(); - - - /* now put it all together into the assembler file */ - /* create the assembler file name */ - - if (!options.c1mode) { - sprintf (buffer, srcFileName); - strcat (buffer, ".asm"); - } - else { - strcpy(buffer, options.out_name); - } - - if (!(asmFile = fopen (buffer, "w"))) { - werror (E_FILE_OPEN_ERR, buffer); - exit (1); - } - - /* initial comments */ - pic14initialComments (asmFile); - - /* print module name */ - fprintf (asmFile, ";\t.module %s\n", moduleName); - - /* Let the port generate any global directives, etc. */ - if (port->genAssemblerPreamble) - { - port->genAssemblerPreamble(asmFile); - } - - /* print the global variables in this module */ - pic14printPublics (asmFile); - - - /* copy the sfr segment */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; special function registers\n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, sfr->oFile); - - - /* Put all variables into a cblock */ - fprintf (asmFile, "\n\n\tcblock 0x0c\n\n"); - - for(i=0; i=0x0c) ) - fprintf (asmFile, "\t%s\n",regspic14[i].name); - } - - - /* For now, create a "dpl" and a "dph" in the register space */ - /* of the pic so that we can use the same calling mechanism */ - /* as the 8051 port */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; dpl and dph to emulate the 8051 calling mechanism \n"); - fprintf (asmFile, "%s", iComments2); - - fprintf (asmFile, "\tdph\n"); - - - - /* copy the sbit segment */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; special function bits \n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, sfrbit->oFile); - - /* copy the data segment */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; internal ram data\n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, data->oFile); - - - /* create the overlay segments */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; overlayable items in internal ram \n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, ovrFile); + /* check for main() */ + mainf = newSymbol ("main", 0); + mainf->block = 0; + mainf = findSymWithLevel (SymbolTab, mainf); - /* create the stack segment MOF */ - if (mainf && mainf->fbody) { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; Stack segment in internal ram \n"); - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, ";\t.area\tSSEG\t(DATA)\n" - ";__start__stack:\n;\t.ds\t1\n\n"); - } + if (!mainf || !IFFUNC_HASBODY(mainf->type)) + { + /* main missing -- import stack from main module */ + //fprintf (stderr, "main() missing -- assuming we are NOT the main module\n"); + pic14_options.isLibrarySource = 1; + } - /* 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 external stack then reserve space of it */ - if (mainf && mainf->fbody && options.useXstack ) { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; external stack \n"); - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile,";\t.area XSEG (XDATA)\n"); /* MOF */ - fprintf (asmFile,";\t.ds 256\n"); - } +#if 0 + if (mainf && IFFUNC_HASBODY(mainf->type)) { + + pBlock *pb = newpCodeChain(NULL,'X',newpCodeCharP("; Starting pCode block")); + addpBlock(pb); + + /* entry point @ start of CSEG */ + addpCode2pBlock(pb,newpCodeLabel("__sdcc_program_startup",-1)); + /* put in the call to main */ + addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp("_main",PO_STR))); + + if (options.mainreturn) { + + addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will return to caller\n")); + addpCode2pBlock(pb,newpCode(POC_RETURN,NULL)); + + } else { + + addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will lock up\n")); + addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("$",PO_STR))); + + } + } +#endif + /* At this point we've got all the code in the form of pCode structures */ + /* Now it needs to be rearranged into the order it should be placed in the */ + /* code space */ - /* copy xtern ram data */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; external ram data\n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, xdata->oFile); - - - fprintf (asmFile, "\tendc\n"); - - - /* copy the bit segment */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; bit data\n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, bit->oFile); - - - fprintf (asmFile, "\tORG 0\n"); - - /* copy the interrupt vector table */ - if (mainf && mainf->fbody) { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; interrupt vector \n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, vFile); - } - - /* copy global & static initialisations */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; global & static initialisations\n"); - fprintf (asmFile, "%s", iComments2); - - /* Everywhere we generate a reference to the static_name area, - * (which is currently only here), we immediately follow it with a - * definition of the post_static_name area. This guarantees that - * the post_static_name area will immediately follow the static_name - * area. - */ - fprintf (asmFile, ";\t.area %s\n", port->mem.static_name); /* MOF */ - fprintf (asmFile, ";\t.area %s\n", port->mem.post_static_name); - fprintf (asmFile, ";\t.area %s\n", port->mem.static_name); - - if (mainf && mainf->fbody) { - fprintf (asmFile,"__sdcc_gsinit_startup:\n"); - /* if external stack is specified then the - higher order byte of the xdatalocation is - going into P2 and the lower order going into - spx */ - if (options.useXstack) { - fprintf(asmFile,";\tmov\tP2,#0x%02x\n", - (((unsigned int)options.xdata_loc) >> 8) & 0xff); - fprintf(asmFile,";\tmov\t_spx,#0x%02x\n", - (unsigned int)options.xdata_loc & 0xff); - } - - } - - if (port->general.glue_up_main && mainf && mainf->fbody) - { - /* This code is generated in the post-static area. - * This area is guaranteed to follow the static area - * by the ugly shucking and jiving about 20 lines ago. - */ - fprintf(asmFile, ";\t.area %s\n", port->mem.post_static_name); - fprintf (asmFile,";\tljmp\t__sdcc_program_startup\n"); - } + movepBlock2Head('P'); // Last + movepBlock2Head(code->dbName); + movepBlock2Head('X'); + movepBlock2Head(statsg->dbName); // First - /* copy over code */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; code\n"); - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, ";\t.area %s\n", port->mem.code_name); - - //copyFile (asmFile, code->oFile); - - copypCode(asmFile, statsg->dbName); - copypCode(asmFile, 'X'); - copypCode(asmFile, code->dbName); + + /* print the global struct definitions */ + if (options.debug) + cdbStructBlock (0); + + vFile = tempfile(); + + addSetHead(&tmpfileSet,vFile); + + /* emit code for the all the variables declared */ + pic14emitMaps (); + /* do the overlay segments */ + pic14emitOverlay(ovrFile); + + /* PENDING: this isnt the best place but it will do */ + if (port->general.glue_up_main) { + /* create the interrupt vector table */ + pic14createInterruptVect (vFile); + } + + AnalyzepCode('*'); + + ReuseReg(); // ReuseReg where call tree permits + + InlinepCode(); + + AnalyzepCode('*'); + + pcode_test(); + + + /* now put it all together into the assembler file */ + /* create the assembler file name */ + + if ((noAssemble || options.c1mode) && fullDstFileName) + { + sprintf (buffer, fullDstFileName); + } + else + { + sprintf (buffer, dstFileName); + strcat (buffer, ".asm"); + } + + if (!(asmFile = fopen (buffer, "w"))) { + werror (E_FILE_OPEN_ERR, buffer); + exit (1); + } + /* prepare statistics */ + resetpCodeStatistics (); + + /* initial comments */ + pic14initialComments (asmFile); + + /* print module name */ + fprintf (asmFile, ";\t.module %s\n", moduleName); + + /* Let the port generate any global directives, etc. */ + if (port->genAssemblerPreamble) + { + port->genAssemblerPreamble(asmFile); + } - fprintf (asmFile,"\tend\n"); + /* Emit the __config directive */ + pic14_emitConfigWord (asmFile); + + /* print the global variables in this module */ + pic14printPublics (asmFile); + + /* print the extern variables in this module */ + pic14printExterns (asmFile); + + /* copy the sfr segment */ + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; special function registers\n"); + fprintf (asmFile, "%s", iComments2); + copyFile (asmFile, sfr->oFile); + + + if (udata_section_name) { + sprintf(udata_name,"%s",udata_section_name); + } else { + sprintf(udata_name,"data_%s",moduleName); + } + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; udata\n"); + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "%s\tudata\n", udata_name); + copyFile (asmFile, data->oFile); + + /* Put all variables into a cblock */ + AnalyzeBanking(); + writeUsedRegs(asmFile); + + /* create the overlay segments */ + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; overlayable items in internal ram \n"); + fprintf (asmFile, "%s", iComments2); + copyFile (asmFile, ovrFile); + +#if 0 + + /* create the stack segment MOF */ + if (mainf && IFFUNC_HASBODY(mainf->type)) { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; Stack segment in internal ram \n"); + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, ";\t.area\tSSEG\t(DATA)\n" + ";__start__stack:\n;\t.ds\t1\n\n"); + } + + /* 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 external stack then reserve space of it */ + if (mainf && IFFUNC_HASBODY(mainf->type) && options.useXstack ) { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; external stack \n"); + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile,";\t.area XSEG (XDATA)\n"); /* MOF */ + fprintf (asmFile,";\t.ds 256\n"); + } + + /* copy xtern ram data */ + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; external ram data\n"); + fprintf (asmFile, "%s", iComments2); + copyFile (asmFile, xdata->oFile); + +#endif + + /* copy the bit segment */ + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; bit data\n"); + fprintf (asmFile, "%s", iComments2); + copyFile (asmFile, bit->oFile); + + /* copy the interrupt vector table */ + if (mainf && IFFUNC_HASBODY(mainf->type)) { + copyFile (asmFile, vFile); + } + + /* create interupt ventor handler */ + pic14_emitInterruptHandler (asmFile); + + if (mainf && IFFUNC_HASBODY(mainf->type)) { + /* initialize data memory */ + fprintf (asmFile, "code_init\t%s\n", CODE_NAME); // Note - for mplink may have to enlarge section vectors in .lnk file + fprintf (asmFile,"__sdcc_gsinit_startup\n"); + /* FIXME: This is temporary. The idata section should be used. If + not, we could add a special feature to the linker. This will + work in the mean time. Put all initalized data in main.c */ + copypCode(asmFile, statsg->dbName); + fprintf (asmFile,"\tpagesel _main\n"); + fprintf (asmFile,"\tgoto _main\n"); + } + +#if 0 + + /* copy global & static initialisations */ + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; global & static initialisations\n"); + fprintf (asmFile, "%s", iComments2); + copypCode(asmFile, statsg->dbName); + +#endif + + /* copy over code */ + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; code\n"); + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "code_%s\t%s\n", moduleName, port->mem.code_name); + + /* unknown */ + copypCode(asmFile, 'X'); + + /* _main function */ + copypCode(asmFile, 'M'); + + /* other functions */ + copypCode(asmFile, code->dbName); + + /* unknown */ + copypCode(asmFile, 'P'); - fclose (asmFile); - applyToSet(tmpfileSet,closeTmpFiles); - applyToSet(tmpfileNameSet, rmTmpFiles); + dumppCodeStatistics (asmFile); + + fprintf (asmFile,"\tend\n"); + + fclose (asmFile); + + rm_tmpfiles(); }