/*-------------------------------------------------------------------------
- SDCCgen51.c - source file for code generation for 8051
-
+ gen.c - source file for code generation for pic16
+
Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
and - Jean-Louis VERN.jlvern@writeme.com (1999)
Bug Fixes - Wojciech Stryjewski wstryj1@tiger.lsu.edu (1999 v2.1.9a)
#include "ralloc.h"
#include "pcode.h"
#include "gen.h"
-
+#include "genutils.h"
+#include "device.h"
+#include "main.h"
extern void pic16_genUMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
extern void pic16_genSMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
void pic16_genMult8X8_8 (operand *, operand *,operand *);
-pCode *pic16_AssembleLine(char *line);
+pCode *pic16_AssembleLine(char *line, int peeps);
extern void pic16_printpBlock(FILE *of, pBlock *pb);
static asmop *newAsmop (short type);
-static pCodeOp *popRegFromString(char *str, int size, int offset);
+static pCodeOp *pic16_popRegFromString(char *str, int size, int offset);
+extern pCode *pic16_newpCodeAsmDir(char *asdir, char *argfmt, ...);
static void mov2w (asmop *aop, int offset);
static int aopIdx (asmop *aop, int offset);
static int labelOffset=0;
extern int pic16_debug_verbose;
static int optimized_for_speed = 0;
+/*
+ hack hack
+
+*/
/* max_key keeps track of the largest label number used in
a function. This is then used to adjust the label offset
}
+void pic16_emitcomment (char *fmt, ...)
+{
+ va_list ap;
+ char lb[INITIAL_INLINEASM];
+ char *lbp = lb;
+
+ if(!pic16_debug_verbose)
+ return;
+
+ va_start(ap,fmt);
+
+ lb[0] = ';';
+ vsprintf(lb+1,fmt,ap);
+
+ while (isspace(*lbp)) lbp++;
+
+ if (lbp && *lbp)
+ lineCurr = (lineCurr ?
+ connectLine(lineCurr,newLineNode(lb)) :
+ (lineHead = newLineNode(lb)));
+ lineCurr->isInline = _G.inLine;
+ lineCurr->isDebug = _G.debugLine;
+
+ pic16_addpCode2pBlock(pb,pic16_newpCodeCharP(lb));
+ va_end(ap);
+
+// fprintf(stderr, "%s\n", lb);
+}
+
void DEBUGpic16_emitcode (char *inst,char *fmt, ...)
{
va_list ap;
lineCurr->isDebug = _G.debugLine;
pic16_addpCode2pBlock(pb,pic16_newpCodeCharP(lb));
-
va_end(ap);
-}
+// fprintf(stderr, "%s\n", lb);
+}
void pic16_emitpLabel(int key)
{
pic16_addpCode2pBlock(pb,pic16_newpCode(poc,pcop));
else
DEBUGpic16_emitcode(";","%s ignoring NULL pcop",__FUNCTION__);
+
+// fprintf(stderr, "%s\n", pcop->name);
}
void pic16_emitpcodeNULLop(PIC_OPCODE poc)
}
+
+#if 1
+#define pic16_emitcode DEBUGpic16_emitcode
+#else
/*-----------------------------------------------------------------*/
/* pic16_emitcode - writes the code into a file : for now it is simple */
/*-----------------------------------------------------------------*/
lineCurr->isInline = _G.inLine;
lineCurr->isDebug = _G.debugLine;
- if(pic16_debug_verbose)
- pic16_addpCode2pBlock(pb,pic16_newpCodeCharP(lb));
+// VR fprintf(stderr, "lb = <%s>\n", lbp);
+
+// if(pic16_debug_verbose)
+// pic16_addpCode2pBlock(pb,pic16_newpCodeCharP(lb));
va_end(ap);
}
+#endif
/*-----------------------------------------------------------------*/
bool r0iu = FALSE , r1iu = FALSE;
bool r0ou = FALSE , r1ou = FALSE;
+ //fprintf(stderr, "%s:%d: getting free ptr from ic = %c\n", __FUNCTION__, __LINE__, ic->op);
+
/* the logic: if r0 & r1 used in the instruction
then we are in trouble otherwise */
DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
/* if already has one */
- if (sym->aop)
+ if (sym->aop) {
+ DEBUGpic16_emitcode("; ***", "already has sym %s %d", __FUNCTION__, __LINE__);
return sym->aop;
+ }
/* assign depending on the storage class */
/* if it is on the stack or indirectly addressable */
offset = OP_SYMBOL(IC_LEFT(ic))->offset;
aop->aopu.pcop = pic16_popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname,0,val);
+#if 0
PCOI(aop->aopu.pcop)->_const = IS_PTR_CONST(operandType(op));
+#else
+ PCOI(aop->aopu.pcop)->_const = IS_CODEPTR(operandType(op));
+#endif
PCOI(aop->aopu.pcop)->index = val;
DEBUGpic16_emitcode(";","%d: rname %s, val %d, const = %d",
__LINE__,OP_SYMBOL(IC_LEFT(ic))->rname,
+#if 0
val, IS_PTR_CONST(operandType(op)));
+#else
+ val, IS_CODEPTR(operandType(op)));
+#endif
// DEBUGpic16_emitcode(";","aop type %s",pic16_AopType(AOP_TYPE(IC_LEFT(ic))));
if (!op)
return ;
- // DEBUGpic16_emitcode(";","%d",__LINE__);
+// DEBUGpic16_emitcode(";","%d",__LINE__);
+
/* if this a literal */
if (IS_OP_LITERAL(op)) {
op->aop = aop = newAsmop(AOP_LIT);
{
sym_link *type = operandType(op);
+#if 0
if(IS_PTR_CONST(type))
+#else
+ if(IS_CODEPTR(type))
+#endif
DEBUGpic16_emitcode(";","%d aop type is const pointer",__LINE__);
}
/* if the underlying symbol has a aop */
if (IS_SYMOP(op) && OP_SYMBOL(op)->aop) {
- DEBUGpic16_emitcode(";","%d",__LINE__);
+ DEBUGpic16_emitcode(";","%d has symbol",__LINE__);
op->aop = OP_SYMBOL(op)->aop;
return;
}
/* if this is a true symbol */
if (IS_TRUE_SYMOP(op)) {
- //DEBUGpic16_emitcode(";","%d - true symop",__LINE__);
+ DEBUGpic16_emitcode(";","%d - true symop",__LINE__);
op->aop = aopForSym(ic,OP_SYMBOL(op),result);
return ;
}
sym = OP_SYMBOL(op);
-
+ DEBUGpic16_emitcode("; ***", "%d: symbol name = %s", __LINE__, sym->name);
/* if the type is a conditional */
if (sym->regType == REG_CND) {
aop = op->aop = sym->aop = newAsmop(AOP_CRY);
sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
//aop->aopu.pcop = pic16_popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
- aop->aopu.pcop = popRegFromString(sym->usl.spillLoc->rname,
+ aop->aopu.pcop = pic16_popRegFromString(sym->usl.spillLoc->rname,
getSize(sym->type),
sym->usl.spillLoc->offset);
aop->size = getSize(sym->type);
{
sym_link *type = operandType(op);
+#if 0
if(IS_PTR_CONST(type))
+#else
+ if(IS_CODEPTR(type))
+#endif
DEBUGpic16_emitcode(";","%d aop type is const pointer",__LINE__);
}
return PCOP(pcor);
}
+
/*-----------------------------------------------------------------*/
-/* pic16_popGet - asm operator to pcode operator conversion */
+/* pic16_popGetLit - asm operator to pcode operator conversion */
/*-----------------------------------------------------------------*/
pCodeOp *pic16_popGetLit(unsigned int lit)
{
-
return pic16_newpCodeOpLit(lit);
}
+/*-----------------------------------------------------------------*/
+/* pic16_popGetLit2 - asm operator to pcode operator conversion */
+/*-----------------------------------------------------------------*/
+pCodeOp *pic16_popGetLit2(unsigned int lit, pCodeOp *arg2)
+{
+ return pic16_newpCodeOpLit2(lit, arg2);
+}
+
/*-----------------------------------------------------------------*/
-/* pic16_popGetImmd - asm operator to pcode immediate conversion */
+/* pic16_popGetImmd - asm operator to pcode immediate conversion */
/*-----------------------------------------------------------------*/
pCodeOp *pic16_popGetImmd(char *name, unsigned int offset, int index)
{
}
/*-----------------------------------------------------------------*/
-/* popRegFromString - */
+/* pic16_popRegFromString - */
/*-----------------------------------------------------------------*/
-static pCodeOp *popRegFromString(char *str, int size, int offset)
+static pCodeOp *pic16_popRegFromString(char *str, int size, int offset)
{
pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
pcop->type = PO_DIR;
- DEBUGpic16_emitcode(";","%d",__LINE__);
+ DEBUGpic16_emitcode(";","%d %s %s",__LINE__, __FUNCTION__, str);
+// fprintf(stderr, "%s:%d: register name = %s pos = %d/%d\n", __FUNCTION__, __LINE__, str, offset, size);
if(!str)
str = "BAD_STRING";
PCOR(pcop)->r = pic16_dirregWithName(pcop->name);
if(PCOR(pcop)->r == NULL) {
- //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
+// fprintf(stderr, "%s:%d - couldn't find %s in allocated regsters, size= %d ofs= %d\n",
+// __FUNCTION__, __LINE__, str, size, offset);
PCOR(pcop)->r = pic16_allocRegByName (pcop->name,size);
+
+ //fprintf(stderr, "allocating new register -> %s\n", str);
+
DEBUGpic16_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
} else {
DEBUGpic16_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
return pcop;
}
-static pCodeOp *popRegFromIdx(int rIdx)
+static pCodeOp *pic16_popRegFromIdx(int rIdx)
{
pCodeOp *pcop;
- DEBUGpic16_emitcode ("; ***","%s,%d , rIdx=0x%x",
- __FUNCTION__,__LINE__,rIdx);
+// DEBUGpic16_emitcode ("; ***","%s,%d\trIdx=0x%x", __FUNCTION__,__LINE__,rIdx);
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ PCOR(pcop)->rIdx = rIdx;
+ PCOR(pcop)->r = pic16_regWithIdx(rIdx);
+ PCOR(pcop)->r->isFree = 0;
+ PCOR(pcop)->r->wasUsed = 1;
- PCOR(pcop)->rIdx = rIdx;
- PCOR(pcop)->r = pic16_regWithIdx(rIdx);
- PCOR(pcop)->r->isFree = 0;
- PCOR(pcop)->r->wasUsed = 1;
+ pcop->type = PCOR(pcop)->r->pc_type;
- pcop->type = PCOR(pcop)->r->pc_type;
+ return pcop;
+}
+/*---------------------------------------------------------------------------------*/
+/* pic16_popGet2 - a variant of pic16_popGet to handle two memory operand commands */
+/* VR 030601 */
+/*---------------------------------------------------------------------------------*/
+pCodeOp *pic16_popGet2(asmop *aop_src, asmop *aop_dst, int offset)
+{
+ pCodeOpReg2 *pcop2;
+ pCodeOp *temp;
+
+ pcop2 = (pCodeOpReg2 *)pic16_popGet(aop_src, offset);
- return pcop;
+ /* comment the following check, so errors to throw up */
+// if(!pcop2)return NULL;
+
+ temp = pic16_popGet(aop_dst, offset);
+ pcop2->pcop2 = temp;
+
+ return PCOP(pcop2);
}
+
+/*---------------------------------------------------------------------------------*/
+/* pic16_popCombine2 - combine two pCodeOpReg variables into one for use with */
+/* movff instruction */
+/*---------------------------------------------------------------------------------*/
+pCodeOp *pic16_popCombine2(pCodeOpReg *src, pCodeOpReg *dst, int noalloc)
+{
+ pCodeOpReg2 *pcop2;
+
+ if(!noalloc) {
+ pcop2 = (pCodeOpReg2 *)pic16_popCopyReg(src);
+ pcop2->pcop2 = pic16_popCopyReg(dst);
+ } else {
+ /* the pCodeOp may be already allocated */
+ pcop2 = (pCodeOpReg2 *)(src);
+ pcop2->pcop2 = (pCodeOp *)(dst);
+ }
+
+ return PCOP(pcop2);
+}
+
+
/*-----------------------------------------------------------------*/
/* pic16_popGet - asm operator to pcode operator conversion */
/*-----------------------------------------------------------------*/
case AOP_DPTR2:
case AOP_ACC:
DEBUGpic16_emitcode(";8051 legacy","%d type = %s",__LINE__,pic16_AopType(aop->type));
+ fprintf(stderr, ";8051 legacy %d type = %s\n",__LINE__,pic16_AopType(aop->type));
return NULL;
case AOP_IMMD:
- DEBUGpic16_emitcode(";","%d",__LINE__);
+ DEBUGpic16_emitcode(";","%d\tAOP_IMMD",__LINE__);
return pic16_popGetImmd(aop->aopu.aop_immd,offset,0);
case AOP_DIR:
- return popRegFromString(aop->aopu.aop_dir, aop->size, offset);
-#if 0
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- pcop->type = PO_DIR;
-
- /*
- if (offset)
- sprintf(s,"(%s + %d)",
- aop->aopu.aop_dir,
- offset);
- else
- sprintf(s,"%s",aop->aopu.aop_dir);
- pcop->name = Safe_calloc(1,strlen(s)+1);
- strcpy(pcop->name,s);
- */
- pcop->name = Safe_calloc(1,strlen(aop->aopu.aop_dir)+1);
- strcpy(pcop->name,aop->aopu.aop_dir);
- PCOR(pcop)->r = pic16_dirregWithName(aop->aopu.aop_dir);
- if(PCOR(pcop)->r == NULL) {
- //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
- PCOR(pcop)->r = pic16_allocRegByName (aop->aopu.aop_dir,aop->size);
- DEBUGpic16_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
- } else {
- DEBUGpic16_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
- }
- PCOR(pcop)->instance = offset;
-
- return pcop;
-#endif
+ DEBUGpic16_emitcode(";","%d\tAOP_DIR", __LINE__);
+ return pic16_popRegFromString(aop->aopu.aop_dir, aop->size, offset);
case AOP_REG:
{
int rIdx = aop->aopu.aop_reg[offset]->rIdx;
+ DEBUGpic16_emitcode(";","%d\tAOP_REG", __LINE__);
pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
PCOR(pcop)->rIdx = rIdx;
PCOR(pcop)->r = pic16_regWithIdx(rIdx);
}
case AOP_CRY:
+ DEBUGpic16_emitcode(";","%d\tAOP_CRY", __LINE__);
+
pcop = pic16_newpCodeOpBit(aop->aopu.aop_dir,-1,1);
PCOR(pcop)->r = pic16_dirregWithName(aop->aopu.aop_dir);
//if(PCOR(pcop)->r == NULL)
return pcop;
case AOP_LIT:
+ DEBUGpic16_emitcode(";","%d\tAOP_LIT", __LINE__);
return pic16_newpCodeOpLit(pic16aopLiteral (aop->aopu.aop_lit,offset));
case AOP_STR:
- DEBUGpic16_emitcode(";","%d %s",__LINE__,aop->aopu.aop_str[offset]);
+ DEBUGpic16_emitcode(";","%d AOP_STR %s",__LINE__,aop->aopu.aop_str[offset]);
return pic16_newpCodeOpRegFromStr(aop->aopu.aop_str[offset]);
+
/*
pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
PCOR(pcop)->r = pic16_allocRegByName(aop->aopu.aop_str[offset]);
}
+
+void pic16_pushpCodeOpReg(pCodeOpReg *pcop)
+{
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2(pcop, &pic16_pc_postdec1, 0));
+}
+
+void pic16_poppCodeOpReg(pCodeOpReg *pcop)
+{
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2(&pic16_pc_preinc1, pcop, 0));
+}
+
+
+/*-----------------------------------------------------------------*/
+/* pushw - pushes wreg to stack */
+/*-----------------------------------------------------------------*/
+void pushw(void)
+{
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_postdec1));
+}
+
+
+/*-----------------------------------------------------------------*/
+/* pushaop - pushes aop to stack */
+/*-----------------------------------------------------------------*/
+void pushaop(asmop *aop, int offset)
+{
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2(PCOR(pic16_popGet(aop, offset)), &pic16_pc_postdec1, 0));
+}
+
+/*-----------------------------------------------------------------*/
+/* popaop - pops aop from stack */
+/*-----------------------------------------------------------------*/
+void popaop(asmop *aop, int offset)
+{
+ DEBUGpic16_emitcode("; ***", "%s %d", __FUNCTION__, __LINE__);
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2(&pic16_pc_preinc1, PCOR(pic16_popGet(aop, offset)), 0));
+}
+
+void popaopidx(asmop *aop, int offset, int index)
+{
+ int ofs=1;
+
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(STACK_MODEL_LARGE)ofs++;
+
+ pic16_emitpcode(POC_MOVLW, pic16_popGetLit(index + ofs));
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2(&pic16_pc_plusw2, PCOR(pic16_popGet(aop, offset)), 0));
+}
+
/*-----------------------------------------------------------------*/
/* reAdjustPreg - points a register back to where it should */
/*-----------------------------------------------------------------*/
}
-/*-----------------------------------------------------------------*/
-/* genNotFloat - generates not for float operations */
-/*-----------------------------------------------------------------*/
-static void genNotFloat (operand *op, operand *res)
-{
- int size, offset;
- char *l;
- symbol *tlbl ;
-
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* we will put 127 in the first byte of
- the result */
- pic16_aopPut(AOP(res),"#127",0);
- size = AOP_SIZE(op) - 1;
- offset = 1;
-
- l = pic16_aopGet(op->aop,offset++,FALSE,FALSE);
- MOVA(l);
-
- while(size--) {
- pic16_emitcode("orl","a,%s",
- pic16_aopGet(op->aop,
- offset++,FALSE,FALSE));
- }
- tlbl = newiTempLabel(NULL);
-
- tlbl = newiTempLabel(NULL);
- pic16_aopPut(res->aop,one,1);
- pic16_emitcode("jz","%05d_DS_",(tlbl->key+100));
- pic16_aopPut(res->aop,zero,1);
- pic16_emitcode("","%05d_DS_:",(tlbl->key+100));
-
- size = res->aop->size - 2;
- offset = 2;
- /* put zeros in the rest */
- while (size--)
- pic16_aopPut(res->aop,zero,offset++);
-}
#if 0
/*-----------------------------------------------------------------*/
}
+#if !defined(GEN_Not)
/*-----------------------------------------------------------------*/
/* genNot - generate code for ! operation */
/*-----------------------------------------------------------------*/
-static void genNot (iCode *ic)
+static void pic16_genNot (iCode *ic)
{
symbol *tlbl;
- sym_link *optype = operandType(IC_LEFT(ic));
int size;
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
goto release;
}
- /* if type float then do float */
- if (IS_FLOAT(optype)) {
- genNotFloat(IC_LEFT(ic),IC_RESULT(ic));
- goto release;
- }
-
- size = AOP_SIZE(IC_RESULT(ic));
+ size = AOP_SIZE(IC_LEFT(ic));
if(size == 1) {
pic16_emitpcode(POC_COMFW,pic16_popGet(AOP(IC_LEFT(ic)),0));
pic16_emitpcode(POC_ANDLW,pic16_popGetLit(1));
pic16_freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
pic16_freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
+#endif
+#if !defined(GEN_Cpl)
/*-----------------------------------------------------------------*/
/* genCpl - generate code for complement */
/*-----------------------------------------------------------------*/
-static void genCpl (iCode *ic)
+static void pic16_genCpl (iCode *ic)
{
int offset = 0;
int size ;
size = AOP_SIZE(IC_RESULT(ic));
while (size--) {
+/*
char *l = pic16_aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE);
MOVA(l);
pic16_emitcode("cpl","a");
pic16_aopPut(AOP(IC_RESULT(ic)),"a",offset++);
+*/
+ if (pic16_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+ pic16_emitpcode(POC_COMF, pic16_popGet(AOP(IC_LEFT(ic)), offset));
+ } else {
+ pic16_emitpcode(POC_COMFW, pic16_popGet(AOP(IC_LEFT(ic)),offset));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(IC_RESULT(ic)),offset));
+ }
+ offset++;
+
}
pic16_freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
pic16_freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
+#endif
/*-----------------------------------------------------------------*/
/* genUminusFloat - unary minus for floating points */
{
int size = AOP_SIZE(oper);
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic16_pic16_AopType(__LINE__,oper,NULL,NULL);
+
+ if(!GpsuedoStkPtr) {
+// DEBUGpic16_emitcode("; ", "pop %d", GpsuedoStkPtr);
+ /* The last byte in the assignment is in W */
+ size--;
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(oper),size));
+ GpsuedoStkPtr++;
+ }
- DEBUGpic16_pic16_AopType(__LINE__,oper,NULL,NULL);
+ while (size--) {
+// DEBUGpic16_emitcode("; ", "POC_MOVLW %d", GpsuedoStkPtr);
+// DEBUGpic16_emitcode("; ", "POC_MOVFW PLUSW2");
+
+#if STACK_SUPPORT
+ if(USE_STACK) {
+ popaopidx(AOP(oper), size, GpsuedoStkPtr);
+ } else {
+ pic16_emitpcode(POC_MOVFW, pic16_popRegFromIdx(GpsuedoStkPtr-1 + pic16_Gstack_base_addr));
+ }
+#else
+ pic16_emitpcode(POC_MOVFW, pic16_popRegFromIdx(GpsuedoStkPtr-1 + pic16_Gstack_base_addr));
+#endif /* STACK_SUPPORT */
+ GpsuedoStkPtr++;
- if(!GpsuedoStkPtr) {
- /* The last byte in the assignment is in W */
- size--;
- pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(oper),size));
- GpsuedoStkPtr++;
- }
+#if STACK_SUPPORT
+ if(!USE_STACK)
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(oper),size));
+#else
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(oper),size));
+#endif
- while (size--) {
- pic16_emitpcode(POC_MOVFW,popRegFromIdx(GpsuedoStkPtr-1 + pic16_Gstack_base_addr));
- GpsuedoStkPtr++;
- pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(oper),size));
- }
+ }
+
}
#endif
}
+
+
/*-----------------------------------------------------------------*/
/* genCall - generates a call statement */
/*-----------------------------------------------------------------*/
static void genCall (iCode *ic)
{
sym_link *dtype;
+ int stackParms=0;
+
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if caller saves & we have not saved then */
+ if (!ic->regsSaved)
+ saveRegisters(ic);
- /* if caller saves & we have not saved then */
- if (!ic->regsSaved)
- saveRegisters(ic);
+ /* if we are calling a function that is not using
+ * the same register bank then we need to save the
+ * destination registers on the stack */
+ dtype = operandType(IC_LEFT(ic));
+ if (currFunc && dtype &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
+ IFFUNC_ISISR(currFunc->type) &&
+ !ic->bankSaved)
- /* if we are calling a function that is not using
- the same register bank then we need to save the
- destination registers on the stack */
- dtype = operandType(IC_LEFT(ic));
- if (currFunc && dtype &&
- (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
- IFFUNC_ISISR(currFunc->type) &&
- !ic->bankSaved)
+ saverbank(FUNC_REGBANK(dtype),ic,TRUE);
- saverbank(FUNC_REGBANK(dtype),ic,TRUE);
+ /* if send set is not empty the assign */
+ if (_G.sendSet) {
+ iCode *sic;
- /* if send set is not empty the assign */
- if (_G.sendSet) {
- iCode *sic;
- /* For the Pic port, there is no data stack.
- * So parameters passed to functions are stored
- * in registers. (The pCode optimizer will get
- * rid of most of these :).
- */
- int psuedoStkPtr=-1;
- int firstTimeThruLoop = 1;
+ /* For the Pic port, there is no data stack.
+ * So parameters passed to functions are stored
+ * in registers. (The pCode optimizer will get
+ * rid of most of these :). */
- _G.sendSet = reverseSet(_G.sendSet);
+ int psuedoStkPtr=-1;
+ int firstTimeThruLoop = 1;
- /* First figure how many parameters are getting passed */
- for (sic = setFirstItem(_G.sendSet) ; sic ;
- sic = setNextItem(_G.sendSet)) {
+ _G.sendSet = reverseSet(_G.sendSet);
- pic16_aopOp(IC_LEFT(sic),sic,FALSE);
- psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
- pic16_freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
- }
+ /* First figure how many parameters are getting passed */
+ for (sic = setFirstItem(_G.sendSet) ; sic ; sic = setNextItem(_G.sendSet)) {
+ pic16_aopOp(IC_LEFT(sic),sic,FALSE);
+ psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
+ pic16_freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
+ }
- for (sic = setFirstItem(_G.sendSet) ; sic ;
- sic = setNextItem(_G.sendSet)) {
- int size, offset = 0;
+ stackParms = psuedoStkPtr;
- pic16_aopOp(IC_LEFT(sic),sic,FALSE);
- size = AOP_SIZE(IC_LEFT(sic));
+ for (sic = setFirstItem(_G.sendSet) ; sic ; sic = setNextItem(_G.sendSet)) {
+ int size, offset = 0;
- while (size--) {
- DEBUGpic16_emitcode ("; ","%d left %s",__LINE__,
- pic16_AopType(AOP_TYPE(IC_LEFT(sic))));
+ pic16_aopOp(IC_LEFT(sic),sic,FALSE);
+ size = AOP_SIZE(IC_LEFT(sic));
+
+ while (size--) {
+ DEBUGpic16_emitcode ("; ","%d left %s",__LINE__,
+ pic16_AopType(AOP_TYPE(IC_LEFT(sic))));
+ DEBUGpic16_emitcode("; ", "push %d", psuedoStkPtr-1);
- if(!firstTimeThruLoop) {
- /* If this is not the first time we've been through the loop
- * then we need to save the parameter in a temporary
- * register. The last byte of the last parameter is
- * passed in W. */
- pic16_emitpcode(POC_MOVWF,popRegFromIdx(--psuedoStkPtr + pic16_Gstack_base_addr));
+ if(!firstTimeThruLoop) {
+ /* If this is not the first time we've been through the loop
+ * then we need to save the parameter in a temporary
+ * register. The last byte of the last parameter is
+ * passed in W. */
+
+#if STACK_SUPPORT
+ if(USE_STACK) {
+ pushw();
+ --psuedoStkPtr; // sanity check
+ } else {
+ pic16_emitpcode(POC_MOVWF, pic16_popRegFromIdx(--psuedoStkPtr + pic16_Gstack_base_addr));
+ }
+#else
+ pic16_emitpcode(POC_MOVWF, pic16_popRegFromIdx(--psuedoStkPtr + pic16_Gstack_base_addr));
+#endif /* STACK_SUPPORT */
+ }
+
+ firstTimeThruLoop=0;
+ mov2w (AOP(IC_LEFT(sic)), offset);
+ offset++;
+ }
+ pic16_freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
+ }
+ _G.sendSet = NULL;
}
- firstTimeThruLoop=0;
- //if (strcmp(l,fReturn[offset])) {
- mov2w (AOP(IC_LEFT(sic)), offset);
-/*
- if ( ((AOP(IC_LEFT(sic))->type) == AOP_PCODE) ||
- ((AOP(IC_LEFT(sic))->type) == AOP_LIT) )
- pic16_emitpcode(POC_MOVLW,pic16_popGet(AOP(IC_LEFT(sic)),offset));
- else
- pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(IC_LEFT(sic)),offset));
-*/
- //}
- offset++;
- }
- pic16_freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
- }
- _G.sendSet = NULL;
- }
- /* make the call */
- pic16_emitpcode(POC_CALL,pic16_popGetWithString(OP_SYMBOL(IC_LEFT(ic))->rname[0] ?
- OP_SYMBOL(IC_LEFT(ic))->rname :
- OP_SYMBOL(IC_LEFT(ic))->name));
-
- GpsuedoStkPtr=0;
- /* if we need assign a result value */
- if ((IS_ITEMP(IC_RESULT(ic)) &&
- (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
- OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
- IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
-
- _G.accInUse++;
- pic16_aopOp(IC_RESULT(ic),ic,FALSE);
- _G.accInUse--;
+ /* make the call */
+ pic16_emitpcode(POC_CALL,pic16_popGetWithString(OP_SYMBOL(IC_LEFT(ic))->rname[0] ?
+ OP_SYMBOL(IC_LEFT(ic))->rname :
+ OP_SYMBOL(IC_LEFT(ic))->name));
+
+ GpsuedoStkPtr=0;
+ /* if we need assign a result value */
+ if ((IS_ITEMP(IC_RESULT(ic)) &&
+ (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
+ OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
+ IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
+
+ _G.accInUse++;
+ pic16_aopOp(IC_RESULT(ic),ic,FALSE);
+ _G.accInUse--;
- assignResultValue(IC_RESULT(ic));
+ assignResultValue(IC_RESULT(ic));
- DEBUGpic16_emitcode ("; ","%d left %s",__LINE__,
+ DEBUGpic16_emitcode ("; ","%d left %s",__LINE__,
pic16_AopType(AOP_TYPE(IC_RESULT(ic))));
- pic16_freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
- }
+ pic16_freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
+ }
- /* adjust the stack for parameters if
- required */
- if (ic->parmBytes) {
- int i;
- if (ic->parmBytes > 3) {
- pic16_emitcode("mov","a,%s",spname);
- pic16_emitcode("add","a,#0x%02x", (- ic->parmBytes) & 0xff);
- pic16_emitcode("mov","%s,a",spname);
- } else
- for ( i = 0 ; i < ic->parmBytes ;i++)
- pic16_emitcode("dec","%s",spname);
+#if STACK_SUPPORT
+ if(USE_STACK && stackParms>0) {
+ pic16_emitpcode(POC_MOVLW, pic16_popGetLit(stackParms));
+ pic16_emitpcode(POC_ADDWF, pic16_popCopyReg( &pic16_pc_fsr1l ));
+ if(STACK_MODEL_LARGE) {
+ emitSKPNC;
+ pic16_emitpcode(POC_INCF, pic16_popCopyReg( &pic16_pc_fsr1h ));
+ }
+ }
+#endif
- }
+ /* adjust the stack for parameters if required */
+// fprintf(stderr, "%s:%d: %s ic->parmBytes= %d\n", __FILE__, __LINE__, OP_SYMBOL(IC_LEFT(ic))->name, ic->parmBytes);
- /* if register bank was saved then pop them */
- if (ic->bankSaved)
- unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
+ if (ic->parmBytes) {
+ int i;
- /* if we hade saved some registers then unsave them */
- if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
- unsaveRegisters (ic);
+ if (ic->parmBytes > 3) {
+ pic16_emitcode("mov","a,%s",spname);
+ pic16_emitcode("add","a,#0x%02x", (- ic->parmBytes) & 0xff);
+ pic16_emitcode("mov","%s,a",spname);
+ } else
+ for ( i = 0 ; i < ic->parmBytes ;i++)
+ pic16_emitcode("dec","%s",spname);
+ }
+ /* if register bank was saved then pop them */
+ if (ic->bankSaved)
+ unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
+ /* if we hade saved some registers then unsave them */
+ if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
+ unsaveRegisters (ic);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genFunction (iCode *ic)
{
- symbol *sym;
- sym_link *ftype;
+ symbol *sym;
+ sym_link *ftype;
- DEBUGpic16_emitcode ("; ***","%s %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,labelOffset,max_key);
+ DEBUGpic16_emitcode ("; ***","%s %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,labelOffset,max_key);
- labelOffset += (max_key+4);
- max_key=0;
- GpsuedoStkPtr=0;
- _G.nRegsSaved = 0;
- /* create the function header */
- pic16_emitcode(";","-----------------------------------------");
- pic16_emitcode(";"," function %s",(sym = OP_SYMBOL(IC_LEFT(ic)))->name);
- pic16_emitcode(";","-----------------------------------------");
+ labelOffset += (max_key+4);
+ max_key=0;
+ GpsuedoStkPtr=0;
+ _G.nRegsSaved = 0;
+ /* create the function header */
+ pic16_emitcode(";","-----------------------------------------");
+ pic16_emitcode(";"," function %s",(sym = OP_SYMBOL(IC_LEFT(ic)))->name);
+ pic16_emitcode(";","-----------------------------------------");
- pic16_emitcode("","%s:",sym->rname);
- pic16_addpCode2pBlock(pb,pic16_newpCodeFunction(NULL,sym->rname));
+ pic16_emitcode("","%s:",sym->rname);
+ pic16_addpCode2pBlock(pb,pic16_newpCodeFunction(moduleName,sym->rname));
- ftype = operandType(IC_LEFT(ic));
+ {
+ absSym *ab;
- /* if critical function then turn interrupts off */
- if (IFFUNC_ISCRITICAL(ftype))
- pic16_emitcode("clr","ea");
+ for(ab = setFirstItem(absSymSet); ab; ab = setNextItem(absSymSet))
+ if(strcmp(ab->name, sym->name)) {
+ pic16_pBlockConvert2Absolute(pb);
+ break;
+ }
+
+ }
- /* here we need to generate the equates for the
- register bank if required */
-#if 0
- if (FUNC_REGBANK(ftype) != rbank) {
- int i ;
-
- rbank = FUNC_REGBANK(ftype);
- for ( i = 0 ; i < pic16_nRegs ; i++ ) {
- if (strcmp(regspic16[i].base,"0") == 0)
- pic16_emitcode("","%s = 0x%02x",
- regspic16[i].dname,
- 8*rbank+regspic16[i].offset);
- else
- pic16_emitcode ("","%s = %s + 0x%02x",
- regspic16[i].dname,
- regspic16[i].base,
- 8*rbank+regspic16[i].offset);
- }
- }
-#endif
+ ftype = operandType(IC_LEFT(ic));
- /* if this is an interrupt service routine then
- save acc, b, dpl, dph */
- if (IFFUNC_ISISR(sym->type)) {
- pic16_addpCode2pBlock(pb,pic16_newpCode(POC_BRA,pic16_newpCodeOp("END_OF_INTERRUPT+2",PO_STR)));
- pic16_emitpcodeNULLop(POC_NOP);
- pic16_emitpcodeNULLop(POC_NOP);
- pic16_emitpcodeNULLop(POC_NOP);
- pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_wsave));
- pic16_emitpcode(POC_SWAPFW, pic16_popCopyReg(&pic16_pc_status));
- pic16_emitpcode(POC_CLRF, pic16_popCopyReg(&pic16_pc_status));
- pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_ssave));
-
- pic16_pBlockConvert2ISR(pb);
-#if 0
- if (!inExcludeList("acc"))
- pic16_emitcode ("push","acc");
- if (!inExcludeList("b"))
- pic16_emitcode ("push","b");
- if (!inExcludeList("dpl"))
- pic16_emitcode ("push","dpl");
- if (!inExcludeList("dph"))
- pic16_emitcode ("push","dph");
- if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
- {
- pic16_emitcode ("push", "dpx");
- /* Make sure we're using standard DPTR */
- pic16_emitcode ("push", "dps");
- pic16_emitcode ("mov", "dps, #0x00");
- if (options.stack10bit)
- {
- /* This ISR could conceivably use DPTR2. Better save it. */
- pic16_emitcode ("push", "dpl1");
- pic16_emitcode ("push", "dph1");
- pic16_emitcode ("push", "dpx1");
- }
+ if(IFFUNC_ISNAKED(ftype)) {
+ DEBUGpic16_emitcode("; ***", "_naked function, no prologue");
+ return;
}
- /* if this isr has no bank i.e. is going to
- run with bank 0 , then we need to save more
- registers :-) */
- if (!FUNC_REGBANK(sym->type)) {
+
- /* if this function does not call any other
- function then we can be economical and
- save only those registers that are used */
- if (! IFFUNC_HASFCALL(sym->type)) {
- int i;
+ /* if critical function then turn interrupts off */
+ if (IFFUNC_ISCRITICAL(ftype))
+ pic16_emitcode("clr","ea");
- /* if any registers used */
- if (sym->regsUsed) {
- /* save the registers used */
- for ( i = 0 ; i < sym->regsUsed->size ; i++) {
- if (bitVectBitValue(sym->regsUsed,i) ||
- (pic16_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
- pic16_emitcode("push","junk");//"%s",pic16_regWithIdx(i)->dname);
- }
+ /* here we need to generate the equates for the
+ * register bank if required */
+#if 0
+ if (FUNC_REGBANK(ftype) != rbank) {
+ int i ;
+
+ rbank = FUNC_REGBANK(ftype);
+ for ( i = 0 ; i < pic16_nRegs ; i++ ) {
+ if (strcmp(regspic16[i].base,"0") == 0)
+ pic16_emitcode("","%s = 0x%02x",
+ regspic16[i].dname,
+ 8*rbank+regspic16[i].offset);
+ else
+ pic16_emitcode ("","%s = %s + 0x%02x",
+ regspic16[i].dname,
+ regspic16[i].base,
+ *rbank+regspic16[i].offset);
}
-
- } else {
- /* this function has a function call cannot
- determines register usage so we will have the
- entire bank */
- saverbank(0,ic,FALSE);
- }
}
#endif
- } else {
- /* if callee-save to be used for this function
- then save the registers being used in this function */
- if (IFFUNC_CALLEESAVES(sym->type)) {
- int i;
+
+ /* if this is an interrupt service routine then
+ * save acc, b, dpl, dph */
+ if (IFFUNC_ISISR(sym->type)) {
+ pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_wsave));
+ pic16_emitpcode(POC_SWAPFW, pic16_popCopyReg(&pic16_pc_status));
+ pic16_emitpcode(POC_CLRF, pic16_popCopyReg(&pic16_pc_status));
+ pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_ssave));
+
+ pic16_pBlockConvert2ISR(pb);
+#if 0
+ if (!inExcludeList("acc"))
+ pic16_emitcode ("push","acc");
+ if (!inExcludeList("b"))
+ pic16_emitcode ("push","b");
+ if (!inExcludeList("dpl"))
+ pic16_emitcode ("push","dpl");
+ if (!inExcludeList("dph"))
+ pic16_emitcode ("push","dph");
+
+ if (options.model == MODEL_FLAT24 && !inExcludeList("dpx")) {
+ pic16_emitcode ("push", "dpx");
+
+ /* Make sure we're using standard DPTR */
+ pic16_emitcode ("push", "dps");
+ pic16_emitcode ("mov", "dps, #0x00");
+ if (options.stack10bit) {
+ /* This ISR could conceivably use DPTR2. Better save it. */
+ pic16_emitcode ("push", "dpl1");
+ pic16_emitcode ("push", "dph1");
+ pic16_emitcode ("push", "dpx1");
+ }
+ }
+
+ /* if this isr has no bank i.e. is going to
+ * run with bank 0 , then we need to save more
+ * registers :-) */
+ if (!FUNC_REGBANK(sym->type)) {
+
+ /* if this function does not call any other
+ * function then we can be economical and
+ * save only those registers that are used */
+ if (! IFFUNC_HASFCALL(sym->type)) {
+ int i;
+
+ /* if any registers used */
+ if (sym->regsUsed) {
+ /* save the registers used */
+ for ( i = 0 ; i < sym->regsUsed->size ; i++) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic16_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
+ pic16_emitcode("push","junk");//"%s",pic16_regWithIdx(i)->dname);
+ }
+ }
+
+ } else {
+ /* this function has a function call cannot
+ * determines register usage so we will have the
+ * entire bank */
+ saverbank(0,ic,FALSE);
+ }
+ }
+#endif
+ } else {
+#if STACK_SUPPORT
+ /* emit code to setup stack frame if user enabled,
+ * and function is not main() */
+
+// fprintf(stderr, "function name: %s\n", sym->name);
+ if(USE_STACK && strcmp(sym->name, "main")) {
+ if(!options.ommitFramePtr || sym->regsUsed) {
+ /* setup the stack frame */
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2( &pic16_pc_fsr2l, &pic16_pc_postdec1, 0));
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2( &pic16_pc_fsr1l, &pic16_pc_fsr2l, 0));
+ if(STACK_MODEL_LARGE)
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2( &pic16_pc_fsr1h, &pic16_pc_fsr2h, 0));
+ }
+ }
+#endif
+
+ /* if callee-save to be used for this function
+ * then save the registers being used in this function */
+ if (IFFUNC_CALLEESAVES(sym->type)) {
+ int i;
- /* if any registers used */
- if (sym->regsUsed) {
- /* save the registers used */
- for ( i = 0 ; i < sym->regsUsed->size ; i++) {
- if (bitVectBitValue(sym->regsUsed,i) ||
- (pic16_ptrRegReq && (i == R0_IDX || i == R1_IDX)) ) {
- //pic16_emitcode("push","%s",pic16_regWithIdx(i)->dname);
- _G.nRegsSaved++;
- }
+// fprintf(stderr, "%s:%d function sym->regsUsed= %p\n", __FILE__, __LINE__, sym->regsUsed);
+
+ /* if any registers used */
+ if (sym->regsUsed
+#if STACK_SUPPORT
+ && USE_STACK
+#endif
+ ) {
+ /* save the registers used */
+ DEBUGpic16_emitcode("; **", "Saving used registers in stack");
+ for ( i = 0 ; i < sym->regsUsed->size ; i++) {
+ if (bitVectBitValue(sym->regsUsed,i)) {
+// fprintf(stderr, "%s:%d function %s uses register %s\n",
+// __FILE__, __LINE__, OP_SYMBOL(IC_LEFT(ic))->name,
+// pic16_regWithIdx(i)->name);
+
+ pic16_pushpCodeOpReg( PCOR(pic16_popRegFromIdx(i) ));
+// pic16_emitpcode(POC_MOVFF, pic16_popCombine2(
+// PCOR(pic16_popCopyReg( PCOR(pic16_popRegFromIdx(i)))),
+// &pic16_pc_postdec1, 0));
+ _G.nRegsSaved++;
+ }
+ }
+ }
}
- }
- }
- }
+ }
- /* set the register bank to the desired value */
- if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type)) {
- pic16_emitcode("push","psw");
- pic16_emitcode("mov","psw,#0x%02x",(FUNC_REGBANK(sym->type) << 3)&0x00ff);
- }
- if (IFFUNC_ISREENT(sym->type) || options.stackAuto) {
+
+#if 0
+ if (IFFUNC_ISREENT(sym->type) || options.stackAuto) {
- if (options.useXstack) {
- pic16_emitcode("mov","r0,%s",spname);
- pic16_emitcode("mov","a,_bp");
- pic16_emitcode("movx","@r0,a");
- pic16_emitcode("inc","%s",spname);
- }
- else
- {
- /* set up the stack */
- pic16_emitcode ("push","_bp"); /* save the callers stack */
+ if (options.useXstack) {
+ pic16_emitcode("mov","r0,%s",spname);
+ pic16_emitcode("mov","a,_bp");
+ pic16_emitcode("movx","@r0,a");
+ pic16_emitcode("inc","%s",spname);
+ } else {
+ /* set up the stack */
+ pic16_emitcode ("push","_bp"); /* save the callers stack */
+ }
+ pic16_emitcode ("mov","_bp,%s",spname);
}
- pic16_emitcode ("mov","_bp,%s",spname);
- }
-
- /* adjust the stack for the function */
- if (sym->stack) {
+#endif
+ DEBUGpic16_emitcode("; ", "need to adjust stack = %d", sym->stack);
- int i = sym->stack;
- if (i > 256 )
- werror(W_STACK_OVERFLOW,sym->name);
+ /* adjust the stack for the function */
+ if (sym->stack) {
+ int i = sym->stack;
- if (i > 3 && sym->recvSize < 4) {
+ if (i > 127 )
+ werror(W_STACK_OVERFLOW,sym->name);
- pic16_emitcode ("mov","a,sp");
- pic16_emitcode ("add","a,#0x%02x",((char)sym->stack & 0xff));
- pic16_emitcode ("mov","sp,a");
-
+ if (i > 3 && sym->recvSize < 4) {
+ pic16_emitcode ("mov","a,sp");
+ pic16_emitcode ("add","a,#0x%02x",((char)sym->stack & 0xff));
+ pic16_emitcode ("mov","sp,a");
+ } else
+ while(i--)
+ pic16_emitcode("inc","sp");
}
- else
- while(i--)
- pic16_emitcode("inc","sp");
- }
- if (sym->xstack) {
-
- pic16_emitcode ("mov","a,_spx");
- pic16_emitcode ("add","a,#0x%02x",((char)sym->xstack & 0xff));
- pic16_emitcode ("mov","_spx,a");
- }
+ if (sym->xstack) {
+ DEBUGpic16_emitcode("; ", "%s", __FUNCTION__);
+ pic16_emitcode ("mov","a,_spx");
+ pic16_emitcode ("add","a,#0x%02x",((char)sym->xstack & 0xff));
+ pic16_emitcode ("mov","_spx,a");
+ }
+
}
/*-----------------------------------------------------------------*/
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(IFFUNC_ISNAKED(sym->type)) {
+ DEBUGpic16_emitcode("; ***", "_naked function, no epilogue");
+ return;
+ }
+
+#if 0
if (IFFUNC_ISREENT(sym->type) || options.stackAuto)
{
pic16_emitcode ("mov","%s,_bp",spname);
}
+#endif
/* if use external stack but some variables were
added to the local stack then decrement the
}
+#if 0
if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)) {
if (options.useXstack) {
pic16_emitcode("mov","r0,%s",spname);
pic16_emitcode ("pop","_bp");
}
}
+#endif
/* restore the register bank */
if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type))
_G.debugLine = 0;
}
- pic16_emitcode ("reti","");
+// pic16_emitcode ("reti","");
pic16_emitpcode(POC_CLRF, pic16_popCopyReg(&pic16_pc_status));
pic16_emitpcode(POC_SWAPFW, pic16_popCopyReg(&pic16_pc_ssave));
pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_status));
pic16_emitpcode(POC_SWAPF, pic16_popCopyReg(&pic16_pc_wsave));
pic16_emitpcode(POC_SWAPFW, pic16_popCopyReg(&pic16_pc_wsave));
+
+#if 0
pic16_addpCode2pBlock(pb,pic16_newpCodeLabel("END_OF_INTERRUPT",-1));
+#endif
pic16_emitpcodeNULLop(POC_RETFIE);
if (IFFUNC_ISCRITICAL(sym->type))
pic16_emitcode("setb","ea");
- if (IFFUNC_CALLEESAVES(sym->type)) {
- int i;
-
- /* if any registers used */
- if (sym->regsUsed) {
+ /* if any registers used */
+ if (sym->regsUsed
+#if STACK_SUPPORT
+ && USE_STACK
+#endif
+ ) {
+ int i;
/* save the registers used */
- for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
- if (bitVectBitValue(sym->regsUsed,i) ||
- (pic16_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
- pic16_emitcode("pop","junk");//"%s",pic16_regWithIdx(i)->dname);
+ DEBUGpic16_emitcode("; **", "Restoring used registers from stack");
+ for ( i = sym->regsUsed->size; i >= 0; i--) {
+ if (bitVectBitValue(sym->regsUsed,i)) {
+// fprintf(stderr, "%s:%d function %s uses register %s\n",
+// __FILE__, __LINE__, OP_SYMBOL(IC_LEFT(ic))->name,
+// pic16_regWithIdx(i)->name);
+
+ pic16_emitpcode(POC_MOVFF, pic16_popCombine2(
+ &pic16_pc_preinc1,
+ PCOR(pic16_popCopyReg( PCOR(pic16_popRegFromIdx(i)))), 0));
+ }
}
- }
-
}
+
/* if debug then send end of function */
if (currFunc) {
_G.debugLine = 0;
}
+#if STACK_SUPPORT
+ /* insert code to restore stack frame, if user enabled it
+ * and function is not main() */
+
+ if(USE_STACK && strcmp(sym->name, "main")) {
+ if(!options.ommitFramePtr || sym->regsUsed) {
+ /* restore stack frame */
+ if(STACK_MODEL_LARGE)
+ pic16_emitpcode(POC_MOVFF,
+ pic16_popCombine2( &pic16_pc_postinc1, &pic16_pc_fsr2h, 0));
+ pic16_emitpcode(POC_MOVFF,
+ pic16_popCombine2( &pic16_pc_postinc1, &pic16_pc_fsr2l, 0));
+ }
+ }
+#endif
+
pic16_emitcode ("return","");
pic16_emitpcodeNULLop(POC_RETURN);
pic16_emitcode("push","%s",l);
pushed++;
} else {
+ DEBUGpic16_emitcode(";", "%d", __LINE__);
l = pic16_aopGet(AOP(IC_LEFT(ic)),offset,
FALSE,FALSE);
+ DEBUGpic16_emitcode(";", "%d l= %s", __LINE__, l);
if (strcmp(fReturn[offset],l)) {
if( ( (AOP(IC_LEFT(ic))->type) == AOP_IMMD) ||
((AOP(IC_LEFT(ic))->type) == AOP_LIT) ) {
pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(IC_LEFT(ic)),offset));
}
if(size) {
- pic16_emitpcode(POC_MOVWF,popRegFromIdx(offset + pic16_Gstack_base_addr));
+ pic16_emitpcode(POC_MOVWF, pic16_popRegFromIdx(offset + pic16_Gstack_base_addr));
}
offset++;
}
/*-----------------------------------------------------------------*/
static void genSkip(iCode *ifx,int status_bit)
{
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(!ifx)
return;
}
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
- pic16_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ // pic16_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
} else {
break;
}
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
- pic16_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+ // pic16_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
}
rifx->generated = 1;
}
+#if 0
/*-----------------------------------------------------------------*/
/* genSkipz */
/*-----------------------------------------------------------------*/
pic16_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
}
+#endif
+
/*-----------------------------------------------------------------*/
/* genSkipCond */
/*-----------------------------------------------------------------*/
/* Sigh. thus sucks... */
if(size) {
pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left),size));
- pic16_emitpcode(POC_MOVWF, popRegFromIdx(pic16_Gstack_base_addr));
+ pic16_emitpcode(POC_MOVWF, pic16_popRegFromIdx(pic16_Gstack_base_addr));
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x80));
- pic16_emitpcode(POC_XORWF, popRegFromIdx(pic16_Gstack_base_addr));
+ pic16_emitpcode(POC_XORWF, pic16_popRegFromIdx(pic16_Gstack_base_addr));
pic16_emitpcode(POC_XORFW, pic16_popGet(AOP(right),size));
- pic16_emitpcode(POC_SUBFW, popRegFromIdx(pic16_Gstack_base_addr));
+ pic16_emitpcode(POC_SUBFW, pic16_popRegFromIdx(pic16_Gstack_base_addr));
} else {
/* Signed char comparison */
/* Special thanks to Nikolai Golovchenko for this snippet */
operand *left, *right, *result;
unsigned long lit = 0L;
int size,offset=0;
+ symbol *falselbl = newiTempLabel(NULL);
+
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(ifx && !AOP_SIZE(result)){
symbol *tlbl;
+ DEBUGpic16_emitcode ("; ***","%s %d CASE 1",__FUNCTION__,__LINE__);
/* if they are both bit variables */
if (AOP_TYPE(left) == AOP_CRY &&
((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
+ DEBUGpic16_emitcode ("; ***","%s %d CASE 11",__FUNCTION__,__LINE__);
if(AOP_TYPE(right) == AOP_LIT){
unsigned long lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
if(lit == 0L){
}
pic16_emitcode("","%05d_DS_:",tlbl->key+100+labelOffset);
- {
- /* left and right are both bit variables, result is carry */
- resolvedIfx rIfx;
+ {
+ /* left and right are both bit variables, result is carry */
+ resolvedIfx rIfx;
- resolveIfx(&rIfx,ifx);
-
- pic16_emitpcode(POC_MOVLW,pic16_popGet(AOP(left),0));
- pic16_emitpcode(POC_ANDFW,pic16_popGet(AOP(left),0));
- pic16_emitpcode(POC_BTFSC,pic16_popGet(AOP(right),0));
- pic16_emitpcode(POC_ANDLW,pic16_popGet(AOP(left),0));
- genSkipz2(&rIfx,0);
- }
+ resolveIfx(&rIfx,ifx);
+
+ pic16_emitpcode(POC_MOVLW,pic16_popGet(AOP(left),0));
+ pic16_emitpcode(POC_ANDFW,pic16_popGet(AOP(left),0));
+ pic16_emitpcode(POC_BTFSC,pic16_popGet(AOP(right),0));
+ pic16_emitpcode(POC_ANDLW,pic16_popGet(AOP(left),0));
+ genSkipz2(&rIfx,0);
+ }
} else {
- /* They're not both bit variables. Is the right a literal? */
- if(AOP_TYPE(right) == AOP_LIT) {
- lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
-
- switch(size) {
+ DEBUGpic16_emitcode ("; ***","%s %d CASE 12",__FUNCTION__,__LINE__);
- case 1:
- switch(lit & 0xff) {
- case 1:
- if ( IC_TRUE(ifx) ) {
- pic16_emitpcode(POC_DECFW,pic16_popGet(AOP(left),offset));
- emitSKPNZ;
- pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
- } else {
- pic16_emitpcode(POC_DECFSZW,pic16_popGet(AOP(left),offset));
- pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
- }
- break;
- case 0xff:
- if ( IC_TRUE(ifx) ) {
- pic16_emitpcode(POC_INCFW,pic16_popGet(AOP(left),offset));
- emitSKPNZ;
- pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
- } else {
- pic16_emitpcode(POC_INCFSZW,pic16_popGet(AOP(left),offset));
- pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
- }
- break;
- default:
- pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),offset));
- if(lit)
- pic16_emitpcode(POC_XORLW,pic16_popGetLit(lit & 0xff));
- genSkip(ifx,'z');
- }
-
-
- /* end of size == 1 */
- break;
+ /* They're not both bit variables. Is the right a literal? */
+ if(AOP_TYPE(right) == AOP_LIT) {
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
+ switch(size) {
+
+ case 1:
+ switch(lit & 0xff) {
+ case 1:
+ if ( IC_TRUE(ifx) ) {
+ pic16_emitpcode(POC_DECFW,pic16_popGet(AOP(left),offset));
+ emitSKPNZ;
+ pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
+ } else {
+ pic16_emitpcode(POC_DECFSZW,pic16_popGet(AOP(left),offset));
+ pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
+ }
+ break;
+ case 0xff:
+ if ( IC_TRUE(ifx) ) {
+ pic16_emitpcode(POC_INCFW,pic16_popGet(AOP(left),offset));
+ emitSKPNZ;
+ pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
+ } else {
+ pic16_emitpcode(POC_INCFSZW,pic16_popGet(AOP(left),offset));
+ pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
+ }
+ break;
+ default:
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),offset));
+ if(lit)
+ pic16_emitpcode(POC_XORLW,pic16_popGetLit(lit & 0xff));
+ genSkip(ifx,'z');
+ } // switch lit
+
+
+ /* end of size == 1 */
+ break;
- case 2:
- genc16bit2lit(left,lit,offset);
- genSkip(ifx,'z');
- break;
- /* end of size == 2 */
-
- default:
- /* size is 4 */
- if(lit==0) {
- pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),0));
- pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),1));
- pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),2));
- pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),3));
-
- } else {
-
- /* search for patterns that can be optimized */
-
- genc16bit2lit(left,lit,0);
- lit >>= 16;
- if(lit) {
- genSkipz(ifx,IC_TRUE(ifx) == NULL);
- //genSkip(ifx,'z');
- genc16bit2lit(left,lit,2);
- } else {
- pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),2));
- pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),3));
-
- }
-
- }
-
- genSkip(ifx,'z');
- }
+ case 2:
+ genc16bit2lit(left,lit,offset);
+ genSkip(ifx,'z');
+ break;
+ /* end of size == 2 */
+
+ default:
+ /* size is 4 */
+ if(lit==0) {
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),0));
+ pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),1));
+ pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),2));
+ pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),3));
+ genSkip(ifx,'z');
+ } else {
+ /* search for patterns that can be optimized */
+
+ genc16bit2lit(left,lit,0);
+ lit >>= 16;
+ if(lit) {
+ if(IC_TRUE(ifx))
+ emitSKPZ; // if hi word unequal
+ else
+ emitSKPNZ; // if hi word equal
+ // fail early
+ pic16_emitpcode(POC_GOTO,pic16_popGetLabel(falselbl->key));
+ genc16bit2lit(left,lit,2);
+ genSkip(ifx,'z');
+ } else {
+ pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),2));
+ pic16_emitpcode(POC_IORFW,pic16_popGet(AOP(left),3));
+ genSkip(ifx,'z');
+ }
+ }
+ pic16_emitpLabel(falselbl->key);
+ break;
+
+ } // switch size
- ifx->generated = 1;
- goto release ;
+ ifx->generated = 1;
+ goto release ;
} else if(AOP_TYPE(right) == AOP_CRY ) {
if ( IC_TRUE(ifx) ) {
emitSKPNZ;
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
- pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ // pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
} else {
emitSKPZ;
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
- pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+ // pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
}
} else {
if ( IC_TRUE(ifx) ) {
if(size) {
emitSKPZ;
+
+ DEBUGpic16_emitcode (";","\tIC_TRUE emitSKPZ");
+
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(tlbl->key));
pic16_emitcode(" goto","_%05d_DS_",tlbl->key+100+labelOffset);
} else {
emitSKPNZ;
+
+ DEBUGpic16_emitcode (";","\tIC_TRUE emitSKPNZ");
+
+
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
}
} else {
emitSKPZ;
+
+ DEBUGpic16_emitcode (";","\tnot IC_TRUE emitSKPZ");
+
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
}
/* if they are both bit variables */
if (AOP_TYPE(left) == AOP_CRY &&
((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
+ DEBUGpic16_emitcode ("; ***","%s %d CASE 2",__FUNCTION__,__LINE__);
if(AOP_TYPE(right) == AOP_LIT){
unsigned long lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
if(lit == 0L){
pic16_outBitC(result);
} else {
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic16_emitcode ("; ***","%s %d CASE 3",__FUNCTION__,__LINE__);
gencjne(left,right,result,ifx);
/*
if(ifx)
switch(lit & 0xff) {
case 0x00:
/* and'ing with 0 has clears the result */
- pic16_emitcode("clrf","%s",pic16_aopGet(AOP(result),offset,FALSE,FALSE));
+// pic16_emitcode("clrf","%s",pic16_aopGet(AOP(result),offset,FALSE,FALSE));
pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),offset));
break;
case 0xff:
int p = my_powof2( (~lit) & 0xff );
if(p>=0) {
/* only one bit is set in the literal, so use a bcf instruction */
- pic16_emitcode("bcf","%s,%d",pic16_aopGet(AOP(left),offset,FALSE,TRUE),p);
+// pic16_emitcode("bcf","%s,%d",pic16_aopGet(AOP(left),offset,FALSE,TRUE),p);
pic16_emitpcode(POC_BCF,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offset,FALSE,FALSE),p,0));
} else {
*bp++ = '\0';
if(*bp1)
- pic16_addpCode2pBlock(pb,pic16_AssembleLine(bp1));
+ pic16_addpCode2pBlock(pb, pic16_newpCodeAsmDir(bp1, NULL)); //pic16_AssembleLine(bp1, 0));
+ // inline directly, no process
bp1 = bp;
} else {
if (*bp == ':') {
}
}
if ((bp1 != bp) && *bp1)
- pic16_addpCode2pBlock(pb,pic16_AssembleLine(bp1));
+ pic16_addpCode2pBlock(pb, pic16_newpCodeAsmDir(bp1, NULL)); //pic16_AssembleLine(bp1, 0));
Safe_free(buffer);
operand *left , *result ;
int size, offset = 0, same;
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
/* rotate right with carry */
left = IC_LEFT(ic);
result=IC_RESULT(ic);
size = AOP_SIZE(result);
+ DEBUGpic16_emitcode ("; ***","%s %d size:%d same:%d",__FUNCTION__,__LINE__,size,same);
+
/* get the lsb and put it into the carry */
pic16_emitpcode(POC_RRCFW, pic16_popGet(AOP(left),size-1));
pic16_freeAsmop(result,NULL,ic,TRUE);
}
+#if 0
/*-----------------------------------------------------------------*/
/* AccRol - rotate left accumulator by known count */
/*-----------------------------------------------------------------*/
break;
}
}
+#endif
/*-----------------------------------------------------------------*/
/* AccLsh - left shift accumulator by known count */
static void AccLsh (int shCount)
{
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(shCount != 0){
- if(shCount == 1)
- pic16_emitcode("add","a,acc");
- else
- if(shCount == 2) {
- pic16_emitcode("add","a,acc");
- pic16_emitcode("add","a,acc");
- } else {
- /* rotate left accumulator */
- AccRol(shCount);
- /* and kill the lower order bits */
- pic16_emitcode("anl","a,#0x%02x", SLMask[shCount]);
- }
+ switch(shCount){
+ case 0 :
+ return;
+ break;
+ case 1 :
+ pic16_emitpcode(POC_RLNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 2 :
+ pic16_emitpcode(POC_RLNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ pic16_emitpcode(POC_RLNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 3 :
+ pic16_emitpcode(POC_SWAPFW,pic16_popCopyReg(&pic16_pc_wreg));
+ pic16_emitpcode(POC_RRNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 4 :
+ pic16_emitpcode(POC_SWAPFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 5 :
+ pic16_emitpcode(POC_SWAPFW,pic16_popCopyReg(&pic16_pc_wreg));
+ pic16_emitpcode(POC_RLNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 6 :
+ pic16_emitpcode(POC_RRNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ pic16_emitpcode(POC_RRNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 7 :
+ pic16_emitpcode(POC_RRNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
}
+ pic16_emitpcode(POC_ANDLW,pic16_popGetLit(SLMask[shCount]));
+
}
/*-----------------------------------------------------------------*/
static void AccRsh (int shCount)
{
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(shCount != 0){
- if(shCount == 1){
- CLRC;
- pic16_emitcode("rrc","a");
- } else {
- /* rotate right accumulator */
- AccRol(8 - shCount);
- /* and kill the higher order bits */
- pic16_emitcode("anl","a,#0x%02x", SRMask[shCount]);
- }
+ switch(shCount){
+ case 0 :
+ return;
+ break;
+ case 1 :
+ pic16_emitpcode(POC_RRNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 2 :
+ pic16_emitpcode(POC_RRNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ pic16_emitpcode(POC_RRNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 3 :
+ pic16_emitpcode(POC_SWAPFW,pic16_popCopyReg(&pic16_pc_wreg));
+ pic16_emitpcode(POC_RLNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 4 :
+ pic16_emitpcode(POC_SWAPFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 5 :
+ pic16_emitpcode(POC_SWAPFW,pic16_popCopyReg(&pic16_pc_wreg));
+ pic16_emitpcode(POC_RRNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 6 :
+ pic16_emitpcode(POC_RLNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ pic16_emitpcode(POC_RLNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
+ case 7 :
+ pic16_emitpcode(POC_RLNCFW,pic16_popCopyReg(&pic16_pc_wreg));
+ break;
}
+ pic16_emitpcode(POC_ANDLW,pic16_popGetLit(SRMask[shCount]));
}
#if 0
static void shiftL2Left2Result (operand *left, int offl,
operand *result, int offr, int shCount)
{
+ int same = pic16_sameRegs(AOP(result), AOP(left));
+ int i;
+ DEBUGpic16_emitcode ("; ***","%s %d shCount:%d same:%d offl:%d offr:%d",__FUNCTION__,__LINE__,shCount,same,offl,offr);
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (same && (offl != offr)) { // shift bytes
+ if (offr > offl) {
+ for(i=1;i>-1;i--) {
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(result),offl+i));
+ pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),offr+i));
+ }
+ } else { // just treat as different later on
+ same = 0;
+ }
+ }
- if(pic16_sameRegs(AOP(result), AOP(left))) {
+ if(same) {
switch(shCount) {
case 0:
break;
pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
while(--shCount) {
- emitCLRC;
- pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr));
- pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
+ emitCLRC;
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr));
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
}
break;
pic16_emitpcode(POC_XORWF, pic16_popGet(AOP(result),offr));
pic16_emitpcode(POC_ADDWF, pic16_popGet(AOP(result),offr+MSB16));
if(shCount >=5) {
- pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr));
- pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr));
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
}
break;
case 6:
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offr+MSB16));
while(--shCount) {
- emitCLRC;
- pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr));
- pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
+ emitCLRC;
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr));
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
}
break;
if(shCount == 5) {
- pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr));
- pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr));
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),offr+MSB16));
}
break;
case 6:
operand *result, int offr,
int shCount, int sign)
{
- int same=0;
-
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- same = pic16_sameRegs(AOP(result), AOP(left));
+ int same = pic16_sameRegs(AOP(result), AOP(left));
+ int i;
+ DEBUGpic16_emitcode ("; ***","%s %d shCount:%d same:%d sign:%d",__FUNCTION__,__LINE__,shCount,same,sign);
- if(same && ((offl + MSB16) == offr)){
- same=1;
- /* don't crash result[offr] */
- MOVA(pic16_aopGet(AOP(left),offl,FALSE,FALSE));
- pic16_emitcode("xch","a,%s", pic16_aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
- }
-/* else {
- movLeft2Result(left,offl, result, offr);
- MOVA(pic16_aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
+ if (same && (offl != offr)) { // shift right bytes
+ if (offr < offl) {
+ for(i=0;i<2;i++) {
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(result),offl+i));
+ pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),offr+i));
+ }
+ } else { // just treat as different later on
+ same = 0;
+ }
}
-*/
- /* a:x >> shCount (x = lsb(result))*/
-/*
- if(sign)
- AccAXRshS( pic16_aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
- else {
- AccAXRsh( pic16_aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
-*/
+
switch(shCount) {
case 0:
break;
while(--shCount) {
if(sign)
- pic16_emitpcode(POC_RLCFW,pic16_popGet(AOP(result),offr+MSB16));
+ pic16_emitpcode(POC_RLCFW,pic16_popGet(AOP(result),offr+MSB16));
else
- emitCLRC;
+ emitCLRC;
pic16_emitpcode(POC_RRCF,pic16_popGet(AOP(result),offr+MSB16));
pic16_emitpcode(POC_RRCF,pic16_popGet(AOP(result),offr));
}
operand *result, int offr, int shCount)
{
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- MOVA(pic16_aopGet(AOP(left),offl,FALSE,FALSE));
+
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),offl));
/* shift left accumulator */
AccLsh(shCount);
/* or with result */
- pic16_emitcode("orl","a,%s", pic16_aopGet(AOP(result),offr,FALSE,FALSE));
/* back to result */
- pic16_aopPut(AOP(result),"a",offr);
+ pic16_emitpcode(POC_IORWF,pic16_popGet(AOP(result),offr));
}
/*-----------------------------------------------------------------*/
operand *result, int offr, int shCount)
{
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- MOVA(pic16_aopGet(AOP(left),offl,FALSE,FALSE));
+
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),offl));
/* shift right accumulator */
AccRsh(shCount);
/* or with result */
- pic16_emitcode("orl","a,%s", pic16_aopGet(AOP(result),offr,FALSE,FALSE));
/* back to result */
- pic16_aopPut(AOP(result),"a",offr);
+ pic16_emitpcode(POC_IORWF,pic16_popGet(AOP(result),offr));
}
/*-----------------------------------------------------------------*/
{
int size;
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic16_emitcode ("; ***","%s %d shCount:%d",__FUNCTION__,__LINE__,shCount);
size = pic16_getDataSize(result);
/* if shCount >= 8 */
/*-----------------------------------------------------------------*/
/* shiftLLong - shift left one long from left to result */
-/* offl = LSB or MSB16 */
+/* offr = LSB or MSB16 */
/*-----------------------------------------------------------------*/
static void shiftLLong (operand *left, operand *result, int offr )
{
- char *l;
int size = AOP_SIZE(result);
+ int same = pic16_sameRegs(AOP(left),AOP(result));
+ int i;
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(size >= LSB+offr){
- l = pic16_aopGet(AOP(left),LSB,FALSE,FALSE);
- MOVA(l);
- pic16_emitcode("add","a,acc");
- if (pic16_sameRegs(AOP(left),AOP(result)) &&
- size >= MSB16+offr && offr != LSB )
- pic16_emitcode("xch","a,%s",
- pic16_aopGet(AOP(left),LSB+offr,FALSE,FALSE));
- else
- pic16_aopPut(AOP(result),"a",LSB+offr);
- }
+ DEBUGpic16_emitcode ("; ***","%s %d offr:%d size:%d",__FUNCTION__,__LINE__,offr,size);
- if(size >= MSB16+offr){
- if (!(pic16_sameRegs(AOP(result),AOP(left)) && size >= MSB16+offr && offr != LSB) ) {
- l = pic16_aopGet(AOP(left),MSB16,FALSE,FALSE);
- MOVA(l);
+ if (same && (offr == MSB16)) { //shift one byte
+ for(i=size-1;i>=MSB16;i--) {
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),i-1));
+ pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(left),i));
+ }
+ } else {
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),LSB+offr));
}
- pic16_emitcode("rlc","a");
- if (pic16_sameRegs(AOP(left),AOP(result)) &&
- size >= MSB24+offr && offr != LSB)
- pic16_emitcode("xch","a,%s",
- pic16_aopGet(AOP(left),MSB16+offr,FALSE,FALSE));
- else
- pic16_aopPut(AOP(result),"a",MSB16+offr);
+
+ if (size >= LSB+offr ){
+ if (same) {
+ pic16_emitpcode(POC_ADDWF,pic16_popGet(AOP(left),LSB+offr));
+ } else {
+ pic16_emitpcode(POC_ADDFW,pic16_popGet(AOP(left),LSB));
+ pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),LSB+offr));
+ }
+ }
+
+ if(size >= MSB16+offr){
+ if (same) {
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(left),MSB16+offr));
+ } else {
+ pic16_emitpcode(POC_RLCFW, pic16_popGet(AOP(left),MSB16));
+ pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),MSB16+offr));
+ }
}
if(size >= MSB24+offr){
- if (!(pic16_sameRegs(AOP(left),AOP(left)) && size >= MSB24+offr && offr != LSB)) {
- l = pic16_aopGet(AOP(left),MSB24,FALSE,FALSE);
- MOVA(l);
- }
- pic16_emitcode("rlc","a");
- if (pic16_sameRegs(AOP(left),AOP(result)) &&
- size >= MSB32+offr && offr != LSB )
- pic16_emitcode("xch","a,%s",
- pic16_aopGet(AOP(left),MSB24+offr,FALSE,FALSE));
- else
- pic16_aopPut(AOP(result),"a",MSB24+offr);
+ if (same) {
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(left),MSB24+offr));
+ } else {
+ pic16_emitpcode(POC_RLCFW, pic16_popGet(AOP(left),MSB24));
+ pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),MSB24+offr));
+ }
}
if(size > MSB32+offr){
- if (!(pic16_sameRegs(AOP(result),AOP(left)) && size >= MSB32+offr && offr != LSB)) {
- l = pic16_aopGet(AOP(left),MSB32,FALSE,FALSE);
- MOVA(l);
- }
- pic16_emitcode("rlc","a");
- pic16_aopPut(AOP(result),"a",MSB32+offr);
+ if (same) {
+ pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(left),MSB32+offr));
+ } else {
+ pic16_emitpcode(POC_RLCFW, pic16_popGet(AOP(left),MSB32));
+ pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),MSB32+offr));
+ }
}
if(offr != LSB)
- pic16_aopPut(AOP(result),zero,LSB);
+ pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),LSB));
+
}
/*-----------------------------------------------------------------*/
shiftL1Left2Result(left, LSB, result, MSB32, shCount);
else
movLeft2Result(left, LSB, result, MSB32);
- pic16_aopPut(AOP(result),zero,LSB);
- pic16_aopPut(AOP(result),zero,MSB16);
- pic16_aopPut(AOP(result),zero,MSB32);
+
+ pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),LSB));
+ pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),MSB16));
+ pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),MSB24));
+
return;
}
movLeft2Result(left, MSB16, result, MSB32);
movLeft2Result(left, LSB, result, MSB24);
}
- pic16_aopPut(AOP(result),zero,MSB16);
- pic16_aopPut(AOP(result),zero,LSB);
+ pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),LSB));
+ pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),MSB16));
return;
}
movLeft2Result(left, MSB24, result, MSB32);
movLeft2Result(left, MSB16, result, MSB24);
movLeft2Result(left, LSB, result, MSB16);
- pic16_aopPut(AOP(result),zero,LSB);
+ pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),LSB));
}
else if(shCount == 1)
shiftLLong(left, result, MSB16);
shiftL2Left2Result(left, MSB16, result, MSB24, shCount);
shiftL1Left2Result(left, LSB, result, MSB16, shCount);
shiftRLeftOrResult(left, LSB, result, MSB24, 8 - shCount);
- pic16_aopPut(AOP(result),zero,LSB);
+ pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),LSB));
}
}
}
/* 1 <= shCount <= 7 */
- else if(shCount <= 2){
+ else if(shCount <= 3)
+ {
shiftLLong(left, result, LSB);
- if(shCount == 2)
+ while(--shCount >= 1)
shiftLLong(result, result, LSB);
}
/* 3 <= shCount <= 7, optimize */
int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
int size;
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic16_emitcode ("; ***","%s %d shCount:%d",__FUNCTION__,__LINE__,shCount);
pic16_freeAsmop(right,NULL,ic,TRUE);
pic16_aopOp(left,ic,FALSE);
tlbl = newiTempLabel(NULL);
if (!pic16_sameRegs(AOP(left),AOP(result))) {
- pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left),0));
- pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
+ pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left),0));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
}
pic16_emitpcode(POC_COMFW, pic16_popGet(AOP(right),0));
pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),0));
/* offset should be 0, 1 or 3 */
- pic16_emitpcode(POC_ANDLW, pic16_popGetLit(0x07 + ((offset&3) << 3)));
+
+ pic16_emitpcode(POC_ANDLW, pic16_popGetLit((size<<3)-1));
emitSKPNZ;
pic16_emitpcode(POC_GOTO, pic16_popGetLabel(tlbl1->key));
static void genrshTwo (operand *result,operand *left,
int shCount, int sign)
{
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic16_emitcode ("; ***","%s %d shCount:%d",__FUNCTION__,__LINE__,shCount);
/* if shCount >= 8 */
if (shCount >= 8) {
shCount -= 8 ;
static void shiftRLong (operand *left, int offl,
operand *result, int sign)
{
+ int size = AOP_SIZE(result);
+ int same = pic16_sameRegs(AOP(left),AOP(result));
+ int i;
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(!sign)
- pic16_emitcode("clr","c");
- MOVA(pic16_aopGet(AOP(left),MSB32,FALSE,FALSE));
+
+ DEBUGpic16_emitcode ("; ***","%s %d offl:%d size:%d",__FUNCTION__,__LINE__,offl,size);
+
+ if (same && (offl == MSB16)) { //shift one byte right
+ for(i=MSB16;i<size;i++) {
+ pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),i));
+ pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(left),i-1));
+ }
+ }
+
if(sign)
- pic16_emitcode("mov","c,acc.7");
- pic16_emitcode("rrc","a");
- pic16_aopPut(AOP(result),"a",MSB32-offl);
- if(offl == MSB16)
+ pic16_emitpcode(POC_RLCFW,pic16_popGet(AOP(left),MSB32));
+ else
+ emitCLRC;
+
+ if (same) {
+ if (offl == LSB)
+ pic16_emitpcode(POC_RRCF, pic16_popGet(AOP(left),MSB32));
+ } else {
+ pic16_emitpcode(POC_RRCFW, pic16_popGet(AOP(left),MSB32));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),MSB32-offl));
+ }
+
+ if(offl == MSB16) {
/* add sign of "a" */
pic16_addSign(result, MSB32, sign);
+ }
- MOVA(pic16_aopGet(AOP(left),MSB24,FALSE,FALSE));
- pic16_emitcode("rrc","a");
- pic16_aopPut(AOP(result),"a",MSB24-offl);
-
- MOVA(pic16_aopGet(AOP(left),MSB16,FALSE,FALSE));
- pic16_emitcode("rrc","a");
- pic16_aopPut(AOP(result),"a",MSB16-offl);
+ if (same) {
+ pic16_emitpcode(POC_RRCF, pic16_popGet(AOP(left),MSB24));
+ } else {
+ pic16_emitpcode(POC_RRCFW, pic16_popGet(AOP(left),MSB24));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),MSB24-offl));
+ }
+
+ if (same) {
+ pic16_emitpcode(POC_RRCF, pic16_popGet(AOP(left),MSB16));
+ } else {
+ pic16_emitpcode(POC_RRCFW, pic16_popGet(AOP(left),MSB16));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),MSB16-offl));
+ }
- if(offl == LSB){
- MOVA(pic16_aopGet(AOP(left),LSB,FALSE,FALSE));
- pic16_emitcode("rrc","a");
- pic16_aopPut(AOP(result),"a",LSB);
- }
+ if (same) {
+ pic16_emitpcode(POC_RRCF, pic16_popGet(AOP(left),LSB));
+ } else {
+ if(offl == LSB){
+ pic16_emitpcode(POC_RRCFW, pic16_popGet(AOP(left),LSB));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),LSB));
+ }
+ }
}
/*-----------------------------------------------------------------*/
movLeft2Result(left, MSB32, result, MSB24);
pic16_addSign(result, MSB32, sign);
}
- else{
+ else{ //shcount >= 2
shiftR2Left2Result(left, MSB16, result, LSB, shCount, 0);
shiftLLeftOrResult(left, MSB32, result, MSB16, 8 - shCount);
/* the last shift is signed */
int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
int lsize,res_size;
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
pic16_freeAsmop(right,NULL,ic,TRUE);
pic16_aopOp(left,ic,FALSE);
pic16_aopOp(result,ic,FALSE);
+ DEBUGpic16_emitcode ("; ***","%s %d shCount:%d result:%d left:%d",__FUNCTION__,__LINE__,shCount,AOP_SIZE(result),AOP_SIZE(left));
+
#if VIEW_SIZE
pic16_emitcode("; shift right ","result %d, left %d",AOP_SIZE(result),
AOP_SIZE(left));
static void genRightShift (iCode *ic)
{
operand *right, *left, *result;
- sym_link *retype ;
+ sym_link *letype ;
int size, offset;
char *l;
symbol *tlbl, *tlbl1 ;
/* if signed then we do it the hard way preserve the
sign bit moving it inwards */
- retype = getSpec(operandType(IC_RESULT(ic)));
+ letype = getSpec(operandType(IC_LEFT(ic)));
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (!SPEC_USIGN(retype)) {
+ if (!SPEC_USIGN(letype)) {
genSignedRightShift (ic);
return ;
}
pic16_aopOp (result,ic,FALSE);
/* if bitfield then unpack the bits */
- if (IS_BITVAR(retype))
+ if (IS_BITFIELD(retype))
genUnpackBits (result,rname,POINTER);
else {
/* we have can just get the values */
pic16_aopOp (result,ic,FALSE);
/* if bitfield then unpack the bits */
- if (IS_BITVAR(retype))
+ if (IS_BITFIELD(retype))
genUnpackBits (result,rname,PPOINTER);
else {
/* we have can just get the values */
pic16_aopOp(result,ic,FALSE);
/* if bit then unpack */
- if (IS_BITVAR(retype))
+ if (IS_BITFIELD(retype))
genUnpackBits(result,"dptr",FPOINTER);
else {
size = AOP_SIZE(result);
pic16_aopOp(result,ic,FALSE);
/* if bit then unpack */
- if (IS_BITVAR(retype))
+ if (IS_BITFIELD(retype))
genUnpackBits(result,"dptr",CPOINTER);
else {
size = AOP_SIZE(result);
/* so dptr know contains the address */
/* if bit then unpack */
- //if (IS_BITVAR(retype))
- // genUnpackBits(result,"dptr",GPOINTER);
+ if (IS_BITFIELD(retype))
+ genUnpackBits(result,"BAD",GPOINTER);
release:
pic16_freeAsmop(left,NULL,ic,TRUE);
poc = ( (AOP_TYPE(left) == AOP_PCODE) ? POC_MOVLW : POC_MOVFW);
+ /* this performs a goto to the specified address -- Why not to use pointer? -- VR */
pic16_emitpcode(poc,pic16_popGet(AOP(left),1));
pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_pclath));
pic16_emitpcode(poc,pic16_popGet(AOP(left),0));
type = operandType(left);
etype = getSpec(type);
+#if 0
if (IS_PTR_CONST(type))
+#else
+ if (IS_CODEPTR(type))
+#endif
DEBUGpic16_emitcode ("; ***","%d - const pointer",__LINE__);
/* if left is of type of pointer then it is simple */
break;
case GPOINTER:
+#if 0
if (IS_PTR_CONST(type))
genConstPointerGet (left,result,ic);
else
+#endif
genGenPointerGet (left,result,ic);
break;
}
while (size--) {
if (offset) {
sprintf(buffer,"(%s + %d)",l,offset);
- fprintf(stderr,"oops %s\n",buffer);
+ fprintf(stderr,"%s:%d: oops %s\n",__FILE__, __LINE__, buffer);
} else
sprintf(buffer,"%s",l);
pic16_emitcode("movwf","%s",buffer);
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(lit&0xff));
- //pic16_emitpcode(POC_MOVWF, popRegFromString(buffer));
+ //pic16_emitpcode(POC_MOVWF, pic16_popRegFromString(buffer));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
} else {
pic16_emitcode("clrf","%s",buffer);
- //pic16_emitpcode(POC_CLRF, popRegFromString(buffer));
+ //pic16_emitpcode(POC_CLRF, pic16_popRegFromString(buffer));
pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),0));
}
}else {
pic16_emitcode("movwf","%s",buffer);
pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),offset));
- //pic16_emitpcode(POC_MOVWF, popRegFromString(buffer));
+ //pic16_emitpcode(POC_MOVWF, pic16_popRegFromString(buffer));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
}
goto release;
}// else
- // rname = pic16_aopGet(AOP(result),0,FALSE,FALSE);
+// rname = pic16_aopGet(AOP(result),0,FALSE,FALSE);
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
/* if bitfield then unpack the bits */
- if (IS_BITVAR(retype)) {
+ if (IS_BITFIELD(retype)) {
werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
"The programmer is obviously confused");
- //genPackBits (retype,right,rname,POINTER);
+// genPackBits (retype,right,"BAD",POINTER);
exit(1);
}
else {
pic16_aopOp (right,ic,FALSE);
/* if bitfield then unpack the bits */
- if (IS_BITVAR(retype))
+ if (IS_BITFIELD(retype))
genPackBits (retype,right,rname,PPOINTER);
else {
/* we have can just get the values */
pic16_aopOp(right,ic,FALSE);
/* if bit then unpack */
- if (IS_BITVAR(retype))
+ if (IS_BITFIELD(retype))
genPackBits(retype,right,"dptr",FPOINTER);
else {
size = AOP_SIZE(right);
/* hack hack! see if this the FSR. If so don't load W */
if(AOP_TYPE(right) != AOP_ACC) {
+// pic16_emitpcode(POC_MOVFF, pic16_popGet2(AOP(result), pic16_popCopyReg(&pic16_pc_fsr0), 0));
pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(result),0));
pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_fsr0));
/* if bit then unpack */
- if (IS_BITVAR(retype))
+ if (IS_BITFIELD(retype))
genPackBits(retype,right,"dptr",GPOINTER);
else {
size = AOP_SIZE(right);
/*-----------------------------------------------------------------*/
/* genAddrOf - generates code for address of */
/*-----------------------------------------------------------------*/
+#if 0
static void genAddrOf (iCode *ic)
{
operand *right, *result, *left;
size = AOP_SIZE(IC_RESULT(ic));
offset = 0;
+
while (size--) {
pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(left),offset));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset));
offset++;
}
+
pic16_freeAsmop(left,NULL,ic,FALSE);
pic16_freeAsmop(result,NULL,ic,TRUE);
}
+#else /* new genAddrOf */
+
+static void genAddrOf (iCode *ic)
+{
+ operand *result, *left;
+ int size;
+ symbol *sym; // = OP_SYMBOL(IC_LEFT(ic));
+ pCodeOp *pcop0, *pcop1, *pcop2;
+
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ pic16_aopOp((left=IC_LEFT(ic)), ic, FALSE);
+ pic16_aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ sym = OP_SYMBOL( left );
+
+ size = AOP_SIZE(IC_RESULT(ic));
+
+ if(pic16_debug_verbose) {
+ fprintf(stderr, "%s:%d %s symbol %s , codespace=%d\n",
+ __FILE__, __LINE__, __FUNCTION__, sym->name, IN_CODESPACE( SPEC_OCLS(sym->etype)));
+ }
+
+ /* Assume that what we want the address of is in data space
+ * since there is no stack on the PIC, yet! -- VR */
+ /* low */
+ pcop0 = PCOP(pic16_newpCodeOpImmd(sym->rname, 0, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
+
+ /* high */
+ pcop1 = PCOP(pic16_newpCodeOpImmd(sym->rname, 1, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
+
+ /* upper */
+ pcop2 = PCOP(pic16_newpCodeOpImmd(sym->rname, 2, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
+
+
+ if (size == 3) {
+ pic16_emitpcode(POC_MOVLW, pcop0);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result), 0));
+ pic16_emitpcode(POC_MOVLW, pcop1);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result), 1));
+ pic16_emitpcode(POC_MOVLW, pcop2);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result), 2));
+ } else
+ if (size == 2) {
+ pic16_emitpcode(POC_MOVLW, pcop0);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
+ pic16_emitpcode(POC_MOVLW, pcop1);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),1));
+ } else {
+ pic16_emitpcode(POC_MOVLW, pcop0);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
+ }
+
+ pic16_freeAsmop(result,NULL,ic,TRUE);
+ pic16_freeAsmop(left, NULL, ic, FALSE);
+}
+
+#endif /* new genAddrOf */
+
#if 0
/*-----------------------------------------------------------------*/
/* genFarFarAssign - assignment when both are in far space */
right = IC_RIGHT(ic) ;
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
+
/* if they are the same */
if (operandsEqu (IC_RESULT(ic),IC_RIGHT(ic)))
return ;
/* if the result is a bit */
if (AOP_TYPE(result) == AOP_CRY) {
-
/* if the right size is a literal then
we know what the value is */
if (AOP_TYPE(right) == AOP_LIT) {
if(AOP_TYPE(right) == AOP_LIT)
lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+/* VR - What is this?! */
if( AOP_TYPE(right) == AOP_DIR && (AOP_TYPE(result) == AOP_REG) && size==1) {
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(aopIdx(AOP(result),0) == 4) {
}
} else {
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),offset));
- pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset));
+
+#if 1
+ /* This is a hack to turn MOVFW/MOVWF pairs to MOVFF command. It
+ normally should work, but mind that the W register live range
+ is not checked, so if the code generator assumes that the W
+ is already loaded after such a pair, wrong code will be generated.
+
+ Checking the live range is the next step.
+ This is experimental code yet and has not been fully tested yet.
+ USE WITH CARE. Revert to old code by setting 0 to the condition above.
+ Vangelis Rokas 030603 (vrokas@otenet.gr) */
+
+ pic16_emitpcode(POC_MOVFF, pic16_popGet2(AOP(right), AOP(result), offset));
+#else
+ /* This is the old code, which is assumed(?!) that works fine(!?) */
+
+ pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),offset));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset));
+#endif
}
offset++;
}
/*-----------------------------------------------------------------*/
-/* genJumpTab - genrates code for jump table */
+/* genJumpTab - generates code for jump table */
/*-----------------------------------------------------------------*/
static void genJumpTab (iCode *ic)
{
/*-----------------------------------------------------------------*/
static void genCast (iCode *ic)
{
- operand *result = IC_RESULT(ic);
- sym_link *ctype = operandType(IC_LEFT(ic));
- sym_link *rtype = operandType(IC_RIGHT(ic));
- operand *right = IC_RIGHT(ic);
- int size, offset ;
-
- DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if they are equivalent then do nothing */
- if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
- return ;
-
- pic16_aopOp(right,ic,FALSE) ;
- pic16_aopOp(result,ic,FALSE);
-
- DEBUGpic16_pic16_AopType(__LINE__,NULL,right,result);
-
- /* if the result is a bit */
- if (AOP_TYPE(result) == AOP_CRY) {
- /* if the right size is a literal then
- we know what the value is */
- DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
- if (AOP_TYPE(right) == AOP_LIT) {
-
- pic16_emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
- pic16_popGet(AOP(result),0));
+ operand *result = IC_RESULT(ic);
+ sym_link *ctype = operandType(IC_LEFT(ic));
+ sym_link *rtype = operandType(IC_RIGHT(ic));
+ operand *right = IC_RIGHT(ic);
+ int size, offset ;
- if (((int) operandLitValue(right)))
- pic16_emitcode("bsf","(%s >> 3), (%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- else
- pic16_emitcode("bcf","(%s >> 3), (%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
+ DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if they are equivalent then do nothing */
+ if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
+ return ;
- goto release;
- }
+ pic16_aopOp(right,ic,FALSE) ;
+ pic16_aopOp(result,ic,FALSE);
- /* the right is also a bit variable */
- if (AOP_TYPE(right) == AOP_CRY) {
+ DEBUGpic16_pic16_AopType(__LINE__,NULL,right,result);
- emitCLRC;
- pic16_emitpcode(POC_BTFSC, pic16_popGet(AOP(right),0));
+ /* if the result is a bit */
+ if (AOP_TYPE(result) == AOP_CRY) {
+
+ /* if the right size is a literal then
+ * we know what the value is */
+ DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (AOP_TYPE(right) == AOP_LIT) {
+ pic16_emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
+ pic16_popGet(AOP(result),0));
+
+ if (((int) operandLitValue(right)))
+ pic16_emitcode("bsf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ else
+ pic16_emitcode("bcf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ goto release;
+ }
- pic16_emitcode("clrc","");
- pic16_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
- pic16_aopPut(AOP(result),"c",0);
- goto release ;
- }
+ /* the right is also a bit variable */
+ if (AOP_TYPE(right) == AOP_CRY) {
+ emitCLRC;
+ pic16_emitpcode(POC_BTFSC, pic16_popGet(AOP(right),0));
+
+ pic16_emitcode("clrc","");
+ pic16_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ pic16_aopPut(AOP(result),"c",0);
+ goto release ;
+ }
- /* we need to or */
- if (AOP_TYPE(right) == AOP_REG) {
- pic16_emitpcode(POC_BCF, pic16_popGet(AOP(result),0));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),0,0));
- pic16_emitpcode(POC_BSF, pic16_popGet(AOP(result),0));
+ /* we need to or */
+ if (AOP_TYPE(right) == AOP_REG) {
+ pic16_emitpcode(POC_BCF, pic16_popGet(AOP(result),0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),0,0));
+ pic16_emitpcode(POC_BSF, pic16_popGet(AOP(result),0));
+ }
+ pic16_toBoolean(right);
+ pic16_aopPut(AOP(result),"a",0);
+ goto release ;
}
- pic16_toBoolean(right);
- pic16_aopPut(AOP(result),"a",0);
- goto release ;
- }
-
- if ((AOP_TYPE(right) == AOP_CRY) && (AOP_TYPE(result) == AOP_REG)) {
- int offset = 1;
- size = AOP_SIZE(result);
- DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ if ((AOP_TYPE(right) == AOP_CRY) && (AOP_TYPE(result) == AOP_REG)) {
+ int offset = 1;
- pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),0));
- pic16_emitpcode(POC_BTFSC, pic16_popGet(AOP(right),0));
- pic16_emitpcode(POC_INCF, pic16_popGet(AOP(result),0));
-
- while (size--)
- pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset++));
+ size = AOP_SIZE(result);
- goto release;
- }
+ DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if they are the same size : or less */
- if (AOP_SIZE(result) <= AOP_SIZE(right)) {
-
- /* if they are in the same place */
- if (pic16_sameRegs(AOP(right),AOP(result)))
- goto release;
+ pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),0));
+ pic16_emitpcode(POC_BTFSC, pic16_popGet(AOP(right),0));
+ pic16_emitpcode(POC_INCF, pic16_popGet(AOP(result),0));
- DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
- if (IS_PTR_CONST(rtype))
- DEBUGpic16_emitcode ("; ***","%d - right is const pointer",__LINE__);
- if (IS_PTR_CONST(operandType(IC_RESULT(ic))))
- DEBUGpic16_emitcode ("; ***","%d - result is const pointer",__LINE__);
+ while (size--)
+ pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset++));
- if ((AOP_TYPE(right) == AOP_PCODE) && AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
- pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right),0));
- pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
- pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right),1));
- pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),1));
- if(AOP_SIZE(result) <2)
- fprintf(stderr,"%d -- result is not big enough to hold a ptr\n",__LINE__);
+ goto release;
+ }
- } else {
+ /* if they are the same size : or less */
+ if (AOP_SIZE(result) <= AOP_SIZE(right)) {
- /* if they in different places then copy */
- size = AOP_SIZE(result);
- offset = 0 ;
- while (size--) {
- pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),offset));
- pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset));
+ /* if they are in the same place */
+ if (pic16_sameRegs(AOP(right),AOP(result)))
+ goto release;
- //pic16_aopPut(AOP(result),
- // pic16_aopGet(AOP(right),offset,FALSE,FALSE),
- // offset);
+ DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+#if 0
+ if (IS_PTR_CONST(rtype))
+#else
+ if (IS_CODEPTR(rtype))
+#endif
+ DEBUGpic16_emitcode ("; ***","%d - right is const pointer",__LINE__);
- offset++;
- }
- }
- goto release;
- }
+#if 0
+ if (IS_PTR_CONST(operandType(IC_RESULT(ic))))
+#else
+ if (IS_CODEPTR(operandType(IC_RESULT(ic))))
+#endif
+ DEBUGpic16_emitcode ("; ***","%d - result is const pointer",__LINE__);
+#if 0
+ if(AOP_TYPE(right) == AOP_IMMD) {
+ pCodeOp *pcop0, *pcop1, *pcop2;
+ symbol *sym = OP_SYMBOL( right );
+
+ size = AOP_SIZE(result);
+ /* low */
+ pcop0 = PCOP(pic16_newpCodeOpImmd(sym->rname, 0, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
+ /* high */
+ pcop1 = PCOP(pic16_newpCodeOpImmd(sym->rname, 1, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
+ /* upper */
+ pcop2 = PCOP(pic16_newpCodeOpImmd(sym->rname, 2, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
+
+ if (size == 3) {
+ pic16_emitpcode(POC_MOVLW, pcop0);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result), 0));
+ pic16_emitpcode(POC_MOVLW, pcop1);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result), 1));
+ pic16_emitpcode(POC_MOVLW, pcop2);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result), 2));
+ } else
+ if (size == 2) {
+ pic16_emitpcode(POC_MOVLW, pcop0);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
+ pic16_emitpcode(POC_MOVLW, pcop1);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),1));
+ } else {
+ pic16_emitpcode(POC_MOVLW, pcop0);
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
+ }
+ } else
+#endif
+ if ((AOP_TYPE(right) == AOP_PCODE) && AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
+ pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right),0));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
+ pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right),1));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),1));
+ if(AOP_SIZE(result) <2)
+ fprintf(stderr,"%d -- result is not big enough to hold a ptr\n",__LINE__);
+ } else {
+ /* if they in different places then copy */
+ size = AOP_SIZE(result);
+ offset = 0 ;
+ while (size--) {
+ pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),offset));
+ pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset));
+ offset++;
+ }
+ }
+ goto release;
+ }
- /* if the result is of type pointer */
- if (IS_PTR(ctype)) {
+ /* if the result is of type pointer */
+ if (IS_PTR(ctype)) {
+ int p_type;
+ sym_link *type = operandType(right);
+ sym_link *etype = getSpec(type);
- int p_type;
- sym_link *type = operandType(right);
- sym_link *etype = getSpec(type);
- DEBUGpic16_emitcode("; ***","%s %d - pointer cast",__FUNCTION__,__LINE__);
+ DEBUGpic16_emitcode("; ***","%s %d - pointer cast",__FUNCTION__,__LINE__);
- /* pointer to generic pointer */
- if (IS_GENPTR(ctype)) {
- char *l = zero;
+ /* pointer to generic pointer */
+ if (IS_GENPTR(ctype)) {
+ char *l = zero;
- if (IS_PTR(type))
- p_type = DCL_TYPE(type);
- else {
+ if (IS_PTR(type))
+ p_type = DCL_TYPE(type);
+ else {
/* we have to go by the storage class */
p_type = PTR_TYPE(SPEC_OCLS(etype));
while (size--)
pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset++));
} else {
- /* we need to extend the sign :{ */
+ /* we need to extend the sign :( */
if(size == 1) {
/* Save one instruction of casting char to int */
/*-----------------------------------------------------------------*/
static void genReceive (iCode *ic)
{
- DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (isOperandInFarSpace(IC_RESULT(ic)) &&
- ( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
- IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
+ if (isOperandInFarSpace(IC_RESULT(ic)) &&
+ ( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
+ IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
- int size = getSize(operandType(IC_RESULT(ic)));
- int offset = pic16_fReturnSizePic - size;
- while (size--) {
- pic16_emitcode ("push","%s", (strcmp(fReturn[pic16_fReturnSizePic - offset - 1],"a") ?
- fReturn[pic16_fReturnSizePic - offset - 1] : "acc"));
- offset++;
- }
- pic16_aopOp(IC_RESULT(ic),ic,FALSE);
- size = AOP_SIZE(IC_RESULT(ic));
- offset = 0;
- while (size--) {
- pic16_emitcode ("pop","acc");
- pic16_aopPut (AOP(IC_RESULT(ic)),"a",offset++);
- }
-
- } else {
- _G.accInUse++;
- pic16_aopOp(IC_RESULT(ic),ic,FALSE);
- _G.accInUse--;
- assignResultValue(IC_RESULT(ic));
- }
+ int size = getSize(operandType(IC_RESULT(ic)));
+ int offset = pic16_fReturnSizePic - size;
- pic16_freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ while (size--) {
+ pic16_emitcode ("push","%s", (strcmp(fReturn[pic16_fReturnSizePic - offset - 1],"a") ?
+ fReturn[pic16_fReturnSizePic - offset - 1] : "acc"));
+ offset++;
+ }
+
+ DEBUGpic16_emitcode ("; ***","1 %s %d",__FUNCTION__,__LINE__);
+
+ pic16_aopOp(IC_RESULT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_RESULT(ic));
+ offset = 0;
+ while (size--) {
+ pic16_emitcode ("pop","acc");
+ pic16_aopPut (AOP(IC_RESULT(ic)),"a",offset++);
+ }
+ } else {
+ DEBUGpic16_emitcode ("; ***","2 %s %d",__FUNCTION__,__LINE__);
+
+ _G.accInUse++;
+ pic16_aopOp(IC_RESULT(ic),ic,FALSE);
+ _G.accInUse--;
+ assignResultValue(IC_RESULT(ic));
+ }
+
+ pic16_freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDummyRead - generate code for dummy read of volatiles */
+/*-----------------------------------------------------------------*/
+static void
+genDummyRead (iCode * ic)
+{
+ pic16_emitcode ("; genDummyRead","");
+ pic16_emitcode ("; not implemented","");
+
+ ic = ic;
}
/*-----------------------------------------------------------------*/
pb = pic16_newpCodeChain(GcurMemmap,0,pic16_newpCodeCharP("; Starting pCode block"));
pic16_addpBlock(pb);
+#if 0
/* if debug information required */
- if (options.debug && currFunc) {
+ if (options.debug && currFunc) {
if (currFunc) {
cdbSymbol(currFunc,cdbFile,FALSE,TRUE);
_G.debugLine = 1;
_G.debugLine = 0;
}
}
+#endif
+// dumpiCode(lic);
for (ic = lic ; ic ; ic = ic->next ) {
- DEBUGpic16_emitcode(";ic","");
+// fprintf(stderr, "; VR = %c %x\n", ic->op, ic->op);
+// DEBUGpic16_emitcode("; VR", "");
+ DEBUGpic16_emitcode(";ic ", "\t%c 0x%x",ic->op, ic->op);
if ( cln != ic->lineno ) {
if ( options.debug ) {
_G.debugLine = 1;
ic->level,ic->block);
_G.debugLine = 0;
}
- /*
- pic16_emitcode("#CSRC","%s %d",FileBaseName(ic->filename),ic->lineno);
- pic16_emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
- printCLine(ic->filename, ic->lineno));
- */
- pic16_addpCode2pBlock(pb,
- pic16_newpCodeCSource(ic->lineno,
- ic->filename,
- printCLine(ic->filename, ic->lineno)));
+
+ if(!options.noCcodeInAsm) {
+ pic16_addpCode2pBlock(pb,
+ pic16_newpCodeCSource(ic->lineno, ic->filename,
+ printCLine(ic->filename, ic->lineno)));
+ }
cln = ic->lineno ;
}
+
+ if(options.iCodeInAsm) {
+ /* insert here code to print iCode as comment */
+ pic16_emitcomment("; ic:%d: %s", ic->seq, printILine(ic));
+ }
+
/* if the result is marked as
spilt and rematerializable or code for
this has already been generated then
/* depending on the operation */
switch (ic->op) {
case '!' :
- genNot(ic);
+ pic16_genNot(ic);
break;
case '~' :
- genCpl(ic);
+ pic16_genCpl(ic);
break;
case UNARYMINUS:
addSet(&_G.sendSet,ic);
break;
+ case DUMMY_READ_VOLATILE:
+ genDummyRead (ic);
+ break;
+
default :
ic = ic;
}
}
-
- /* now we are ready to call the
+
+ /* now we are ready to call the
peep hole optimizer */
if (!options.nopeep) {
peepHole (&lineHead);
return;
}
+
projects / fw / sdcc / blobdiff