X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fpic16%2Fgen.c;h=a92822ec246793a43800ede72161447bab99ca4f;hb=986baccff019b926baac90622bd81772f9b47001;hp=174bca23be9111fdbda6990d0dffad7a96d726b6;hpb=43082e9855dafdd47d0dc6649c63e47ad7a842c0;p=fw%2Fsdcc diff --git a/src/pic16/gen.c b/src/pic16/gen.c index 174bca23..a92822ec 100644 --- a/src/pic16/gen.c +++ b/src/pic16/gen.c @@ -42,15 +42,18 @@ #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 *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); @@ -183,6 +186,35 @@ void DEBUGpic16_pic16_AopTypeSign(int line_no, operand *left, operand *right, op } +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; @@ -218,7 +250,6 @@ void DEBUGpic16_emitcode (char *inst,char *fmt, ...) // fprintf(stderr, "%s\n", lb); } - void pic16_emitpLabel(int key) { pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(NULL,key+100+labelOffset)); @@ -242,6 +273,10 @@ 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 */ /*-----------------------------------------------------------------*/ @@ -273,11 +308,12 @@ void pic16_emitcode (char *inst,char *fmt, ...) // VR fprintf(stderr, "lb = <%s>\n", lbp); - if(pic16_debug_verbose) - pic16_addpCode2pBlock(pb,pic16_newpCodeCharP(lb)); +// if(pic16_debug_verbose) +// pic16_addpCode2pBlock(pb,pic16_newpCodeCharP(lb)); va_end(ap); } +#endif /*-----------------------------------------------------------------*/ @@ -429,6 +465,7 @@ static void resolveIfx(resolvedIfx *resIfx, iCode *ifx) // DEBUGpic16_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset); } +#if 0 /*-----------------------------------------------------------------*/ /* pointerCode - returns the code for a pointer type */ /*-----------------------------------------------------------------*/ @@ -438,7 +475,7 @@ static int pointerCode (sym_link *etype) return PTR_TYPE(SPEC_OCLS(etype)); } - +#endif /*-----------------------------------------------------------------*/ /* aopForSym - for a true symbol */ /*-----------------------------------------------------------------*/ @@ -761,7 +798,8 @@ void pic16_aopOp (operand *op, iCode *ic, bool result) 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); @@ -1225,18 +1263,26 @@ pCodeOp *pic16_popCopyReg(pCodeOpReg *pc) 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) { @@ -1285,7 +1331,8 @@ static pCodeOp *pic16_popRegFromString(char *str, int size, int offset) 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); @@ -1299,22 +1346,19 @@ static pCodeOp *pic16_popRegFromString(char *str, int size, int 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); - - pcop = Safe_calloc(1,sizeof(pCodeOpReg) ); +// DEBUGpic16_emitcode ("; ***","%s,%d\trIdx=0x%x", __FUNCTION__,__LINE__,rIdx); - 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 = 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; + pcop->type = PCOR(pcop)->r->pc_type; return pcop; } @@ -1329,6 +1373,10 @@ pCodeOp *pic16_popGet2(asmop *aop_src, asmop *aop_dst, int offset) pCodeOp *temp; pcop2 = (pCodeOpReg2 *)pic16_popGet(aop_src, offset); + + /* comment the following check, so errors to throw up */ +// if(!pcop2)return NULL; + temp = pic16_popGet(aop_dst, offset); pcop2->pcop2 = temp; @@ -1336,6 +1384,44 @@ pCodeOp *pic16_popGet2(asmop *aop_src, asmop *aop_dst, int offset) } + +/*--------------------------------------------------------------------------------.-*/ +/* pic16_popGet2p - a variant of pic16_popGet to handle two memory operand commands */ +/* VR 030601 , adapted by Hans Dorn */ +/*--------------------------------------------------------------------------------.-*/ +pCodeOp *pic16_popGet2p(pCodeOp *src, pCodeOp *dst) +{ + pCodeOpReg2 *pcop2; + + pcop2 = (pCodeOpReg2 *) src; + pcop2->pcop2 = dst; + + 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 */ /*-----------------------------------------------------------------*/ @@ -1363,48 +1449,22 @@ pCodeOp *pic16_popGet (asmop *aop, int offset) //, bool bit16, bool dname) 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: + DEBUGpic16_emitcode(";","%d\tAOP_DIR", __LINE__); return pic16_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 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); @@ -1419,6 +1479,8 @@ pCodeOp *pic16_popGet (asmop *aop, int offset) //, bool bit16, bool dname) } 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) @@ -1426,11 +1488,13 @@ pCodeOp *pic16_popGet (asmop *aop, int offset) //, bool bit16, bool dname) 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]); @@ -1704,6 +1768,58 @@ static void mov2w (asmop *aop, int 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 */ /*-----------------------------------------------------------------*/ @@ -1851,10 +1967,11 @@ void pic16_toBoolean(operand *oper) } +#if !defined(GEN_Not) /*-----------------------------------------------------------------*/ /* genNot - generate code for ! operation */ /*-----------------------------------------------------------------*/ -static void genNot (iCode *ic) +static void pic16_genNot (iCode *ic) { symbol *tlbl; int size; @@ -1897,12 +2014,14 @@ static void genNot (iCode *ic) 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 ; @@ -1948,6 +2067,7 @@ release: 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 */ @@ -2166,22 +2286,41 @@ static void assignResultValue(operand * oper) { 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)); - } + } + } @@ -2367,136 +2506,152 @@ static void saverbank (int bank, iCode *ic, bool pushPsw) #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)); - 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)); + 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. */ + +#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); } /*-----------------------------------------------------------------*/ @@ -2662,189 +2817,221 @@ static bool inExcludeList(char *s) /*-----------------------------------------------------------------*/ 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)) { + if(IFFUNC_ISNAKED(ftype)) { + DEBUGpic16_emitcode("; ***", "_naked function, no prologue"); + return; + } + + /* if critical function then turn interrupts off */ + if (IFFUNC_ISCRITICAL(ftype)) + pic16_emitcode("clr","ea"); + + /* here we need to generate the equates for the + * register bank if required */ #if 0 - pic16_addpCode2pBlock(pb,pic16_newpCode(POC_BRA,pic16_newpCodeOp("END_OF_INTERRUPT+2",PO_STR))); - - /* what is the reason of having these 3 NOPS? VR - 030701 */ - pic16_emitpcodeNULLop(POC_NOP); - pic16_emitpcodeNULLop(POC_NOP); - pic16_emitpcodeNULLop(POC_NOP); + 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); + } + } #endif - 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)); + /* 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); + 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 (!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 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); - } + /* 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); + } } - - } 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; + } 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"); + } + } /*-----------------------------------------------------------------*/ @@ -2856,10 +3043,17 @@ static void genEndFunction (iCode *ic) 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 @@ -2871,6 +3065,7 @@ static void genEndFunction (iCode *ic) } +#if 0 if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)) { if (options.useXstack) { pic16_emitcode("mov","r0,%s",spname); @@ -2883,6 +3078,7 @@ static void genEndFunction (iCode *ic) pic16_emitcode ("pop","_bp"); } } +#endif /* restore the register bank */ if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type)) @@ -2977,20 +3173,28 @@ static void genEndFunction (iCode *ic) 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) { @@ -3005,6 +3209,22 @@ static void genEndFunction (iCode *ic) _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); @@ -3041,8 +3261,10 @@ static void genRet (iCode *ic) 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) ) { @@ -3051,7 +3273,7 @@ static void genRet (iCode *ic) 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++; } @@ -3606,6 +3828,7 @@ static void genIfxJump (iCode *ic, char *jval) /*-----------------------------------------------------------------*/ static void genSkip(iCode *ifx,int status_bit) { + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); if(!ifx) return; @@ -3626,7 +3849,7 @@ static void genSkip(iCode *ifx,int status_bit) } 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 { @@ -3645,7 +3868,7 @@ static void genSkip(iCode *ifx,int status_bit) 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); } @@ -3685,6 +3908,7 @@ static void genSkipz2(resolvedIfx *rifx, int invert_condition) rifx->generated = 1; } +#if 0 /*-----------------------------------------------------------------*/ /* genSkipz */ /*-----------------------------------------------------------------*/ @@ -3709,6 +3933,8 @@ static void genSkipz(iCode *ifx, int condition) pic16_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset); } +#endif + /*-----------------------------------------------------------------*/ /* genSkipCond */ /*-----------------------------------------------------------------*/ @@ -4351,11 +4577,11 @@ static void genCmp (operand *left,operand *right, /* 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 */ @@ -4762,6 +4988,8 @@ static void genCmpEq (iCode *ic, iCode *ifx) operand *left, *right, *result; unsigned long lit = 0L; int size,offset=0; + symbol *falselbl = newiTempLabel(NULL); + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -4791,9 +5019,11 @@ static void genCmpEq (iCode *ic, iCode *ifx) 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){ @@ -4824,96 +5054,102 @@ static void genCmpEq (iCode *ic, iCode *ifx) } 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 ) { @@ -4933,11 +5169,11 @@ static void genCmpEq (iCode *ic, iCode *ifx) 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 { @@ -4953,15 +5189,25 @@ static void genCmpEq (iCode *ic, iCode *ifx) 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); } @@ -4981,6 +5227,7 @@ static void genCmpEq (iCode *ic, iCode *ifx) /* 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){ @@ -5013,7 +5260,7 @@ static void genCmpEq (iCode *ic, iCode *ifx) 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) @@ -6103,7 +6350,12 @@ static void genInline (iCode *ic) *bp++ = '\0'; if(*bp1) - pic16_addpCode2pBlock(pb,pic16_AssembleLine(bp1)); +#if 0 + pic16_addpCode2pBlock(pb, pic16_newpCodeAsmDir(bp1, NULL)); +#else + pic16_addpCode2pBlock(pb, pic16_AssembleLine(bp1, 0)); +#endif + // inline directly, no process bp1 = bp; } else { if (*bp == ':') { @@ -6117,7 +6369,7 @@ static void genInline (iCode *ic) } } if ((bp1 != bp) && *bp1) - pic16_addpCode2pBlock(pb,pic16_AssembleLine(bp1)); + pic16_addpCode2pBlock(pb, pic16_newpCodeAsmDir(bp1, NULL)); //pic16_AssembleLine(bp1, 0)); Safe_free(buffer); @@ -6132,6 +6384,8 @@ static void genRRC (iCode *ic) 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); @@ -6144,6 +6398,8 @@ static void genRRC (iCode *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)); @@ -6239,6 +6495,7 @@ static void genGetHbit (iCode *ic) pic16_freeAsmop(result,NULL,ic,TRUE); } +#if 0 /*-----------------------------------------------------------------*/ /* AccRol - rotate left accumulator by known count */ /*-----------------------------------------------------------------*/ @@ -6276,6 +6533,7 @@ static void AccRol (int shCount) break; } } +#endif /*-----------------------------------------------------------------*/ /* AccLsh - left shift accumulator by known count */ @@ -6283,20 +6541,38 @@ static void AccRol (int shCount) 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])); + } /*-----------------------------------------------------------------*/ @@ -6305,17 +6581,37 @@ static void AccLsh (int 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 @@ -6653,11 +6949,23 @@ static void movLeft2Result (operand *left, int offl, 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; @@ -6670,9 +6978,9 @@ static void shiftL2Left2Result (operand *left, int offl, 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; @@ -6686,8 +6994,8 @@ static void shiftL2Left2Result (operand *left, int offl, 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: @@ -6726,9 +7034,9 @@ static void shiftL2Left2Result (operand *left, int offl, 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; @@ -6745,8 +7053,8 @@ static void shiftL2Left2Result (operand *left, int offl, 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: @@ -6781,29 +7089,21 @@ static void shiftR2Left2Result (operand *left, int offl, 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; @@ -6827,9 +7127,9 @@ static void shiftR2Left2Result (operand *left, int offl, 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)); } @@ -6933,13 +7233,13 @@ static void shiftLLeftOrResult (operand *left, int offl, 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)); } /*-----------------------------------------------------------------*/ @@ -6949,13 +7249,13 @@ static void shiftRLeftOrResult (operand *left, int offl, 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)); } /*-----------------------------------------------------------------*/ @@ -6974,7 +7274,7 @@ static void genlshTwo (operand *result,operand *left, int shCount) { int size; - DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); + DEBUGpic16_emitcode ("; ***","%s %d shCount:%d",__FUNCTION__,__LINE__,shCount); size = pic16_getDataSize(result); /* if shCount >= 8 */ @@ -7001,64 +7301,63 @@ static void genlshTwo (operand *result,operand *left, int shCount) /*-----------------------------------------------------------------*/ /* 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 (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)); + } + + 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 (!(pic16_sameRegs(AOP(result),AOP(left)) && size >= MSB16+offr && offr != LSB) ) { - l = pic16_aopGet(AOP(left),MSB16,FALSE,FALSE); - MOVA(l); - } - 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 (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)); + } /*-----------------------------------------------------------------*/ @@ -7080,9 +7379,11 @@ static void genlshFour (operand *result, operand *left, int shCount) 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; } @@ -7097,8 +7398,8 @@ static void genlshFour (operand *result, operand *left, int shCount) 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; } @@ -7117,7 +7418,7 @@ static void genlshFour (operand *result, operand *left, int shCount) 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); @@ -7125,15 +7426,16 @@ static void genlshFour (operand *result, operand *left, int shCount) 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 */ @@ -7155,7 +7457,7 @@ static void genLeftShiftLiteral (operand *left, 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); @@ -7305,8 +7607,8 @@ static void genLeftShift (iCode *ic) 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)); @@ -7368,7 +7670,8 @@ static void genLeftShift (iCode *ic) 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)); @@ -7411,7 +7714,7 @@ static void genrshOne (operand *result, operand *left, 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 ; @@ -7441,31 +7744,58 @@ static void genrshTwo (operand *result,operand *left, static void shiftRLong (operand *left, int offl, operand *result, int sign) { - DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); - if(!sign) - pic16_emitcode("clr","c"); - MOVA(pic16_aopGet(AOP(left),MSB32,FALSE,FALSE)); + int size = AOP_SIZE(result); + int same = pic16_sameRegs(AOP(left),AOP(result)); + int i; + DEBUGpic16_emitcode ("; ***","%s %d offl:%d size:%d",__FUNCTION__,__LINE__,offl,size); + + if (same && (offl == MSB16)) { //shift one byte right + for(i=MSB16;i= 2 shiftR2Left2Result(left, MSB16, result, LSB, shCount, 0); shiftLLeftOrResult(left, MSB32, result, MSB16, 8 - shCount); /* the last shift is signed */ @@ -7539,12 +7869,13 @@ static void genRightShiftLiteral (operand *left, 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)); @@ -7754,17 +8085,17 @@ static void genSignedRightShift (iCode *ic) 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 ; } @@ -8061,7 +8392,7 @@ static void genNearPointerGet (operand *left, 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 */ @@ -8159,7 +8490,7 @@ static void genPagedPointerGet (operand *left, 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 */ @@ -8237,7 +8568,7 @@ static void genFarPointerGet (operand *left, 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); @@ -8287,7 +8618,7 @@ static void genCodePointerGet (operand *left, 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); @@ -8311,50 +8642,58 @@ static void genCodePointerGet (operand *left, static void genGenPointerGet (operand *left, operand *result, iCode *ic) { - int size, offset ; - sym_link *retype = getSpec(operandType(result)); - - DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); - pic16_aopOp(left,ic,FALSE); - pic16_aopOp(result,ic,FALSE); - + int size, offset, lit; + sym_link *retype = getSpec(operandType(result)); - DEBUGpic16_pic16_AopType(__LINE__,left,NULL,result); + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); + pic16_aopOp(left,ic,FALSE); + pic16_aopOp(result,ic,FALSE); + size = AOP_SIZE(result); - /* if the operand is already in dptr - then we do nothing else we move the value to dptr */ - // if (AOP_TYPE(left) != AOP_STR) { - /* if this is remateriazable */ - if (AOP_TYPE(left) == AOP_IMMD) { - pic16_emitcode("mov","dptr,%s",pic16_aopGet(AOP(left),0,TRUE,FALSE)); - pic16_emitcode("mov","b,#%d",pointerCode(retype)); - } - else { /* we need to get it byte by byte */ + DEBUGpic16_pic16_AopType(__LINE__,left,NULL,result); - pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),0)); - pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_fsr0)); + if (AOP_TYPE(left) == AOP_IMMD) { // do we ever get here? (untested!) - size = AOP_SIZE(result); - offset = 0 ; + lit = (unsigned)floatFromVal(AOP(left)->aopu.aop_lit); + // load FSR0 from immediate + pic16_emitpcode(POC_LFSR,pic16_popGetLit2(0,pic16_popGetLit(lit))); + offset = 0; + while(size--) { + if(size) { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_postinc0), pic16_popGet(AOP(result),offset))); + } else { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_indf0), pic16_popGet(AOP(result),offset))); + } + offset++; + } + goto release; - while(size--) { - pic16_emitpcode(POC_MOVFW,pic16_popCopyReg(&pic16_pc_indf0)); - pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),offset++)); - if(size) - pic16_emitpcode(POC_INCF,pic16_popCopyReg(&pic16_pc_fsr0)); - } - goto release; - } - //} - /* so dptr know contains the address */ + } + else { /* we need to get it byte by byte */ + // set up FSR0 with address from left + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),0), pic16_popCopyReg(&pic16_pc_fsr0l))); + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),1), pic16_popCopyReg(&pic16_pc_fsr0h))); + + offset = 0 ; + + while(size--) { + if(size) { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_postinc0), pic16_popGet(AOP(result),offset))); + } else { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_indf0), pic16_popGet(AOP(result),offset))); + } + offset++; + } + goto release; + } /* 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); - pic16_freeAsmop(result,NULL,ic,TRUE); + release: + pic16_freeAsmop(left,NULL,ic,TRUE); + pic16_freeAsmop(result,NULL,ic,TRUE); } @@ -8384,6 +8723,7 @@ static void genConstPointerGet (operand *left, 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)); @@ -8672,7 +9012,7 @@ static void genDataPointerSet(operand *right, 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); @@ -8762,14 +9102,15 @@ static void genNearPointerSet (operand *right, 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 { @@ -8871,7 +9212,7 @@ static void genPagedPointerSet (operand *right, 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 */ @@ -8949,7 +9290,7 @@ static void genFarPointerSet (operand *right, 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); @@ -8973,105 +9314,110 @@ static void genFarPointerSet (operand *right, static void genGenPointerSet (operand *right, operand *result, iCode *ic) { - int size, offset ; - sym_link *retype = getSpec(operandType(right)); - - DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); - - pic16_aopOp(result,ic,FALSE); - pic16_aopOp(right,ic,FALSE); - size = AOP_SIZE(right); - - DEBUGpic16_pic16_AopType(__LINE__,NULL,right,result); - - /* if the operand is already in dptr - then we do nothing else we move the value to dptr */ - if (AOP_TYPE(result) != AOP_STR) { - /* if this is remateriazable */ - if (AOP_TYPE(result) == AOP_IMMD) { - pic16_emitcode("mov","dptr,%s",pic16_aopGet(AOP(result),0,TRUE,FALSE)); - pic16_emitcode("mov","b,%s + 1",pic16_aopGet(AOP(result),0,TRUE,FALSE)); - } - else { /* we need to get it byte by byte */ - //char *l = pic16_aopGet(AOP(result),0,FALSE,FALSE); - size = AOP_SIZE(right); - offset = 0 ; - - /* hack hack! see if this the FSR. If so don't load W */ - if(AOP_TYPE(right) != AOP_ACC) { + int size, offset, lit; + sym_link *retype = getSpec(operandType(right)); + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); - pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(result),0)); - pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_fsr0)); - - if(AOP_SIZE(result) > 1) { - pic16_emitpcode(POC_BCF, pic16_popCopyGPR2Bit(PCOP(&pic16_pc_status),PIC_IRP_BIT)); - pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(result),1,FALSE,FALSE),0,0)); - pic16_emitpcode(POC_BSF, pic16_popCopyGPR2Bit(PCOP(&pic16_pc_status),PIC_IRP_BIT)); - - } + pic16_aopOp(result,ic,FALSE); + pic16_aopOp(right,ic,FALSE); + size = AOP_SIZE(right); + offset = 0; + + DEBUGpic16_pic16_AopType(__LINE__,NULL,right,result); + + + /* if the operand is already in dptr + then we do nothing else we move the value to dptr */ + if (AOP_TYPE(result) != AOP_STR) { + /* if this is remateriazable */ + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); + // WARNING: anythig until "else" is untested! + if (AOP_TYPE(result) == AOP_IMMD) { + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); + lit = (unsigned)floatFromVal(AOP(result)->aopu.aop_lit); + // load FSR0 from immediate + pic16_emitpcode(POC_LFSR,pic16_popGetLit2(0,pic16_popGetLit(lit))); + offset = 0; + while(size--) { + if(size) { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(right),offset), pic16_popCopyReg(&pic16_pc_postinc0))); + } else { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(right),offset), pic16_popCopyReg(&pic16_pc_indf0))); + } + offset++; + } + goto release; + } + else { /* we need to get it byte by byte */ + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); + //char *l = pic16_aopGet(AOP(result),0,FALSE,FALSE); + + // set up FSR0 with address of result + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(result),0), pic16_popCopyReg(&pic16_pc_fsr0l))); + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(result),1), pic16_popCopyReg(&pic16_pc_fsr0h))); + + /* hack hack! see if this the FSR. If so don't load W */ + if(AOP_TYPE(right) != AOP_ACC) { + + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); + + while(size--) { + if(size) { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(right),offset), pic16_popCopyReg(&pic16_pc_postinc0))); + } else { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(right),offset), pic16_popCopyReg(&pic16_pc_indf0))); + } + offset++; + } + goto release; + } + // right = ACC + DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__); + + pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_indf0)); + goto release; + } // if (AOP_TYPE(result) != AOP_IMMD) + + } // if (AOP_TYPE(result) != AOP_STR) + /* so dptr know contains the address */ + + + /* if bit then unpack */ + if (IS_BITFIELD(retype)) + genPackBits(retype,right,"dptr",GPOINTER); + else { + size = AOP_SIZE(right); + offset = 0 ; - //if(size==2) - //pic16_emitpcode(POC_DECF,pic16_popCopyReg(&pic16_pc_fsr0)); - //if(size==4) { - // pic16_emitpcode(POC_MOVLW,pic16_popGetLit(0xfd)); - // pic16_emitpcode(POC_ADDWF,pic16_popCopyReg(&pic16_pc_fsr0)); - //} + DEBUGpic16_emitcode ("; ***","%s %d size=%d",__FUNCTION__,__LINE__,size); - while(size--) { - pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(right),offset++)); - pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_indf0)); - - if(size) - pic16_emitpcode(POC_INCF,pic16_popCopyReg(&pic16_pc_fsr0)); + // set up FSR0 with address of result + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(result),0), pic16_popCopyReg(&pic16_pc_fsr0l))); + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(result),1), pic16_popCopyReg(&pic16_pc_fsr0h))); + + while (size--) { + if (AOP_TYPE(right) == AOP_LIT) { + pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right),offset)); + if (size) { + pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_postinc0)); + } else { + pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_indf0)); + } + } else { // no literal + if(size) { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(right),offset), pic16_popCopyReg(&pic16_pc_postinc0))); + } else { + pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(right),offset), pic16_popCopyReg(&pic16_pc_indf0))); + } + } + offset++; + } } - - goto release; - } - - if(aopIdx(AOP(result),0) != 4) { - - pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_indf0)); - goto release; - } - - pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_indf0)); - goto release; - - } - } - /* so dptr know contains the address */ - - - /* if bit then unpack */ - if (IS_BITVAR(retype)) - genPackBits(retype,right,"dptr",GPOINTER); - else { - size = AOP_SIZE(right); - offset = 0 ; - - DEBUGpic16_emitcode ("; ***","%s %d size=%d",__FUNCTION__,__LINE__,size); - - while (size--) { - - pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(result),offset)); - pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_fsr0)); - - if (AOP_TYPE(right) == AOP_LIT) - pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right),offset)); - else - pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),offset)); - - pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_indf0)); - - offset++; - } - } - - release: - pic16_freeAsmop(right,NULL,ic,TRUE); - pic16_freeAsmop(result,NULL,ic,TRUE); + release: + pic16_freeAsmop(right,NULL,ic,TRUE); + pic16_freeAsmop(result,NULL,ic,TRUE); } /*-----------------------------------------------------------------*/ @@ -9186,6 +9532,7 @@ static void genIfx (iCode *ic, iCode *popIc) /*-----------------------------------------------------------------*/ /* genAddrOf - generates code for address of */ /*-----------------------------------------------------------------*/ +#if 0 static void genAddrOf (iCode *ic) { operand *right, *result, *left; @@ -9218,6 +9565,65 @@ static void genAddrOf (iCode *ic) } +#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 */ @@ -9365,7 +9771,7 @@ static void genAssign (iCode *ic) #if 1 /* This is a hack to turn MOVFW/MOVWF pairs to MOVFF command. It - normally should work, but mind that thw W register live range + 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. @@ -9374,7 +9780,6 @@ static void genAssign (iCode *ic) 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(!?) */ @@ -9571,149 +9976,174 @@ release: /*-----------------------------------------------------------------*/ 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); + if ((AOP_TYPE(right) == AOP_CRY) && (AOP_TYPE(result) == AOP_REG)) { + int offset = 1; - DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__); + size = AOP_SIZE(result); - 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__); - while (size--) - pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset++)); + 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)); - goto release; - } + while (size--) + pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset++)); + + goto release; + } - /* if they are the same size : or less */ - if (AOP_SIZE(result) <= AOP_SIZE(right)) { + /* 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; + /* if they are in the same place */ + if (pic16_sameRegs(AOP(right),AOP(result))) + goto release; - DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__); + DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__); #if 0 - if (IS_PTR_CONST(rtype)) + if (IS_PTR_CONST(rtype)) #else - if (IS_CODEPTR(rtype)) + if (IS_CODEPTR(rtype)) #endif - DEBUGpic16_emitcode ("; ***","%d - right is const pointer",__LINE__); + DEBUGpic16_emitcode ("; ***","%d - right is const pointer",__LINE__); + #if 0 - if (IS_PTR_CONST(operandType(IC_RESULT(ic)))) + if (IS_PTR_CONST(operandType(IC_RESULT(ic)))) #else - if (IS_CODEPTR(operandType(IC_RESULT(ic)))) + if (IS_CODEPTR(operandType(IC_RESULT(ic)))) #endif - DEBUGpic16_emitcode ("; ***","%d - result is const pointer",__LINE__); - - 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)); - - //pic16_aopPut(AOP(result), - // pic16_aopGet(AOP(right),offset,FALSE,FALSE), - // offset); - - offset++; - } - } - goto release; - } + 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)); @@ -9821,7 +10251,7 @@ static void genCast (iCode *ic) 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 */ @@ -9916,35 +10346,40 @@ static int genDjnz (iCode *ic, iCode *ifx) /*-----------------------------------------------------------------*/ 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); } /*-----------------------------------------------------------------*/ @@ -10014,18 +10449,21 @@ void genpic16Code (iCode *lic) 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 @@ -10036,11 +10474,11 @@ void genpic16Code (iCode *lic) /* depending on the operation */ switch (ic->op) { case '!' : - genNot(ic); + pic16_genNot(ic); break; case '~' : - genCpl(ic); + pic16_genCpl(ic); break; case UNARYMINUS: