return -1;
}
+void DEBUGpic14_AopType(int line_no, operand *left, operand *right, operand *result)
+{
+
+ DEBUGpic14_emitcode ("; ","line = %d result %s=%s, left %s=%s, right %s=%s, size = %d",
+ line_no,
+ ((result) ? AopType(AOP_TYPE(result)) : "-"),
+ ((result) ? aopGet(AOP(result),0,TRUE,FALSE) : "-"),
+ ((left) ? AopType(AOP_TYPE(left)) : "-"),
+ ((left) ? aopGet(AOP(left),0,TRUE,FALSE) : "-"),
+ ((right) ? AopType(AOP_TYPE(right)) : "-"),
+ ((right) ? aopGet(AOP(right),0,FALSE,FALSE) : "-"),
+ ((result) ? AOP_SIZE(result) : 0));
+
+}
+
void DEBUGpic14_emitcode (char *inst,char *fmt, ...)
{
va_list ap;
sym->aop = aop = newAsmop (AOP_CRY);
aop->aopu.aop_dir = sym->rname ;
aop->size = getSize(sym->type);
- DEBUGpic14_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
+ //DEBUGpic14_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
return aop;
}
/* if it is in direct space */
if (!op)
return ;
- DEBUGpic14_emitcode(";","%d",__LINE__);
+ // DEBUGpic14_emitcode(";","%d",__LINE__);
/* if this a literal */
if (IS_OP_LITERAL(op)) {
op->aop = aop = newAsmop(AOP_LIT);
aop->aopu.aop_lit = op->operand.valOperand;
aop->size = getSize(operandType(op));
- DEBUGpic14_emitcode(";","%d, lit = %d",__LINE__,aop->aopu.aop_lit);
return;
}
/* if this is a true symbol */
if (IS_TRUE_SYMOP(op)) {
- DEBUGpic14_emitcode(";","%d - true symop",__LINE__);
- op->aop = aopForSym(ic,OP_SYMBOL(op),result);
- return ;
+ //DEBUGpic14_emitcode(";","%d - true symop",__LINE__);
+ op->aop = aopForSym(ic,OP_SYMBOL(op),result);
+ return ;
}
/* this is a temporary : this has
/* if the type is a conditional */
if (sym->regType == REG_CND) {
- DEBUGpic14_emitcode(";","%d",__LINE__);
aop = op->aop = sym->aop = newAsmop(AOP_CRY);
aop->size = 0;
return;
sym->aop = op->aop = aop =
aopForRemat (sym);
aop->size = getSize(sym->type);
- DEBUGpic14_emitcode(";","%d",__LINE__);
return;
}
/* depending on the asmop type only three cases need work AOP_RO
, AOP_R1 && AOP_STK */
+#if 0
switch (aop->type) {
case AOP_R0 :
if (_G.r0Pushed ) {
}
}
}
+#endif
dealloc:
/* all other cases just dealloc */
return rs;
case AOP_REG:
- DEBUGpic14_emitcode(";","%d",__LINE__);
if (dname)
return aop->aopu.aop_reg[offset]->dname;
else
return aop->aopu.aop_reg[offset]->name;
case AOP_CRY:
- pic14_emitcode(";","%d",__LINE__);
- //pic14_emitcode("clr","a");
- //pic14_emitcode("mov","c,%s",aop->aopu.aop_dir);
- //pic14_emitcode("rlc","a") ;
- //return (dname ? "acc" : "a");
+ //pic14_emitcode(";","%d",__LINE__);
return aop->aopu.aop_dir;
case AOP_ACC:
DEBUGpic14_emitcode(";Warning -pic port ignoring get(AOP_ACC)","%d",__LINE__);
- //if (!offset && dname)
- // return "acc";
- //return aop->aopu.aop_str[offset];
return "AOP_accumulator_bug";
case AOP_LIT:
- DEBUGpic14_emitcode(";","%d",__LINE__);
sprintf(s,"0x%02x", pic14aopLiteral (aop->aopu.aop_lit,offset));
rs = Safe_calloc(1,strlen(s)+1);
strcpy(rs,s);
/*-----------------------------------------------------------------*/
/* popGet - asm operator to pcode operator conversion */
/*-----------------------------------------------------------------*/
-pCodeOp *popGet (asmop *aop, int offset, bool bit16, bool dname)
+pCodeOp *popGet (asmop *aop, int offset) //, bool bit16, bool dname)
{
char *s = buffer ;
char *rs;
DEBUGpic14_emitcode(";","%d",__LINE__);
pcop = Safe_calloc(1,sizeof(pCodeOp) );
pcop->type = PO_IMMEDIATE;
- if (bit16)
- sprintf (s,"%s",aop->aopu.aop_immd);
+ //if (bit16)
+ // sprintf (s,"%s",aop->aopu.aop_immd);
+ //else
+ if (offset)
+ sprintf(s,"(%s >> %d)",
+ aop->aopu.aop_immd,
+ offset*8);
else
- if (offset)
- sprintf(s,"(%s >> %d)",
- aop->aopu.aop_immd,
- offset*8);
- else
- sprintf(s,"%s",
- aop->aopu.aop_immd);
+ sprintf(s,"%s",
+ aop->aopu.aop_immd);
pcop->name = Safe_calloc(1,strlen(s)+1);
strcpy(pcop->name,s);
return pcop;
{
int rIdx = aop->aopu.aop_reg[offset]->rIdx;
- DEBUGpic14_emitcode(";","%d, rIdx=0x%x",__LINE__,rIdx);
- if(bit16)
- pcop = Safe_calloc(1,sizeof(pCodeOpRegBit) );
- else
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- //pcop->type = PO_GPR_REGISTER;
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
PCOR(pcop)->rIdx = rIdx;
PCOR(pcop)->r = pic14_regWithIdx(rIdx);
pcop->type = PCOR(pcop)->r->pc_type;
-
- if (dname)
- rs = aop->aopu.aop_reg[offset]->dname;
- else
- rs = aop->aopu.aop_reg[offset]->name;
-
- DEBUGpic14_emitcode(";","%d %s",__LINE__,rs);
-
+ rs = aop->aopu.aop_reg[offset]->name;
return pcop;
}
return pcop;
case AOP_LIT:
- DEBUGpic14_emitcode(";","%d",__LINE__);
return newpCodeOpLit(pic14aopLiteral (aop->aopu.aop_lit,offset));
case AOP_STR:
pcop->type = PO_STR;
//aop->coff = offset ;
- if (strcmp(aop->aopu.aop_str[offset],"a") == 0 && dname)
- sprintf(s,"%s","acc");
- else
- sprintf(s,"%s",aop->aopu.aop_str[offset]);
- pcop->name = Safe_calloc(1,strlen(s)+1);
- strcpy(pcop->name,s);
- return pcop;
+ //if (strcmp(aop->aopu.aop_str[offset],"a") == 0 && dname)
+ // sprintf(s,"%s","acc");
+ //else
+ sprintf(s,"%s",aop->aopu.aop_str[offset]);
+ pcop->name = Safe_calloc(1,strlen(s)+1);
+ strcpy(pcop->name,s);
+ return pcop;
}
if(strcmp(s,"W"))
pic14_emitcode(";BUG! should have this:movf","%s,w %d",s,__LINE__);
- emitpcode(POC_MOVWF,popGet(aop,offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(aop,offset));
}
pcop->name = Safe_strdup(s);
emitpcode(POC_MOVFW,pcop);
}
- emitpcode(POC_MOVWF,popGet(aop,offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(aop,offset));
}
break;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if ( AOP_TYPE(oper) != AOP_ACC) {
- emitpcode(POC_MOVFW,popGet(AOP(oper),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(oper),0));
pic14_emitcode("movf","%s,w",aopGet(AOP(oper),0,FALSE,FALSE));
}
while (size--) {
- pic14_emitcode("iorwf","%s,w",aopGet(AOP(oper),offset,FALSE,FALSE));
- emitpcode(POC_IORFW, popGet(AOP(oper),offset++,FALSE,FALSE));
+ emitpcode(POC_IORFW, popGet(AOP(oper),offset++));
}
}
/*-----------------------------------------------------------------*/
static void assignResultValue(operand * oper)
{
- int offset = 0;
int size = AOP_SIZE(oper);
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(!GpsuedoStkPtr) {
/* The last byte in the assignment is in W */
- //aopPut(AOP(oper),"W",size-1);
- emitpcode(POC_MOVWF, popGet(AOP(oper),0,FALSE,FALSE));
- GpsuedoStkPtr++;
- if(size == 1)
- return;
size--;
- offset++;
+ emitpcode(POC_MOVWF, popGet(AOP(oper),size));
+ GpsuedoStkPtr++;
}
while (size--) {
emitpcode(POC_MOVFW,popRegFromIdx(GpsuedoStkPtr-1 + Gstack_base_addr));
- emitpcode(POC_MOVWF, popGet(AOP(oper),offset,FALSE,FALSE));
- offset++;
GpsuedoStkPtr++;
-
+ emitpcode(POC_MOVWF, popGet(AOP(oper),size));
}
}
* in registers. (The pCode optimizer will get
* rid of most of these :).
*/
- int psuedoStkPtr=0;
+ int psuedoStkPtr=-1;
int firstTimeThruLoop = 1;
+ _G.sendSet = reverseSet(_G.sendSet);
+
+ /* First figure how many parameters are getting passed */
+ for (sic = setFirstItem(_G.sendSet) ; sic ;
+ sic = setNextItem(_G.sendSet)) {
+
+ aopOp(IC_LEFT(sic),sic,FALSE);
+ psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
+ freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
+ }
+
for (sic = setFirstItem(_G.sendSet) ; sic ;
sic = setNextItem(_G.sendSet)) {
int size, offset = 0;
AopType(AOP_TYPE(IC_LEFT(sic))));
if(!firstTimeThruLoop) {
- /* If is not the first time we've been through the loop
+ /* 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. */
- pic14_emitcode("movwf","%s",fReturn[offset]);
- emitpcode(POC_MOVWF,popRegFromIdx(psuedoStkPtr + Gstack_base_addr));
- psuedoStkPtr++;
- DEBUGpic14_emitcode ("; ","%d save param in %d",__LINE__,
- psuedoStkPtr+Gstack_base_addr);
+ emitpcode(POC_MOVWF,popRegFromIdx(--psuedoStkPtr + Gstack_base_addr));
+
}
firstTimeThruLoop=0;
- if (strcmp(l,fReturn[offset])) {
+ //if (strcmp(l,fReturn[offset])) {
- if ( ((AOP(IC_LEFT(sic))->type) == AOP_IMMD) ||
- ((AOP(IC_LEFT(sic))->type) == AOP_LIT) )
- emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(sic)),size,FALSE,FALSE));
- //pic14_emitcode("movlw","%s",l);
- else
- emitpcode(POC_MOVFW,popGet(AOP(IC_LEFT(sic)),size,FALSE,FALSE));
- //pic14_emitcode("movf","%s,w",l);
+ if ( ((AOP(IC_LEFT(sic))->type) == AOP_IMMD) ||
+ ((AOP(IC_LEFT(sic))->type) == AOP_LIT) )
+ emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(sic)),offset));
+ else
+ emitpcode(POC_MOVFW,popGet(AOP(IC_LEFT(sic)),offset));
- /* The last one is passed in W but all others are passed on
- the psuedo stack */
- /*
- if(size) {
- pic14_emitcode("movwf","%s",fReturn[offset]);
- emitpcode(POC_MOVWF,popRegFromIdx(offset + Gstack_base_addr));
- }
- */
- }
+ //}
offset++;
}
freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
if (strcmp(fReturn[offset],l)) {
if( ( (AOP(IC_LEFT(ic))->type) == AOP_IMMD) ||
((AOP(IC_LEFT(ic))->type) == AOP_LIT) ) {
- emitpcode(POC_MOVLW, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
- pic14_emitcode("movlw","%s",l);
+ emitpcode(POC_MOVLW, popGet(AOP(IC_LEFT(ic)),offset));
}else {
- emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
- pic14_emitcode("movf","%s,w",l);
+ emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
}
if(size) {
emitpcode(POC_MOVWF,popRegFromIdx(offset + Gstack_base_addr));
}
emitpcode(POC_MOVLW, popGetLit(i));
- emitpcode(POC_SUBFW, popGet(AOP(left),size,FALSE,FALSE));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
while(size--) {
i = (lit >> (size*8)) & 0xff;
emitpcode(POC_MOVLW, popGetLit(i));
emitSKPNC;
- emitpcode(POC_SUBFW, popGet(AOP(left),size,FALSE,FALSE));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
}
if(ifx) {
}
}
emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
- emitpcode(POC_SUBFW, popGet(AOP(right),0,FALSE,FALSE));
+ emitpcode(POC_SUBFW, popGet(AOP(right),0));
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
rIfx.condition ^= 1;
genSkipc(&rIfx);// if(ifx) genSkipc(ifx,1,1);//IC_TRUE(ifx)!=NULL);
}
}
- emitpcode(POC_MOVFW, popGet(AOP(right),size,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
emitpcode(POC_SUBLW, popGetLit((i)&0xff));
while(size--) {
i = (lit >> (size*8)) & 0xff;
- emitpcode(POC_MOVFW, popGet(AOP(right),size,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
emitSKPNC;
emitpcode(POC_SUBLW, popGetLit((i)&0xff));
}
// CLRC;
DEBUGpic14_emitcode(";sign","%d",sign);
- pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("subwf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));//++
-
- emitpcode(POC_MOVFW, popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_SUBFW, popGet(AOP(left),offset++,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_SUBFW, popGet(AOP(left),offset++));
size--;
while (size--) {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
emitSKPC;
- emitpcode(POC_INCFSZW, popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_SUBFW, popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_INCFSZW, popGet(AOP(right),offset));
+ emitpcode(POC_SUBFW, popGet(AOP(left),offset));
-/*
- pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- emitSKPC;
- pic14_emitcode("incfsz","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("subwf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));
-*/
offset++;
}
}
switch( BYTEofLONG(lit,i)) {
case 0:
- emitpcode(POC_MOVFW,popGet(AOP(op),offset+i,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
break;
case 1:
- emitpcode(POC_DECFW,popGet(AOP(op),offset+i,FALSE,FALSE));
+ emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
break;
case 0xff:
- emitpcode(POC_INCFW,popGet(AOP(op),offset+i,FALSE,FALSE));
+ emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
break;
default:
- emitpcode(POC_MOVFW,popGet(AOP(op),offset+i,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
emitpcode(POC_XORLW,popGetLit(BYTEofLONG(lit,i)));
}
switch( BYTEofLONG(lit,i)) {
case 0:
- emitpcode(POC_IORFW,popGet(AOP(op),offset+i,FALSE,FALSE));
+ emitpcode(POC_IORFW,popGet(AOP(op),offset+i));
break;
case 1:
emitSKPNZ;
- emitpcode(POC_DECFW,popGet(AOP(op),offset+i,FALSE,FALSE));
+ emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
break;
case 0xff:
emitSKPNZ;
- emitpcode(POC_INCFW,popGet(AOP(op),offset+i,FALSE,FALSE));
+ emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
break;
default:
emitpcode(POC_MOVLW,popGetLit(BYTEofLONG(lit,i)));
emitSKPNZ;
- emitpcode(POC_XORFW,popGet(AOP(op),offset+i,FALSE,FALSE));
+ emitpcode(POC_XORFW,popGet(AOP(op),offset+i));
}
unsigned long lit = 0L;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- DEBUGpic14_emitcode ("; ","left %s=%s, right %s=%s, size = %d",
- AopType(AOP_TYPE(left)),
- aopGet(AOP(left),0,TRUE,FALSE),
- AopType(AOP_TYPE(right)),
- aopGet(AOP(right),0,FALSE,FALSE),
- size);
+ DEBUGpic14_AopType(__LINE__,left,right,NULL);
resolveIfx(&rIfx,ifx);
lbl = newiTempLabel(NULL);
case 2:
genc16bit2lit(left, lit, 0);
emitSKPNZ;
- pic14_emitcode("goto","_%05d_DS_",lbl->key+100+labelOffset);
emitpcode(POC_GOTO,popGetLabel(lbl->key));
break;
default:
while (size--) {
if(lit & 0xff) {
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
emitpcode(POC_XORLW,popGetLit(lit & 0xff));
- pic14_emitcode("movf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("xorlw","0x%x",lit & 0xff);
} else {
- emitpcode(POC_MOVF,popGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("movf","%s,f",aopGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVF,popGet(AOP(left),offset));
}
emitSKPNZ;
- pic14_emitcode("goto","_%05d_DS_",lbl->key+100+labelOffset);
emitpcode(POC_GOTO,popGetLabel(lbl->key));
offset++;
lit >>= 8;
case 2:
genc16bit2lit(left, lit, 0);
emitSKPNZ;
- pic14_emitcode("goto","_%05d_DS_",lbl->key+100+labelOffset);
emitpcode(POC_GOTO,popGetLabel(lbl->key));
break;
default:
if((AOP_TYPE(left) == AOP_DIR) &&
((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_XORFW,popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
} else if((AOP_TYPE(left) == AOP_DIR) && (AOP_TYPE(right) == AOP_LIT)){
switch (lit & 0xff) {
case 0:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
break;
case 1:
- emitpcode(POC_DECFSZ,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_DECFSZ,popGet(AOP(left),offset));
emitpcode(POC_GOTO,popGetLabel(lbl->key));
emit_skip=0;
break;
case 0xff:
- emitpcode(POC_INCFSZ,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_INCFSZ,popGet(AOP(left),offset));
emitpcode(POC_GOTO,popGetLabel(lbl->key));
emit_skip=0;
break;
default:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
emitpcode(POC_XORLW,popGetLit(lit & 0xff));
}
lit >>= 8;
} else {
- emitpcode(POC_MOVF,popGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("movf","%s,f",aopGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVF,popGet(AOP(left),offset));
}
if(emit_skip) {
pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
AOP_TYPE(left) != AOP_DIR){
while(size--) {
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_XORFW,popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
if(rIfx.condition)
emitSKPNZ;
aopOp((right=IC_RIGHT(ic)),ic,FALSE);
aopOp((result=IC_RESULT(ic)),ic,TRUE);
-/*
- DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
- AopType(AOP_TYPE(IC_RESULT(ic))),
- AopType(AOP_TYPE(IC_LEFT(ic))),
- AopType(AOP_TYPE(IC_RIGHT(ic))));
-*/
size = max(AOP_SIZE(left),AOP_SIZE(right));
- DEBUGpic14_emitcode ("; ","result %s=%s, left %s=%s, right %s=%s, size = %d",
- AopType(AOP_TYPE(result)),
- aopGet(AOP(result),0,TRUE,FALSE),
- AopType(AOP_TYPE(left)),
- aopGet(AOP(left),0,TRUE,FALSE),
- AopType(AOP_TYPE(right)),
- aopGet(AOP(right),0,FALSE,FALSE),
- size);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
/* if literal, literal on the right or
if the right is in a pointer register and left
switch(lit & 0xff) {
case 1:
if ( IC_TRUE(ifx) ) {
- emitpcode(POC_DECFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_DECFW,popGet(AOP(left),offset));
emitSKPNZ;
emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
} else {
- emitpcode(POC_DECFSZW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
}
break;
case 0xff:
if ( IC_TRUE(ifx) ) {
- emitpcode(POC_INCFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_INCFW,popGet(AOP(left),offset));
emitSKPNZ;
emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
} else {
- emitpcode(POC_INCFSZW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
}
break;
default:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
if(lit)
emitpcode(POC_XORLW,popGetLit(lit & 0xff));
genSkip(ifx,'z');
default:
/* size is 4 */
if(lit==0) {
- emitpcode(POC_MOVFW,popGet(AOP(left),0,FALSE,FALSE));
- emitpcode(POC_IORFW,popGet(AOP(left),1,FALSE,FALSE));
- emitpcode(POC_IORFW,popGet(AOP(left),2,FALSE,FALSE));
- emitpcode(POC_IORFW,popGet(AOP(left),3,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),0));
+ emitpcode(POC_IORFW,popGet(AOP(left),1));
+ emitpcode(POC_IORFW,popGet(AOP(left),2));
+ emitpcode(POC_IORFW,popGet(AOP(left),3));
} else {
//genSkip(ifx,'z');
genc16bit2lit(left,lit,2);
} else {
- emitpcode(POC_IORFW,popGet(AOP(left),2,FALSE,FALSE));
- emitpcode(POC_IORFW,popGet(AOP(left),3,FALSE,FALSE));
+ emitpcode(POC_IORFW,popGet(AOP(left),2));
+ emitpcode(POC_IORFW,popGet(AOP(left),3));
}
} else if(AOP_TYPE(right) == AOP_CRY ) {
/* we know the left is not a bit, but that the right is */
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
emitpcode( ( (IC_TRUE(ifx)) ? POC_BTFSC : POC_BTFSS),
- popGet(AOP(right),offset,FALSE,FALSE));
+ popGet(AOP(right),offset));
emitpcode(POC_XORLW,popGetLit(1));
- pic14_emitcode("movf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));
- if ( IC_TRUE(ifx) )
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
- else
- pic14_emitcode("btfss","(%s >> 3), (%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
-
- pic14_emitcode("xorlw","1");
-
/* if the two are equal, then W will be 0 and the Z bit is set
* we could test Z now, or go ahead and check the high order bytes if
* the variable we're comparing is larger than a byte. */
while(--size)
- emitpcode(POC_IORFW,popGet(AOP(left),offset,FALSE,FALSE));
- //pic14_emitcode("iorwf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_IORFW,popGet(AOP(left),offset));
if ( IC_TRUE(ifx) ) {
emitSKPNZ;
tlbl = newiTempLabel(NULL);
while(size--) {
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_XORFW,popGet(AOP(right),offset,FALSE,FALSE));
-
- pic14_emitcode("movf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("xorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
if ( IC_TRUE(ifx) ) {
if(size) {
aopOp((right=IC_RIGHT(ic)),ic,FALSE);
aopOp((result=IC_RESULT(ic)),ic,FALSE);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
/* if both are bit variables */
if (AOP_TYPE(left) == AOP_CRY &&
AOP_TYPE(right) == AOP_CRY ) {
size = AOP_SIZE(result);
- DEBUGpic14_emitcode ("; ","result %s=%s, left %s=%s, right %s=%s, size = %d",
- AopType(AOP_TYPE(result)),
- aopGet(AOP(result),0,TRUE,FALSE),
- AopType(AOP_TYPE(left)),
- aopGet(AOP(left),0,TRUE,FALSE),
- AopType(AOP_TYPE(right)),
- aopGet(AOP(right),0,FALSE,FALSE),
- size);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
// if(bit & yy)
// result = bit & yy;
if (AOP_TYPE(left) == AOP_CRY){
case 0x00:
/* and'ing with 0 has clears the result */
pic14_emitcode("clrf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_CLRF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF,popGet(AOP(result),offset));
break;
case 0xff:
/* and'ing with 0xff is a nop when the result and left are the same */
if(p>=0) {
/* only one bit is set in the literal, so use a bcf instruction */
pic14_emitcode("bcf","%s,%d",aopGet(AOP(left),offset,FALSE,TRUE),p);
- //emitpcode(POC_BCF,popGet(AOP(left),offset,FALSE,TRUE));
emitpcode(POC_BCF,newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
} else {
if(know_W != (lit&0xff))
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
know_W = lit &0xff;
- emitpcode(POC_ANDWF,popGet(AOP(left),offset,FALSE,TRUE));
+ emitpcode(POC_ANDWF,popGet(AOP(left),offset));
}
}
}
} else {
if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_ANDFW,popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_ANDFW,popGet(AOP(right),offset));
} else {
- emitpcode(POC_MOVFW,popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_ANDWF,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_ANDWF,popGet(AOP(left),offset));
}
}
case 0x00:
pic14_emitcode("clrf","%s",
aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_CLRF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF,popGet(AOP(result),offset));
break;
case 0xff:
pic14_emitcode("movf","%s,w",
aopGet(AOP(left),offset,FALSE,FALSE));
pic14_emitcode("movwf","%s",
aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
break;
default:
pic14_emitcode("movlw","0x%x",t);
aopGet(AOP(result),offset,FALSE,FALSE));
emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_ANDFW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
}
continue;
}
if (AOP_TYPE(left) == AOP_ACC) {
pic14_emitcode("andwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_ANDFW,popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_ANDFW,popGet(AOP(right),offset));
} else {
pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
pic14_emitcode("andwf","%s,w",
aopGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVFW,popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_ANDFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_ANDFW,popGet(AOP(left),offset));
}
pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
}
}
}
aopOp((right= IC_RIGHT(ic)),ic,FALSE);
aopOp((result=IC_RESULT(ic)),ic,TRUE);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
/* if left is a literal & right is not then exchange them */
if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
left = tmp;
}
- DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
- AopType(AOP_TYPE(result)),
- AopType(AOP_TYPE(left)),
- AopType(AOP_TYPE(right)));
+ DEBUGpic14_AopType(__LINE__,left,right,result);
if(AOP_TYPE(right) == AOP_LIT)
lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
// lit != 0 => result = 1
if(AOP_TYPE(result) == AOP_CRY){
if(size)
- emitpcode(POC_BSF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
//pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
// AOP(result)->aopu.aop_dir,
// AOP(result)->aopu.aop_dir);
if (AOP_TYPE(right) == AOP_CRY){
if(pic14_sameRegs(AOP(result),AOP(left))){
// c = bit | bit;
- emitpcode(POC_BCF, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_BTFSC, popGet(AOP(right),0,FALSE,FALSE));
- emitpcode(POC_BSF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
AOP(result)->aopu.aop_dir,
} else {
if( AOP_TYPE(result) == AOP_ACC) {
emitpcode(POC_MOVLW, popGetLit(0));
- emitpcode(POC_BTFSS, popGet(AOP(right),0,FALSE,FALSE));
- emitpcode(POC_BTFSC, popGet(AOP(left),0,FALSE,FALSE));
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
emitpcode(POC_MOVLW, popGetLit(1));
} else {
- emitpcode(POC_BCF, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_BTFSS, popGet(AOP(right),0,FALSE,FALSE));
- emitpcode(POC_BTFSC, popGet(AOP(left),0,FALSE,FALSE));
- emitpcode(POC_BSF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
AOP(result)->aopu.aop_dir,
pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
- emitpcode(POC_BCF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BCF, popGet(AOP(result),0));
if( AOP_TYPE(right) == AOP_ACC) {
emitpcode(POC_IORLW, popGetLit(0));
emitSKPNZ;
- emitpcode(POC_BTFSC, popGet(AOP(left),0,FALSE,FALSE));
- emitpcode(POC_BSF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
}
if(know_W != (lit & 0xff))
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
know_W = lit & 0xff;
- emitpcode(POC_IORWF, popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_IORWF, popGet(AOP(left),offset));
}
}
} else {
if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_IORFW, popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_IORFW, popGet(AOP(right),offset));
pic14_emitcode("iorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
} else {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_IORWF, popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_IORWF, popGet(AOP(left),offset));
pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
pic14_emitcode("iorwf","%s,f",aopGet(AOP(left),offset,FALSE,FALSE));
int t = (lit >> (offset*8)) & 0x0FFL;
switch(t) {
case 0x00:
- emitpcode(POC_MOVFW, popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
pic14_emitcode("movf","%s,w",
aopGet(AOP(left),offset,FALSE,FALSE));
break;
default:
emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_IORFW, popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_IORFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
pic14_emitcode("movlw","0x%x",t);
pic14_emitcode("iorwf","%s,w",
// faster than result <- left, anl result,right
// and better if result is SFR
if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_IORWF, popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_IORWF, popGet(AOP(right),offset));
pic14_emitcode("iorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
} else {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_IORFW, popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_IORFW, popGet(AOP(left),offset));
pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
pic14_emitcode("iorwf","%s,w",
aopGet(AOP(left),offset,FALSE,FALSE));
}
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
}
}
aopPut(AOP(result),"a",offset);
} else {
emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_XORWF,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_XORWF,popGet(AOP(left),offset));
pic14_emitcode("xrl","%s,%s",
aopGet(AOP(left),offset,FALSE,TRUE),
aopGet(AOP(right),offset,FALSE,FALSE));
if (AOP_TYPE(left) == AOP_ACC)
pic14_emitcode("xrl","a,%s",aopGet(AOP(right),offset,FALSE,FALSE));
else {
- emitpcode(POC_MOVFW,popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_XORWF,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_XORWF,popGet(AOP(left),offset));
/*
if (IS_AOP_PREG(left)) {
pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
int t = (lit >> (offset*8)) & 0x0FFL;
switch(t) {
case 0x00:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
pic14_emitcode("movf","%s,w",
aopGet(AOP(left),offset,FALSE,FALSE));
pic14_emitcode("movwf","%s",
aopGet(AOP(result),offset,FALSE,FALSE));
break;
case 0xff:
- emitpcode(POC_COMFW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_COMFW,popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
pic14_emitcode("comf","%s,w",
aopGet(AOP(left),offset,FALSE,FALSE));
pic14_emitcode("movwf","%s",
break;
default:
emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_XORFW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_XORFW,popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
pic14_emitcode("movlw","0x%x",t);
pic14_emitcode("xorwf","%s,w",
aopGet(AOP(left),offset,FALSE,FALSE));
// faster than result <- left, anl result,right
// and better if result is SFR
if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_XORFW,popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
pic14_emitcode("xorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
} else {
- emitpcode(POC_MOVFW,popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_XORFW,popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_XORFW,popGet(AOP(left),offset));
pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
pic14_emitcode("xorwf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));
}
if ( AOP_TYPE(result) != AOP_ACC){
- emitpcode(POC_MOVWF,popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
}
}
switch(shCount) {
case 1:
- emitpcode(POC_RLFW, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
if(same)
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
}
break;
case 1:
emitCLRC;
if(same)
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
}
break;
case 2:
emitCLRC;
if(same) {
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
} else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
}
emitCLRC;
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
break;
case 3:
if(same)
- emitpcode(POC_SWAPF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
else {
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
}
- emitpcode(POC_RLFW, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLFW, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
emitpcode(POC_ANDLW, popGetLit(0x1f));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
break;
case 4:
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
emitpcode(POC_ANDLW, popGetLit(0x0f));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
break;
case 5:
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
emitpcode(POC_ANDLW, popGetLit(0x0f));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
emitCLRC;
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
break;
case 6:
- emitpcode(POC_RLFW, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
emitpcode(POC_ANDLW, popGetLit(0x80));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
break;
case 7:
- emitpcode(POC_RLFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_CLRF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
break;
switch(shCount) {
case 1:
/* Shift left 1 bit position */
- emitpcode(POC_MOVFW, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
if(same) {
- emitpcode(POC_ADDWF, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(left),offl));
} else {
- emitpcode(POC_ADDFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_ADDFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
}
break;
case 2:
- emitpcode(POC_RLFW, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
emitpcode(POC_ANDLW,popGetLit(0x7e));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
break;
case 3:
- emitpcode(POC_RLFW, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
emitpcode(POC_ANDLW,popGetLit(0x3e));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
break;
case 4:
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
break;
case 5:
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
break;
case 6:
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
emitpcode(POC_ANDLW, popGetLit(0x30));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
break;
case 7:
- emitpcode(POC_RRFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_CLRF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
break;
default:
aopPut(AOP(result),"a",offr);
} else {
if(!sign) {
- emitpcode(POC_MOVFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
//aopPut(AOP(result),l,offr);
}else{
case 2:
case 3:
- emitpcode(POC_MOVFW,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
while(--shCount) {
emitCLRC;
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
}
break;
case 4:
case 5:
emitpcode(POC_MOVLW, popGetLit(0x0f));
- emitpcode(POC_ANDWF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_SWAPF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ANDFW, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_XORWF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_ANDWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ emitpcode(POC_ANDFW, popGet(AOP(result),offr));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
if(shCount >=5) {
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
}
break;
case 6:
- emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
emitpcode(POC_ANDLW,popGetLit(0xc0));
- emitpcode(POC_XORFW,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_XORWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_XORFW,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
break;
case 7:
- emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRFW, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_CLRF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
}
} else {
case 3:
/* note, use a mov/add for the shift since the mov has a
chance of getting optimized out */
- emitpcode(POC_MOVFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
while(--shCount) {
emitCLRC;
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
}
break;
case 4:
case 5:
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16,FALSE,FALSE));
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
emitpcode(POC_ANDLW, popGetLit(0xF0));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
emitpcode(POC_ANDLW, popGetLit(0xF0));
- emitpcode(POC_XORWF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
if(shCount == 5) {
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
}
break;
case 6:
- emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRFW, popGet(AOP(result),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
-
- emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(result),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
emitpcode(POC_ANDLW,popGetLit(0xc0));
- emitpcode(POC_XORFW,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_XORWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_XORFW,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
break;
case 7:
- emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16,FALSE,FALSE));
- emitpcode(POC_RRFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_CLRF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
}
}
case 3:
emitCLRC;
if(same) {
- emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF,popGet(AOP(result),offr));
} else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
}
while(--shCount) {
emitCLRC;
- emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF,popGet(AOP(result),offr));
}
break;
case 4:
if(same) {
emitpcode(POC_MOVLW, popGetLit(0xf0));
- emitpcode(POC_ANDWF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_SWAPF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_ANDWF, popGet(AOP(result),offr));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
- emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_ANDFW, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
} else {
- emitpcode(POC_SWAPF, popGet(AOP(left),offl,FALSE,FALSE));
+ emitpcode(POC_SWAPF, popGet(AOP(left),offl));
emitpcode(POC_ANDLW, popGetLit(0x0f));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- emitpcode(POC_SWAPF, popGet(AOP(left),offl+MSB16,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_SWAPF, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
}
if(shCount >=5) {
- emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
}
break;
case 6:
if(same) {
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RLFW, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
emitpcode(POC_ANDLW,popGetLit(0x03));
- emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_XORWF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
} else {
- emitpcode(POC_RLFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RLFW, popGet(AOP(result),offl+MSB16,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_RLFW, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLFW, popGet(AOP(result),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
emitpcode(POC_ANDLW,popGetLit(0x03));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
}
break;
case 7:
- emitpcode(POC_RLFW, popGet(AOP(left),offl,FALSE,FALSE));
- emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr,FALSE,FALSE));
- emitpcode(POC_CLRF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
}
}
}
else
movLeft2Result(left, LSB, result, MSB16, 0);
}
- emitpcode(POC_CLRF,popGet(AOP(result),LSB,FALSE,FALSE));
+ emitpcode(POC_CLRF,popGet(AOP(result),LSB));
}
/* 1 <= shCount <= 7 */
/* if it is only one byte then */
if (size == 1) {
if(optimized_for_speed) {
- emitpcode(POC_SWAPFW, popGet(AOP(left),0,FALSE,FALSE));
+ emitpcode(POC_SWAPFW, popGet(AOP(left),0));
emitpcode(POC_ANDLW, popGetLit(0xf0));
emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),2,0));
- emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
- emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_RLFW, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
+ emitpcode(POC_RLFW, popGet(AOP(result),0));
emitpcode(POC_ANDLW, popGetLit(0xfe));
- emitpcode(POC_ADDFW, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_ADDFW, popGet(AOP(result),0));
emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),1,0));
- emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
} else {
tlbl = newiTempLabel(NULL);
if (!pic14_sameRegs(AOP(left),AOP(result))) {
- emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
}
- emitpcode(POC_COMFW, popGet(AOP(right),0,FALSE,FALSE));
- emitpcode(POC_RRF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_COMFW, popGet(AOP(right),0));
+ emitpcode(POC_RRF, popGet(AOP(result),0));
emitpLabel(tlbl->key);
- emitpcode(POC_RLF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
emitpcode(POC_ADDLW, popGetLit(1));
emitSKPC;
emitpcode(POC_GOTO,popGetLabel(tlbl->key));
if(sign)
addSign(result, MSB16, sign);
else
- emitpcode(POC_CLRF,popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_CLRF,popGet(AOP(result),MSB16));
}
*/
tlbl = newiTempLabel(NULL);
if (!pic14_sameRegs(AOP(left),AOP(result))) {
- emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
}
- emitpcode(POC_COMFW, popGet(AOP(right),0,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_COMFW, popGet(AOP(right),0));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
emitpLabel(tlbl->key);
- emitpcode(POC_RRF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_RRF, popGet(AOP(result),0));
emitpcode(POC_ADDLW, popGetLit(1));
emitSKPC;
emitpcode(POC_GOTO,popGetLabel(tlbl->key));
aopOp(result,ic,TRUE);
- emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,TRUE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
size = AOP_SIZE(result);
while (size--) {
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,TRUE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
offset++;
}
aopOp(result,ic,FALSE);
- DEBUGpic14_emitcode ("; ","result %s, left %s",
- AopType(AOP_TYPE(result)),
- AopType(AOP_TYPE(left)));
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
/* if the operand is already in dptr
then we do nothing else we move the value to dptr */
while(size--) {
emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset++,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset++));
if(size)
emitpcode(POC_INCF,popCopyReg(&pc_fsr));
}
pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
pic14_emitcode("movwf","%s",buffer);
- emitpcode(POC_MOVFW, popGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
emitpcode(POC_MOVWF, popRegFromString(buffer));
}
aopOp(right,ic,FALSE);
size = AOP_SIZE(right);
- DEBUGpic14_emitcode ("; ","result %s=%s, right %s=%s, size = %d",
- AopType(AOP_TYPE(result)),
- aopGet(AOP(result),0,TRUE,FALSE),
- AopType(AOP_TYPE(right)),
- aopGet(AOP(right),0,FALSE,FALSE),
- size);
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
/* if the operand is already in dptr
then we do nothing else we move the value to dptr */
}
while(size--) {
- emitpcode(POC_MOVFW,popGet(AOP(right),offset++,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset++));
emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
if(size)
aopOp((right=IC_RIGHT(ic)),ic,FALSE);
aopOp((result=IC_RESULT(ic)),ic,TRUE);
- if(result)
- DEBUGpic14_emitcode ("; ","result %s",
- AopType(AOP_TYPE(IC_RESULT(ic))));
+ DEBUGpic14_AopType(__LINE__,left,right,result);
- if(left)
- DEBUGpic14_emitcode ("; ","left %s",
- AopType(AOP_TYPE(IC_LEFT(ic))));
- if(right)
- DEBUGpic14_emitcode ("; ","right %s",
- AopType(AOP_TYPE(IC_RIGHT(ic))));
-
- emitpcode(POC_MOVLW, popGet(AOP(left),0,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_MOVLW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
#if 0
/* object not on stack then we need the name */
aopOp(right,ic,FALSE);
aopOp(result,ic,TRUE);
- DEBUGpic14_emitcode ("; ","result %s, right %s, size = %d",
- AopType(AOP_TYPE(IC_RESULT(ic))),
- AopType(AOP_TYPE(IC_RIGHT(ic))),
- AOP_SIZE(result));
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
/* if they are the same registers */
if (pic14_sameRegs(AOP(right),AOP(result)))
if (AOP_TYPE(right) == AOP_LIT) {
emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
- popGet(AOP(result),0,FALSE,FALSE));
+ popGet(AOP(result),0));
if (((int) operandLitValue(right)))
pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
/* the right is also a bit variable */
if (AOP_TYPE(right) == AOP_CRY) {
- emitpcode(POC_BCF, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_BTFSC, popGet(AOP(right),0,FALSE,FALSE));
- emitpcode(POC_BSF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
AOP(result)->aopu.aop_dir,
}
/* we need to or */
- emitpcode(POC_BCF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BCF, popGet(AOP(result),0));
pic14_toBoolean(right);
emitSKPZ;
- emitpcode(POC_BSF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
//aopPut(AOP(result),"a",0);
goto release ;
}
if( AOP_TYPE(right) == AOP_DIR && (AOP_TYPE(result) == AOP_REG) && size==1) {
if(aopIdx(AOP(result),0) == 4) {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
goto release;
} else
DEBUGpic14_emitcode ("; WARNING","%s %d ignoring register storage",__FUNCTION__,__LINE__);
if(know_W != (lit&0xff))
emitpcode(POC_MOVLW,popGetLit(lit&0xff));
know_W = lit&0xff;
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
} else
- emitpcode(POC_CLRF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
lit >>= 8;
} else if (AOP_TYPE(right) == AOP_CRY) {
- emitpcode(POC_CLRF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
if(offset == 0) {
- emitpcode(POC_BTFSS, popGet(AOP(right),0,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
}
} else {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
}
offset++;
pic14_emitcode("","%05d_DS_:",jtab->key+100);
emitpcode(POC_MOVLW, popGetLabel(jtab->key));
- emitpcode(POC_ADDFW, popGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE));
+ emitpcode(POC_ADDFW, popGet(AOP(IC_JTCOND(ic)),0));
emitSKPNC;
emitpcode(POC_INCF, popCopyReg(&pc_pclath));
emitpcode(POC_MOVWF, popCopyReg(&pc_pcl));
aopOp(right,ic,FALSE) ;
aopOp(result,ic,FALSE);
+ DEBUGpic14_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
if (AOP_TYPE(right) == AOP_LIT) {
emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
- popGet(AOP(result),0,FALSE,FALSE));
+ popGet(AOP(result),0));
if (((int) operandLitValue(right)))
pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
if (AOP_TYPE(right) == AOP_CRY) {
emitCLRC;
- emitpcode(POC_BTFSC, popGet(AOP(right),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
pic14_emitcode("clrc","");
pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
}
/* we need to or */
- pic14_toBoolean(right);
- aopPut(AOP(result),"a",0);
+ if (AOP_TYPE(right) == AOP_REG) {
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+ }
+ pic14_toBoolean(right);
+ 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);
+
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+
+ while (size--)
+ emitpcode(POC_CLRF, popGet(AOP(result),offset++));
+
+ goto release;
+ }
+
/* if they are the same size : or less */
if (AOP_SIZE(result) <= AOP_SIZE(right)) {
}
- if (AOP_TYPE(right) == AOP_CRY) {
- int offset = 1;
- size = AOP_SIZE(right);
-
- emitpcode(POC_CLRF, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_BTFSC, popGet(AOP(right),0,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
-
- pic14_emitcode("clrf","%s ; %d", aopGet(AOP(result),0,FALSE,FALSE),__LINE__);
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
- pic14_emitcode("incf","%s,f", aopGet(AOP(result),0,FALSE,FALSE),__LINE__);
- while (size--) {
- pic14_emitcode("clrf","%s;%d", aopGet(AOP(result),offset,FALSE,FALSE),__LINE__);
- emitpcode(POC_CLRF, popGet(AOP(result),offset++,FALSE,FALSE));
- }
- goto release;
- }
/* so we now know that the size of destination is greater
than the size of the source.
/* aopPut(AOP(result),
aopGet(AOP(right),offset,FALSE,FALSE),
offset); */
- emitpcode(POC_MOVFW, popGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
offset++;
}
/* if unsigned or not an integral type */
if (SPEC_USIGN(ctype) || !IS_SPEC(ctype)) {
while (size--) {
- emitpcode(POC_CLRF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
pic14_emitcode("clrf","%s ;%d",aopGet(AOP(result),offset,FALSE,FALSE),__LINE__);
offset++;
}
AOP(right)->aopu.aop_dir);
pic14_emitcode("movlw","0xff");
while (size--) {
- emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
offset++;
// aopPut(AOP(result),"a",offset++);
} else {
- emitpcode(POC_DECFSZ,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_DECFSZ,popGet(AOP(IC_RESULT(ic)),0));
emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
pic14_emitcode("decfsz","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
int offset = MSB16;
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),LSB));
//pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
while(--size) {
emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++));
//pic14_emitcode(" incf","%s,f",aopGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
}
if( strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") &&
(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) ) {
- emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
AOP(IC_RESULT(ic))->aopu.aop_dir,
AOP(IC_RESULT(ic))->aopu.aop_dir);
//pic14_emitcode("andlw","1");
emitSKPZ;
- emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0));
pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
AOP(IC_RESULT(ic))->aopu.aop_dir,
AOP(IC_RESULT(ic))->aopu.aop_dir);
if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
while (icount--)
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
//pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
return TRUE ;
switch(AOP_TYPE(IC_RESULT(ic))) {
case AOP_ACC:
emitpcode(POC_CLRW, NULL);
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
emitpcode(POC_XORLW, popGetLit(1));
- emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
emitpcode(POC_XORLW, popGetLit(1));
pic14_emitcode("clrw","");
break;
case AOP_REG:
emitpcode(POC_MOVLW, popGetLit(0));
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
emitpcode(POC_XORLW, popGetLit(1));
- emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
emitpcode(POC_XORLW, popGetLit(1));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
break;
default:
- emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
pic14_emitcode("movlw","(1 << (%s & 7))",
AOP(IC_RESULT(ic))->aopu.aop_dir,
case 0:
break;
case 1:
- emitpcode(POC_INCF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),offr));
break;
case 0xff:
- emitpcode(POC_DECF, popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(result),offr));
break;
default:
emitpcode(POC_MOVLW,popGetLit(lit&0xff));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr,FALSE,FALSE));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
}
}
return;
}
- emitpcode(POC_MOVWF, popGet(AOP(reg),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(reg),offset));
}
case 0:
break;
case 1:
- emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
break;
case 0xff:
- emitpcode(POC_DECF, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(result),0));
+ emitpcode(POC_INCFSZW, popGet(AOP(result),0));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
break;
default:
emitpcode(POC_MOVLW,popGetLit(lit&0xff));
- emitpcode(POC_ADDWF,popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_ADDWF,popGet(AOP(result),0));
emitSKPNC;
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
}
DEBUGpic14_emitcode ("; hi = 1","%s %d",__FUNCTION__,__LINE__);
switch(lo) {
case 0: /* 0x0100 */
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
break;
case 1: /* 0x0101 */
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
break;
case 0xff: /* 0x01ff */
- emitpcode(POC_DECF, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(result),0));
+ emitpcode(POC_INCFSZW, popGet(AOP(result),0));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
}
break;
/* lit = 0xffLL */
switch(lo) {
case 0: /* 0xff00 */
- emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16));
break;
case 1: /*0xff01 */
- emitpcode(POC_INCFSZ, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_INCFSZ, popGet(AOP(result),0));
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16));
break;
/* case 0xff: * 0xffff *
emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
*/
default:
emitpcode(POC_MOVLW,popGetLit(lo));
- emitpcode(POC_ADDWF,popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_ADDWF,popGet(AOP(result),0));
emitSKPC;
- emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16));
}
break;
case 1: /* 0xHH01 */
emitpcode(POC_MOVLW,popGetLit((hi+1)&0xff));
- emitpcode(POC_INCFSZ, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_INCFSZ, popGet(AOP(result),0));
emitpcode(POC_MOVLW,popGetLit(hi));
- emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
break;
/* case 0xff: * 0xHHff *
emitpcode(POC_MOVFW, popGet(AOP(result),0,FALSE,FALSE));
break;
*/ default: /* 0xHHLL */
emitpcode(POC_MOVLW,popGetLit(lo));
- emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
emitpcode(POC_MOVLW,popGetLit(hi));
emitSKPNC;
emitpcode(POC_MOVLW,popGetLit((hi+1) & 0xff));
- emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
break;
}
switch(carry_info) {
case 1:
emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),offset));
break;
case 2:
- emitpcode(POC_RLFW, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_RLFW, popGet(AOP(result),offset));
emitpcode(POC_ANDLW,popGetLit(1));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
break;
default: /* carry_info = 3 */
emitSKPNC;
- emitpcode(POC_INCF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),offset));
carry_info = 1;
break;
}
emitSKPZ;
else
emitSKPC;
- emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
break;
default:
emitpcode(POC_MOVLW,popGetLit(lo));
else
emitSKPNC;
emitpcode(POC_MOVLW,popGetLit(lo+1));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
carry_info=2;
break;
}
case 0:
break;
case 1:
- emitpcode(POC_INCF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),offset));
carry_info=1;
break;
default:
emitpcode(POC_MOVLW,popGetLit(lo));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
if(lit <0x100)
carry_info = 3; /* Were adding only one byte and propogating the carry */
else
/* left addend is in a register */
switch(lit & 0xff) {
case 0:
- emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
emitMOVWF(result, 0);
//emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
emitMOVWF(result,0);
break;
case 1:
- emitpcode(POC_INCFW, popGet(AOP(left),0,FALSE,FALSE));
+ emitpcode(POC_INCFW, popGet(AOP(left),0));
//emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
emitMOVWF(result,0);
break;
case 0xff:
- emitpcode(POC_DECFW, popGet(AOP(left),0,FALSE,FALSE));
+ emitpcode(POC_DECFW, popGet(AOP(left),0));
//emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
emitMOVWF(result,0);
break;
default:
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_ADDFW, popGet(AOP(left),0,FALSE,FALSE));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0));
//emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
emitMOVWF(result,0);
}
/* left is not the accumulator */
if(lit & 0xff) {
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_ADDFW, popGet(AOP(left),0,FALSE,FALSE));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0));
} else
- emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
//emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
emitMOVWF(result,0);
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
//emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
emitMOVWF(result,offset);
- emitpcode(POC_MOVFW, popGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
emitSKPNC;
- emitpcode(POC_INCFSZW,popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
} else {
- emitpcode(POC_CLRF, popGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_RLF, popGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_MOVFW, popGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
+ emitpcode(POC_RLF, popGet(AOP(result),offset));
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
}
offset++;
}
/* if result in bit space */
if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
if((unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit) != 0L) {
- emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
- emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
}
} else {
size = pic14_getDataSize(IC_RESULT(ic));
if(size == 1) {
if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_INCF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCF , popGet(AOP(IC_RESULT(ic)),0));
pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
AOP(IC_RIGHT(ic))->aopu.aop_dir,
} else {
if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
emitpcode(POC_XORLW , popGetLit(1));
pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
AOP(IC_RIGHT(ic))->aopu.aop_dir);
pic14_emitcode(" xorlw","1");
} else {
- emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_INCFW , popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCFW , popGet(AOP(IC_LEFT(ic)),0));
pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
emitpcode(POC_ANDLW , popGetLit(1));
- emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
emitSKPZ;
- emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
} else {
- emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
}
}
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
emitCLRZ;
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
pic14_emitcode("clrz","");
} else {
- emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_INCFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCFW, popGet(AOP(IC_LEFT(ic)),0));
//emitpcode(POC_MOVWF, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
emitMOVWF(IC_RIGHT(ic),0);
while(--size){
emitSKPZ;
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++));
//pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RIGHT(ic)),offset++,FALSE,FALSE));
}
} else {
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
- emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
} else {
if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
- emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
} else {
- emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0));
else {
if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
(AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
- emitpcode(POC_ADDLW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_ADDLW, popGet(AOP(IC_LEFT(ic)),0));
} else {
- emitpcode(POC_ADDFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_ADDFW, popGet(AOP(IC_LEFT(ic)),0));
if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
}
}
}
while(size--){
if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
- emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
}
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
emitSKPNC;
- emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),offset));
/*
pic14_emitcode("movf","%s,w", aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
(icount == 1)) {
if(size == 2) {
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
- emitpcode(POC_INCFSZW, popGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),LSB));
+ emitpcode(POC_INCFSZW, popGet(AOP(IC_RESULT(ic)),LSB));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),MSB16));
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),MSB16));
pic14_emitcode("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
pic14_emitcode("incfsz","%s,w",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
} else {
/* size is 3 or 4 */
emitpcode(POC_MOVLW, popGetLit(0xff));
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),LSB));
emitSKPNC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB16));
emitSKPNC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB24));
pic14_emitcode("movlw","0xff");
pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
if(size > 3) {
emitSKPNC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB32,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB32));
pic14_emitcode("skpnc","");
emitSKPNC;
if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
while (icount--)
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),0));
//pic14_emitcode ("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
pic14_emitcode("decf","%s,w",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- emitpcode(POC_DECFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_DECFW, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
return TRUE;
}
pic14_emitcode("movlw","0x%x", lit & 0xff);
pic14_emitcode("addwf","%s,f", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0));
offset = 1;
if((lit & 0xff) == 0xff) {
emitpcode(POC_MOVLW, popGetLit(0xff));
emitSKPC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
} else {
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
emitSKPNC;
emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
}
} else {
/* do the rlf known zero trick here */
emitpcode(POC_MOVLW, popGetLit(1));
emitSKPNC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
}
offset++;
}
if(size == 1) {
if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_DECF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_DECF , popGet(AOP(IC_RESULT(ic)),0));
pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
AOP(IC_RIGHT(ic))->aopu.aop_dir,
} else {
if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
emitpcode(POC_XORLW , popGetLit(1));
}else if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
(AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
if(lit & 1) {
- emitpcode(POC_MOVLW , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_XORWF , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVLW , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_XORWF , popGet(AOP(IC_RIGHT(ic)),0));
}
}else{
- emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
if(lit & 1)
- emitpcode(POC_BTFSS , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSS , popGet(AOP(IC_RIGHT(ic)),0));
else
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
}
goto release;
} else {
emitpcode(POC_MOVLW , popGetLit(lit & 0xff));
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
emitpcode(POC_MOVLW , popGetLit((lit-1) & 0xff));
- emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
}
} else {
- emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_DECFW , popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_DECFW , popGet(AOP(IC_LEFT(ic)),0));
}
if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
- emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
} else {
emitpcode(POC_ANDLW , popGetLit(1));
if( (size == 1) && ((lit & 0xff) == 0) ) {
/* res = 0 - right */
if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
- emitpcode(POC_COMF, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_COMF, popGet(AOP(IC_RIGHT(ic)),0));
} else {
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
}
goto release;
}
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),0));
emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
offset = 1;
if(lit == 0xff) {
/* 0xff - x == ~x */
if(same) {
- emitpcode(POC_COMF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_COMF, popGet(AOP(IC_RESULT(ic)),offset));
emitSKPC;
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
} else {
- emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
emitSKPC;
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
}
} else {
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
emitSKPC;
- emitpcode(POC_INCFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_INCFW, popGet(AOP(IC_RIGHT(ic)),offset));
emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
}
goto release;
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
emitSKPC;
emitpcode(POC_MOVLW, popGetLit((lit & 0xff)-1));
- emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
} else {
emitSKPNC;
- emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
}
} else {
if(lit & 0xff) {
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
} else
- emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
emitSKPC;
- emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
- emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
}
}
if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
emitpcode(POC_SUBLW, popGetLit(0));
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
} else {
if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
- emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
emitpcode(POC_SUBLW, popGetLit(0));
if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
} else {
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(AOP_TYPE(IC_RIGHT(ic)) != AOP_ACC)
- emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
- emitpcode(POC_SUBWF, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_SUBWF, popGet(AOP(IC_LEFT(ic)),0));
else {
if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
(AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
- emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),0));
} else {
- emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),0));
}
if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
if ( AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
- emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
emitSKPZ;
- emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
}else
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
}
}
}
while(size--){
if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
- emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
}
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
emitSKPC;
- emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
- emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+ emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
offset++;
}