for (sym = setFirstItem (map->syms); sym; sym = setNextItem (map->syms)) {
#if 0
- fprintf(stderr, "\t%s: sym: %s\tused: %d\textern: %d\tstatic: %d\taggregate: %d\n",
+ fprintf(stderr, "%s\t%s: sym: %s\tused: %d\textern: %d\tstatic: %d\taggregate: %d\tregister: 0x%x\tfunction: %d\n",
+ __FUNCTION__,
map->sname, sym->name, sym->used, IS_EXTERN(sym->etype), IS_STATIC(sym->etype),
- IS_AGGREGATE(sym->type));
+ IS_AGGREGATE(sym->type), (SPEC_SCLS(sym->etype) == S_REGISTER), IS_FUNC(sym->type));
printTypeChain( sym->type, stderr );
fprintf(stderr, "\n");
#endif
-// if(PIC16_IS_CONFIG_ADDRESS(SPEC_ADDR(sym->etype)))
-// continue;
-
-
/* if extern then add to externs */
if (IS_EXTERN (sym->etype)) {
- checkAddSym(&externs, sym);
+ /* reduce overhead while linking by not declaring
+ * extern unused external functions (usually declared
+ * in header files) */
+ if(IS_FUNC(sym->type) && !sym->used)continue;
+
+ /* make sure symbol is not in publics section */
+ if(!checkSym(publics, sym))
+ checkAddSym(&externs, sym);
continue;
}
/* if allocation required check is needed
- * then check if the symbol really requires
+ * then check if the symbol really requires
* allocation only for local variables */
if (arFlag && !IS_AGGREGATE (sym->type) &&
!(sym->_isparm && !IS_REGPARM (sym->etype)) &&
#endif
reg = pic16_allocDirReg( operandFromSymbol( sym ));
- checkAddReg(&pic16_rel_udata, reg);
+
+ {
+ sectSym *ssym;
+ int found=0;
+
+#if 1
+ for(ssym=setFirstItem(sectSyms); ssym; ssym=setNextItem(sectSyms)) {
+ if(!strcmp(ssym->name, reg->name))found=1;
+ }
+#endif
+
+ if(!found)checkAddReg(&pic16_rel_udata, reg);
+ }
}
/* if extern then do nothing or is a function
} else {
reg = pic16_allocDirReg( operandFromSymbol( sym ) );
}
- if(checkAddReg(&pic16_rel_udata, reg)) {
- addSetHead(&publics, sym);
+
+ {
+ sectSym *ssym;
+ int found=0;
+
+ fprintf(stderr, "%s:%d sym->rname: %s reg: %p reg->name: %s\n", __FILE__, __LINE__,
+ sym->rname, reg, (reg?reg->name:"<<NULL>>"));
+#if 1
+ for(ssym=setFirstItem(sectSyms); ssym; ssym=setNextItem(sectSyms)) {
+ if(!strcmp(ssym->name, reg->name))found=1;
+ }
+#endif
+
+ if(!found)
+ if(checkAddReg(&pic16_rel_udata, reg)) {
+ addSetHead(&publics, sym);
+ }
+
}
+
+
+
} else
+
addSetHead(&publics, sym);
}
addSet(&rel_idataSymSet, copySymbol(sym));
// ival = newNode ('=', newAst_VALUE(symbolVal (sym)),
-// decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_CHECK));
+// decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_TYPE_NONE));
}
if(ival) {
}
+/* set to 0 to disable debug messages */
+#define DEBUG_PRINTIVAL 0
/*-----------------------------------------------------------------*/
/* pic16_printIvalType - generates ival for int/char */
// fprintf(stderr, "%s for symbol %s\n",__FUNCTION__, sym->rname);
+#if DEBUG_PRINTIVAL
+ fprintf(stderr, "%s\n",__FUNCTION__);
+#endif
+
+
/* if initList is deep */
if (ilist && ilist->type == INIT_DEEP)
ilist = ilist->init.deep;
pic16_printIvalChar (sym_link * type, initList * ilist, char *s, char ptype, void *p)
{
value *val;
- int remain;
+ unsigned int remain;
if(!p)
return 0;
+#if DEBUG_PRINTIVAL
+ fprintf(stderr, "%s\n",__FUNCTION__);
+#endif
- // fprintf(stderr, "%s\n",__FUNCTION__);
if (!s)
{
return;
+#if DEBUG_PRINTIVAL
+ fprintf(stderr, "%s\n",__FUNCTION__);
+#endif
/* take care of the special case */
/* array of characters can be init */
/* by a string */
int size =0;
+#if DEBUG_PRINTIVAL
+ fprintf(stderr, "%s\n",__FUNCTION__);
+#endif
+
+
do {
unsigned long i;
val = list2val(lilist);
symbol *sflds;
initList *iloop = NULL;
+
+#if DEBUG_PRINTIVAL
+ fprintf(stderr, "%s\n",__FUNCTION__);
+#endif
+
sflds = SPEC_STRUCT (type)->fields;
if (ilist) {
VR - Attempting to port this function to pic16 port - 8-Jun-2004
*/
-// fprintf(stderr, "%s\n",__FUNCTION__);
+
+#if DEBUG_PRINTIVAL
+ fprintf(stderr, "%s\n",__FUNCTION__);
+#endif
size = getSize (type);
{
fprintf (stderr, "*** internal error: unknown size in "
"printIvalCharPtr.\n");
+ assert(0);
}
}
else
pic16_emitDB(pic16aopLiteral(val, 0), ptype, p);
pic16_emitDB(pic16aopLiteral(val, 1), ptype, p);
pic16_emitDB(pic16aopLiteral(val, 2), ptype, p);
-
break;
default:
}
}
- if (val->sym && val->sym->isstrlit && !isinSet(statsg->syms, val->sym)) {
- addSet (&statsg->syms, val->sym);
+ if (val->sym && val->sym->isstrlit) { // && !isinSet(statsg->syms, val->sym)) {
+ if(ptype == 'p' && !isinSet(statsg->syms, val->sym))addSet (&statsg->syms, val->sym);
+ else if(ptype == 'f' /*&& !isinSet(rel_idataSymSet, val->sym)*/)addSet(&rel_idataSymSet, val->sym);
}
return 1;
value *val;
int dLvl = 0;
+
+#if DEBUG_PRINTIVAL
+ fprintf(stderr, "%s\n",__FUNCTION__);
+#endif
+
if (ilist)
val = list2val (ilist);
else
pic16_printPointerType (val->name, ptype, p);
} else {
pic16_printPointerType (val->sym->rname, ptype, p);
+
+ if(IS_FUNC(val->sym->type) && !val->sym->used) {
+
+ if(!checkSym(publics, val->sym))
+ checkAddSym(&externs, val->sym);
+
+ /* this has not been declared as extern
+ * so declare it as a 'late extern' just after the symbol */
+ if(ptype == 'f') {
+ fprintf((FILE *)p, "declare symbol as extern");
+ fprintf((FILE *)p, "\textern\t%s\n", val->sym->rname);
+ fprintf((FILE *)p, "continue variable declaration");
+ }
+ }
}
return;
value *val;
int size;
-
#if 0
fprintf(stderr, "%s:%d initialising pointer: %s size: %d\n", __FILE__, __LINE__,
sym->rname, getSize(sym->type));
pic16_emitDB(pic16aopLiteral(val, 0), ptype, p);
pic16_emitDB(pic16aopLiteral(val, 1), ptype, p);
pic16_emitDB(pic16aopLiteral(val, 2), ptype, p);
+ default:
+ assert(0);
}
return;
}
pic16_printGPointerType (val->name, sym->name, (IS_PTR(type)?DCL_TYPE(type):PTR_TYPE(SPEC_OCLS(sym->etype))),
(IS_PTR (val->type) ? DCL_TYPE (val->type) :
PTR_TYPE (SPEC_OCLS (val->etype))), ptype, p);
- }
+ } else
+ assert(0);
return;
}
if (!p)
return;
-// fprintf(stderr, "%s:%d generating init for %s\n", __FILE__, __LINE__, sym->name);
-
+#if 0
+ fprintf(stderr, "%s:%d generating init for %s\n", __FILE__, __LINE__, sym->name);
+ fprintf(stderr, "%s: IS_STRUCT: %d IS_ARRAY: %d IS_PTR: %d IS_SPEC: %d\n", sym->name,
+ IS_STRUCT(type), IS_ARRAY(type), IS_PTR(type), IS_SPEC(type));
+#endif
+
/* if structure then */
if (IS_STRUCT (type))
{
int PIC16_IS_CONFIG_ADDRESS(int address)
{
+ return ((address >= pic16->cwInfo.confAddrStart && address <= pic16->cwInfo.confAddrEnd));
+}
- return (address >= pic16->cwInfo.confAddrStart && address <= pic16->cwInfo.confAddrEnd);
+int PIC16_IS_IDLOC_ADDRESS(int address)
+{
+ return ((address >= pic16->idInfo.idAddrStart && address <= pic16->idInfo.idAddrEnd));
}
+/* wrapper function for the above */
+int PIC16_IS_HWREG_ADDRESS(int address)
+{
+ return (PIC16_IS_CONFIG_ADDRESS(address) || PIC16_IS_IDLOC_ADDRESS(address));
+}
+
+
/*-----------------------------------------------------------------*/
/* emitStaticSeg - emitcode for the static segment */
/*-----------------------------------------------------------------*/
pic16emitStaticSeg (memmap * map)
{
symbol *sym;
-
- fprintf (map->oFile, ";\t.area\t%s\n", map->sname);
+ static int didcode=0;
//fprintf(stderr, "%s\n",__FUNCTION__);
{
#if 0
- fprintf(stderr, "\t%s: sym: %s\tused: %d\tSPEC_ABSA: %d\tSPEC_AGGREGATE: %d\tCODE: %d\n\
-CODESPACE: %d\tCONST: %d\tPTRCONST: %d\tSPEC_CONST: %d\n",
+ fprintf(stderr, "%s\t%s: sym: %s\tused: %d\tSPEC_ABSA: %d\tSPEC_AGGREGATE: %d\tCODE: %d\n\
+CODESPACE: %d\tCONST: %d\tPTRCONST: %d\tSPEC_CONST: %d\n", __FUNCTION__,
map->sname, sym->name, sym->used, SPEC_ABSA(sym->etype), IS_AGGREGATE(sym->type),
IS_CODE(sym->etype), IN_CODESPACE( SPEC_OCLS(sym->etype)), IS_CONSTANT(sym->etype),
IS_PTR_CONST(sym->etype), SPEC_CONST(sym->etype));
continue;
}
+ if(SPEC_ABSA(sym->etype) && PIC16_IS_IDLOC_ADDRESS(SPEC_ADDR(sym->etype))) {
+ pic16_assignIdByteValue(SPEC_ADDR(sym->etype),
+ (char) floatFromVal(list2val(sym->ival)));
+
+ continue;
+ }
+
/* if it is "extern" then do nothing */
if (IS_EXTERN (sym->etype) && !SPEC_ABSA(sym->etype)) {
checkAddSym(&externs, sym);
pic16_addpCode2pBlock(pb,pcf);
pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(sym->rname,-1));
+// fprintf(stderr, "%s:%d [1] generating init for label: %s\n", __FILE__, __LINE__, sym->rname);
pic16_printIval(sym, sym->type, sym->ival, 'p', (void *)pb);
pic16_flushDB('p', (void *)pb);
/* special case for character strings */
if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) &&
- SPEC_CVAL (sym->etype).v_char)
+ SPEC_CVAL (sym->etype).v_char) {
+
+// fprintf(stderr, "%s:%d printing code string from %s\n", __FILE__, __LINE__, sym->rname);
+
pic16_pCodeConstString(sym->rname , SPEC_CVAL (sym->etype).v_char);
- else {
+ } else {
assert(0);
- fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
}
}
// fprintf(stderr, "%s:%d spec_absa is false for symbol: %s\n",
// __FILE__, __LINE__, sym->name);
+
/* if it has an initial value */
if (sym->ival) {
pBlock *pb;
pb = pic16_newpCodeChain(NULL, 'P',pic16_newpCodeCharP("; Starting pCode block for Ival"));
pic16_addpBlock(pb);
- pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(sym->rname,-1));
+ if(!didcode) {
+ /* make sure that 'code' directive is emitted before, once */
+ pic16_addpCode2pBlock(pb, pic16_newpCodeAsmDir("code", NULL));
+
+ didcode++;
+ }
+
+// fprintf(stderr, "%s:%d [2] generating init for label: %s\n", __FILE__, __LINE__, sym->rname);
+
+ pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(sym->rname,-1));
pic16_printIval(sym, sym->type, sym->ival, 'p', (void *)pb);
pic16_flushDB('p', (void *)pb);
noAlloc--;
/* symbol doesn't have absolute address and no initial value */
/* allocate space */
+// fprintf(stderr, "%s:%d [3] generating init for label: %s\n", __FILE__, __LINE__, sym->rname);
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)
+ SPEC_CVAL (sym->etype).v_char) {
+
+// fprintf(stderr, "%s:%d printing code string from %s\n", __FILE__, __LINE__, sym->rname);
+
pic16_pCodeConstString(sym->rname , SPEC_CVAL (sym->etype).v_char);
- else {
+ } else {
assert(0);
- fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
}
}
}
pic16->cwInfo.crInfo[i].value);
}
+void pic16_emitIDRegs(FILE *of)
+{
+ int i;
+
+ for(i=0;i<pic16->idInfo.idAddrEnd-pic16->idInfo.idAddrStart;i++)
+ if(pic16->idInfo.irInfo[i].emit)
+ fprintf (of, "\t__idlocs 0x%06x, 0x%hhx\n",
+ pic16->idInfo.idAddrStart+i,
+ pic16->idInfo.irInfo[i].value);
+}
+
static void
pic16emitMaps ()
if((!pic16_options.omit_ivt) || (pic16_options.omit_ivt && pic16_options.leave_reset)) {
fprintf (vFile, ";\t.area\t%s\n", CODE_NAME);
- fprintf(vFile, ".intvecs\tcode\t0x0000\n");
- fprintf (vFile, "__interrupt_vect:\n");
+ fprintf(vFile, ".intvecs\tcode\t0x%06x\n", pic16_options.ivt_loc);
/* this is an overkill since WE are the port,
* and we know if we have a genIVT function! */
static void
pic16initialComments (FILE * afile)
{
- initialComments (afile);
- fprintf (afile, "; PIC16 port for the Microchip 16-bit core micros\n");
- fprintf (afile, iComments2);
-
+ initialComments (afile);
+ fprintf (afile, "; PIC16 port for the Microchip 16-bit core micros\n");
+ if(pic16_mplab_comp)
+ fprintf(afile, "; MPLAB/MPASM/MPASMWIN/MPLINK compatibility mode enabled\n");
+ fprintf (afile, iComments2);
}
/*-----------------------------------------------------------------*/
{
symbol *sym;
- fprintf (afile, "%s", iComments2);
+ fprintf (afile, "\n%s", iComments2);
fprintf (afile, "; public variables in this module\n");
fprintf (afile, "%s", iComments2);
{
symbol *sym;
- fprintf(afile, "%s", iComments2);
+ /* print nothing if no externs to declare */
+ if(!elementsInSet(externs) && !elementsInSet(pic16_builtin_functions))
+ return;
+
+ fprintf(afile, "\n%s", iComments2);
fprintf(afile, "; extern variables in this module\n");
fprintf(afile, "%s", iComments2);
and addPublics allowed then add it to the public set */
if ((sym->_isparm && !IS_REGPARM (sym->etype))
&& !IS_STATIC (sym->etype)) {
+// fprintf(stderr, "%s:%d %s accessed\n", __FILE__, __LINE__, __FUNCTION__);
checkAddSym(&publics, sym);
// addSetHead (&publics, sym);
}
addSetHead(&tmpfileSet,ovrFile);
pic16_pCodeInitRegisters();
- if (mainf && IFFUNC_HASBODY(mainf->type)) {
+
+ if (pic16_options.no_crt && mainf && IFFUNC_HASBODY(mainf->type)) {
pBlock *pb = pic16_newpCodeChain(NULL,'X',pic16_newpCodeCharP("; Starting pCode block"));
pic16_addpBlock(pb);
if(initsfpnt) {
pic16_addpCode2pBlock(pb, pic16_newpCode(POC_LFSR,
- pic16_popGetLit2(1, pic16_newpCodeOpRegFromStr("stack"))));
+ pic16_popGetLit2(1, pic16_newpCodeOpRegFromStr("_stack_end"))));
pic16_addpCode2pBlock(pb, pic16_newpCode(POC_LFSR,
- pic16_popGetLit2(2, pic16_newpCodeOpRegFromStr("stack"))));
+ pic16_popGetLit2(2, pic16_newpCodeOpRegFromStr("_stack_end"))));
}
/* put in the call to main */
pic16emitOverlay(ovrFile);
pic16_AnalyzepCode('*');
-#if 0
- {
+#if 1
+ if(pic16_options.dumpcalltree) {
FILE *cFile;
sprintf(buffer, dstFileName);
strcat(buffer, ".calltree");
/* initial comments */
pic16initialComments (asmFile);
-
+
/* print module name */
fprintf(asmFile, "#FILE\t\"%s\"\n", fullSrcFileName);
-
+
/* Let the port generate any global directives, etc. */
if (port->genAssemblerPreamble) {
port->genAssemblerPreamble(asmFile);
}
-
+
/* print the extern variables to this module */
pic16_printExterns(asmFile);
-
+
/* print the global variables in this module */
pic16printPublics (asmFile);
fprintf (asmFile, "%s", iComments2);
copyFile (asmFile, sfr->oFile);
#endif
-
/* Put all variables into a cblock */
pic16_AnalyzeBanking();
pic16_writeUsedRegs(asmFile);
-#if 0
- /* create the overlay segments */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; overlayable items in internal ram \n");
- fprintf (asmFile, "%s", iComments2);
- copyFile (asmFile, ovrFile);
-#endif
-
-#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");
- }
-#endif
-
-#if 0
- /* no indirect data in pic */
- /* create the idata segment */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; indirectly addressable internal ram data\n");
- fprintf (asmFile, "%s", iComments2);
- copyFile (asmFile, idata->oFile);
-#endif
-
-
#if 0
/* no xdata in pic */
/* if external stack then reserve space of it */
/* copy the interrupt vector table */
if(mainf && IFFUNC_HASBODY(mainf->type)) {
- fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "\n%s", iComments2);
fprintf (asmFile, "; interrupt vector \n");
fprintf (asmFile, "%s", iComments2);
copyFile (asmFile, vFile);
}
/* copy global & static initialisations */
- fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "\n%s", iComments2);
fprintf (asmFile, "; global & static initialisations\n");
fprintf (asmFile, "%s", iComments2);
-#if 0
- /* copy over code */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "\tcode\n");
- fprintf (asmFile, "%s", iComments2);
-#endif
-
if(pic16_debug_verbose)
fprintf(asmFile, "; A code from now on!\n");
pic16_copypCode(asmFile, 'A');
- if(mainf && IFFUNC_HASBODY(mainf->type)) {
- fprintf(asmFile, "\tcode\n");
- fprintf(asmFile,"__sdcc_gsinit_startup:\n");
-
-#if 0
- /* FIXME 8051 legacy (?!) - VR 20-Jun-2003 */
- /* if external stack is specified then the
- * higher order byte of the xdatalocation is
- * going into P2 and the lower order going into */
-
- 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(pic16_options.no_crt) {
+ if(mainf && IFFUNC_HASBODY(mainf->type)) {
+ fprintf(asmFile, "\tcode\n");
+ fprintf(asmFile,"__sdcc_gsinit_startup:\n");
}
-#endif
}
// copyFile (stderr, code->oFile);
pic16_copypCode(asmFile, statsg->dbName);
- if (port->general.glue_up_main && mainf && IFFUNC_HASBODY(mainf->type)) {
- fprintf (asmFile,"\tgoto\t__sdcc_program_startup\n");
+ if(pic16_options.no_crt) {
+ if (port->general.glue_up_main && mainf && IFFUNC_HASBODY(mainf->type)) {
+ fprintf (asmFile,"\tgoto\t__sdcc_program_startup\n");
+ }
}
projects / fw / sdcc / blobdiff