/*-------------------------------------------------------------------------
- SDCCgen51.c - source file for code generation for 8051
+ gen.c - source file for code generation for pic
Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
and - Jean-Louis VERN.jlvern@writeme.com (1999)
#include "SDCCglobl.h"
#include "newalloc.h"
-#ifdef HAVE_SYS_ISA_DEFS_H
-#include <sys/isa_defs.h>
-#else
-#ifdef HAVE_MACHINE_ENDIAN_H
-#include <machine/endian.h>
-#else
-#ifdef HAVE_ENDIAN_H
-#include <endian.h>
-#else
-#if !defined(__BORLANDC__) && !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-#warning "Cannot determine ENDIANESS of this machine assuming LITTLE_ENDIAN"
-#warning "If you running sdcc on an INTEL 80x86 Platform you are okay"
-#endif
-#endif
-#endif
-#endif
-
#include "common.h"
#include "SDCCpeeph.h"
#include "ralloc.h"
extern void genUMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
extern void genSMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
void genMult8X8_8 (operand *, operand *,operand *);
+pCode *AssembleLine(char *line);
+extern void printpBlock(FILE *of, pBlock *pb);
static int labelOffset=0;
-static int debug_verbose=1;
+extern int debug_verbose;
static int optimized_for_speed = 0;
/* max_key keeps track of the largest label number used in
static int max_key=0;
static int GpsuedoStkPtr=0;
-pCodeOp *popGetImmd(char *name, unsigned int offset, int index);
+pCodeOp *popGetImmd(char *name, unsigned int offset, int index,int is_func);
unsigned int pic14aopLiteral (value *val, int offset);
const char *AopType(short type);
static iCode *ifxForOp ( operand *op, iCode *ic );
void emitpcode(PIC_OPCODE poc, pCodeOp *pcop)
{
-
if(pcop)
addpCode2pBlock(pb,newpCode(poc,pcop));
else
}
+void emitpcodePagesel(const char *label)
+{
+
+ char code[81];
+ strcpy(code,"\tpagesel ");
+ strcat(code,label);
+ addpCode2pBlock(pb,newpCodeInlineP(code));
+
+}
+
/*-----------------------------------------------------------------*/
/* pic14_emitcode - writes the code into a file : for now it is simple */
/*-----------------------------------------------------------------*/
if(!resIfx)
return;
- DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ // DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
resIfx->condition = 1; /* assume that the ifx is true */
resIfx->generated = 0; /* indicate that the ifx has not been used */
if(!ifx) {
resIfx->lbl = newiTempLabel(NULL); /* oops, there is no ifx. so create a label */
+/*
DEBUGpic14_emitcode("; ***","%s %d null ifx creating new label key =%d",
__FUNCTION__,__LINE__,resIfx->lbl->key);
+*/
} else {
if(IC_TRUE(ifx)) {
resIfx->lbl = IC_TRUE(ifx);
resIfx->lbl = IC_FALSE(ifx);
resIfx->condition = 0;
}
+/*
if(IC_TRUE(ifx))
DEBUGpic14_emitcode("; ***","ifx true is non-null");
if(IC_FALSE(ifx))
DEBUGpic14_emitcode("; ***","ifx false is non-null");
+*/
}
- DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
+ // DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
}
/*-----------------------------------------------------------------*/
/* special case for a function */
if (IS_FUNC(sym->type)) {
+
+ sym->aop = aop = newAsmop(AOP_PCODE);
+ aop->aopu.pcop = popGetImmd(sym->rname,0,0,1);
+ PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
+ PCOI(aop->aopu.pcop)->_function = 1;
+ PCOI(aop->aopu.pcop)->index = 0;
+ aop->size = FPTRSIZE;
+ /*
sym->aop = aop = newAsmop(AOP_IMMD);
- //_ALLOC_ATOMIC(aop->aopu.aop_immd,strlen(sym->rname)+1);
aop->aopu.aop_immd = Safe_calloc(1,strlen(sym->rname)+1);
strcpy(aop->aopu.aop_immd,sym->rname);
aop->size = FPTRSIZE;
+ */
DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
return aop;
}
/* in which case DPTR gets the address */
sym->aop = aop = newAsmop(AOP_PCODE);
- aop->aopu.pcop = popGetImmd(sym->rname,0,0);
+ aop->aopu.pcop = popGetImmd(sym->rname,0,0,0);
PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
PCOI(aop->aopu.pcop)->index = 0;
- DEBUGpic14_emitcode(";"," rname %s, val %d, const = %d",
- sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
allocDirReg (IC_LEFT(ic));
ic = sym->rematiCode;
- DEBUGpic14_emitcode(";","%s %d",__FUNCTION__,__LINE__);
-
- for (;;) {
- if (ic->op == '+') {
- val += (int) operandLitValue(IC_RIGHT(ic));
- } else if (ic->op == '-') {
- val -= (int) operandLitValue(IC_RIGHT(ic));
- } else
- break;
+ DEBUGpic14_emitcode(";","%s %d",__FUNCTION__,__LINE__);
+ if(IS_OP_POINTER(op)) {
+ DEBUGpic14_emitcode(";","%s %d IS_OP_POINTER",__FUNCTION__,__LINE__);
+ }
+ for (;;) {
+ if (ic->op == '+') {
+ val += (int) operandLitValue(IC_RIGHT(ic));
+ } else if (ic->op == '-') {
+ val -= (int) operandLitValue(IC_RIGHT(ic));
+ } else
+ break;
- ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
- }
+ ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
+ }
- offset = OP_SYMBOL(IC_LEFT(ic))->offset;
- aop->aopu.pcop = popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname,0,val);
- PCOI(aop->aopu.pcop)->_const = IS_PTR_CONST(operandType(op));
- PCOI(aop->aopu.pcop)->index = val;
+ offset = OP_SYMBOL(IC_LEFT(ic))->offset;
+ aop->aopu.pcop = popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname,0,val,0);
+#if 0
+ PCOI(aop->aopu.pcop)->_const = IS_PTR_CONST(operandType(op));
+#else
+ PCOI(aop->aopu.pcop)->_const = IS_CODEPTR(operandType(op));
+#endif
+ PCOI(aop->aopu.pcop)->index = val;
- DEBUGpic14_emitcode(";"," rname %s, val %d, const = %d",
- OP_SYMBOL(IC_LEFT(ic))->rname,
- val, IS_PTR_CONST(operandType(op)));
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,OP_SYMBOL(IC_LEFT(ic))->rname,
+ val, IS_PTR_CONST(operandType(op)));
- // DEBUGpic14_emitcode(";","aop type %s",AopType(AOP_TYPE(IC_LEFT(ic))));
+ // DEBUGpic14_emitcode(";","aop type %s",AopType(AOP_TYPE(IC_LEFT(ic))));
- allocDirReg (IC_LEFT(ic));
+ allocDirReg (IC_LEFT(ic));
- return aop;
+ return aop;
}
int aopIdx (asmop *aop, int offset)
{
sym_link *type = operandType(op);
+#if 0
if(IS_PTR_CONST(type))
+#else
+ if(IS_CODEPTR(type))
+#endif
DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
}
aop->size = getSize(sym->type);
for ( i = 0 ; i < 2 ; i++ )
aop->aopu.aop_str[i] = accUse[i];
- DEBUGpic14_emitcode(";","%d",__LINE__);
+ DEBUGpic14_emitcode(";","%d size=%d",__LINE__,aop->size);
return;
}
if (sym->ruonly ) {
- unsigned i;
- aop = op->aop = sym->aop = newAsmop(AOP_STR);
- aop->size = getSize(sym->type);
- for ( i = 0 ; i < fReturnSizePic ; i++ )
+ if(sym->isptr) { // && sym->uptr
+ aop = op->aop = sym->aop = newAsmop(AOP_PCODE);
+ aop->aopu.pcop = newpCodeOp(NULL,PO_GPR_POINTER); //popCopyReg(&pc_fsr);
+
+ //PCOI(aop->aopu.pcop)->_const = 0;
+ //PCOI(aop->aopu.pcop)->index = 0;
+ /*
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
+ */
+ //allocDirReg (IC_LEFT(ic));
+
+ aop->size = getSize(sym->type);
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ return;
+
+ } else {
+
+ unsigned i;
+
+ aop = op->aop = sym->aop = newAsmop(AOP_STR);
+ aop->size = getSize(sym->type);
+ for ( i = 0 ; i < fReturnSizePic ; i++ )
aop->aopu.aop_str[i] = fReturn[i];
+
DEBUGpic14_emitcode(";","%d",__LINE__);
- return;
+ return;
+ }
}
/* else spill location */
__FUNCTION__,__LINE__,
sym->usl.spillLoc->rname,
sym->rname, sym->usl.spillLoc->offset);
- // X sym->aop = op->aop = aop = aopForSym(ic,sym->usl.spillLoc,result);
+
sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
- aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
- //allocDirReg (IC_LEFT(ic));
+ //aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
+ aop->aopu.pcop = popRegFromString(sym->usl.spillLoc->rname,
+ getSize(sym->type),
+ sym->usl.spillLoc->offset);
aop->size = getSize(sym->type);
return;
{
sym_link *type = operandType(op);
+#if 0
if(IS_PTR_CONST(type))
+#else
+ if(IS_CODEPTR(type))
+#endif
DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
}
/* must be in a register */
+ DEBUGpic14_emitcode(";","%d register type nRegs=%d",__LINE__,sym->nRegs);
sym->aop = op->aop = aop = newAsmop(AOP_REG);
aop->size = sym->nRegs;
for ( i = 0 ; i < sym->nRegs ;i++)
return rs;
case AOP_STR:
- DEBUGpic14_emitcode(";","%d",__LINE__);
aop->coff = offset ;
if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
dname)
return "acc";
+ DEBUGpic14_emitcode(";","%d - %s",__LINE__, aop->aopu.aop_str[offset]);
return aop->aopu.aop_str[offset];
case AOP_PCODE:
{
pCodeOp *pcop = aop->aopu.pcop;
- DEBUGpic14_emitcode(";","%d: aopGet AOP_PCODE",__LINE__);
+ DEBUGpic14_emitcode(";","%d: aopGet AOP_PCODE type %s",__LINE__,pCodeOpType(pcop));
if(pcop->name) {
DEBUGpic14_emitcode(";","%s offset %d",pcop->name,PCOI(pcop)->offset);
//sprintf(s,"(%s+0x%02x)", pcop->name,PCOI(aop->aopu.pcop)->offset);
DEBUGpic14_emitcode ("; ***","%s key=%d, label offset %d",__FUNCTION__,key, labelOffset);
- if(key>max_key)
+ if(key>(unsigned int)max_key)
max_key = key;
return newpCodeOpLabel(NULL,key+100+labelOffset);
}
+/*-------------------------------------------------------------------*/
+/* popGetLabel - create a new pCodeOp of type PO_LABEL with offset=1 */
+/*-------------------------------------------------------------------*/
+pCodeOp *popGetHighLabel(unsigned int key)
+{
+ pCodeOp *pcop;
+ DEBUGpic14_emitcode ("; ***","%s key=%d, label offset %d",__FUNCTION__,key, labelOffset);
+
+ if(key>(unsigned int)max_key)
+ max_key = key;
+
+ pcop = newpCodeOpLabel(NULL,key+100+labelOffset);
+ PCOLAB(pcop)->offset = 1;
+ return pcop;
+}
+
/*-----------------------------------------------------------------*/
/* popCopyReg - copy a pcode operator */
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
/* popGetImmd - asm operator to pcode immediate conversion */
/*-----------------------------------------------------------------*/
-pCodeOp *popGetImmd(char *name, unsigned int offset, int index)
+pCodeOp *popGetImmd(char *name, unsigned int offset, int index,int is_func)
{
- return newpCodeOpImmd(name, offset,index, 0);
+ return newpCodeOpImmd(name, offset,index, 0, is_func);
}
return pcop;
}
-pCodeOp *popRegFromString(char *str)
+/*-----------------------------------------------------------------*/
+/* popRegFromString - */
+/*-----------------------------------------------------------------*/
+pCodeOp *popRegFromString(char *str, int size, int offset)
{
- pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOp) );
+ pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
pcop->type = PO_DIR;
DEBUGpic14_emitcode(";","%d",__LINE__);
- pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
+
+ if(!str)
+ str = "BAD_STRING";
+
+ pcop->name = Safe_calloc(1,strlen(str)+1);
+ strcpy(pcop->name,str);
+
+ //pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
+
+ PCOR(pcop)->r = 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);
+ PCOR(pcop)->r = allocRegByName (pcop->name,size);
+ DEBUGpic14_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
+ } else {
+ DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
+ }
+ PCOR(pcop)->instance = offset;
return pcop;
}
case AOP_IMMD:
DEBUGpic14_emitcode(";","%d",__LINE__);
- return popGetImmd(aop->aopu.aop_immd,offset,0);
+ return popGetImmd(aop->aopu.aop_immd,offset,0,0);
case AOP_DIR:
+ return popRegFromString(aop->aopu.aop_dir, aop->size, offset);
+#if 0
pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
pcop->type = PO_DIR;
if(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 = allocRegByName (aop->aopu.aop_dir,aop->size);
- }
-
- DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
+ DEBUGpic14_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
+ } else {
+ DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
+ }
PCOR(pcop)->instance = offset;
return pcop;
+#endif
case AOP_REG:
{
pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
PCOR(pcop)->rIdx = rIdx;
PCOR(pcop)->r = pic14_regWithIdx(rIdx);
+ PCOR(pcop)->r->wasUsed=1;
+ PCOR(pcop)->r->isFree=0;
+
PCOR(pcop)->instance = offset;
pcop->type = PCOR(pcop)->r->pc_type;
//rs = aop->aopu.aop_reg[offset]->name;
- //DEBUGpic14_emitcode(";","%d regiser idx = %d name =%s",__LINE__,rIdx,rs);
+ DEBUGpic14_emitcode(";","%d regiser idx = %d ",__LINE__,rIdx);
return pcop;
}
return newpCodeOpLit(pic14aopLiteral (aop->aopu.aop_lit,offset));
case AOP_STR:
- DEBUGpic14_emitcode(";","%d",__LINE__);
+ DEBUGpic14_emitcode(";","%d %s",__LINE__,aop->aopu.aop_str[offset]);
return newpCodeOpRegFromStr(aop->aopu.aop_str[offset]);
/*
pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
*/
case AOP_PCODE:
- DEBUGpic14_emitcode(";","popGet AOP_PCODE%d",__LINE__);
+ DEBUGpic14_emitcode(";","popGet AOP_PCODE (%s) %d %s",pCodeOpType(aop->aopu.pcop),
+ __LINE__,
+ ((aop->aopu.pcop->name)? (aop->aopu.pcop->name) : "no name"));
pcop = pCodeOpCopy(aop->aopu.pcop);
PCOI(pcop)->offset = offset;
return pcop;
emitpcode(POC_CLRF,popGet(aop,offset));
break;
} else
- emitpcode(POC_MOVLW,popGetImmd(s,offset,0));
+ emitpcode(POC_MOVLW,popGetImmd(s,offset,0,0));
}
emitpcode(POC_MOVWF,popGet(aop,offset));
else
*/
- if(strcmp(s,"W"))
+ if(strcmp(s,"W")==0 )
pic14_emitcode("movf","%s,w ; %d",s,__LINE__);
pic14_emitcode("movwf","%s",
aop->aopu.aop_reg[offset]->name);
- if(strcmp(s,"W")) {
+ if(strcmp(s,zero)==0) {
+ emitpcode(POC_CLRF,popGet(aop,offset));
+
+ } else if(strcmp(s,"W")==0) {
pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
pcop->type = PO_GPR_REGISTER;
DEBUGpic14_emitcode(";","%d",__LINE__);
pcop->name = Safe_strdup(s);
emitpcode(POC_MOVFW,pcop);
+ emitpcode(POC_MOVWF,popGet(aop,offset));
+ } else if(strcmp(s,one)==0) {
+ emitpcode(POC_CLRF,popGet(aop,offset));
+ emitpcode(POC_INCF,popGet(aop,offset));
+ } else {
+ emitpcode(POC_MOVWF,popGet(aop,offset));
}
- emitpcode(POC_MOVWF,popGet(aop,offset));
-
}
break;
}
+/*-----------------------------------------------------------------*/
+/* mov2w - generate either a MOVLW or MOVFW based operand type */
+/*-----------------------------------------------------------------*/
+void mov2w (asmop *aop, int offset)
+{
+
+ if(!aop)
+ return;
+
+ DEBUGpic14_emitcode ("; ***","%s %d offset=%d",__FUNCTION__,__LINE__,offset);
+
+ if ( aop->type == AOP_PCODE ||
+ aop->type == AOP_LIT ||
+ aop->type == AOP_IMMD )
+ emitpcode(POC_MOVLW,popGet(aop,offset));
+ else
+ emitpcode(POC_MOVFW,popGet(aop,offset));
+
+}
+
/*-----------------------------------------------------------------*/
/* reAdjustPreg - points a register back to where it should */
/*-----------------------------------------------------------------*/
}
-/*-----------------------------------------------------------------*/
-/* genNotFloat - generates not for float operations */
-/*-----------------------------------------------------------------*/
-static void genNotFloat (operand *op, operand *res)
-{
- int size, offset;
- char *l;
- symbol *tlbl ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* we will put 127 in the first byte of
- the result */
- aopPut(AOP(res),"#127",0);
- size = AOP_SIZE(op) - 1;
- offset = 1;
-
- l = aopGet(op->aop,offset++,FALSE,FALSE);
- MOVA(l);
-
- while(size--) {
- pic14_emitcode("orl","a,%s",
- aopGet(op->aop,
- offset++,FALSE,FALSE));
- }
- tlbl = newiTempLabel(NULL);
-
- tlbl = newiTempLabel(NULL);
- aopPut(res->aop,one,1);
- pic14_emitcode("jz","%05d_DS_",(tlbl->key+100));
- aopPut(res->aop,zero,1);
- pic14_emitcode("","%05d_DS_:",(tlbl->key+100));
-
- size = res->aop->size - 2;
- offset = 2;
- /* put zeros in the rest */
- while (size--)
- aopPut(res->aop,zero,offset++);
-}
#if 0
/*-----------------------------------------------------------------*/
static void genNot (iCode *ic)
{
symbol *tlbl;
- sym_link *optype = operandType(IC_LEFT(ic));
int size;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
goto release;
}
- /* if type float then do float */
- if (IS_FLOAT(optype)) {
- genNotFloat(IC_LEFT(ic),IC_RESULT(ic));
- goto release;
- }
-
- size = AOP_SIZE(IC_RESULT(ic));
+ size = AOP_SIZE(IC_LEFT(ic));
if(size == 1) {
emitpcode(POC_COMFW,popGet(AOP(IC_LEFT(ic)),0));
emitpcode(POC_ANDLW,popGetLit(1));
/*-----------------------------------------------------------------*/
static void genCpl (iCode *ic)
{
- int offset = 0;
- int size ;
+ operand *left, *result;
+ int size, offset=0;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* assign asmOps to operand & result */
- aopOp (IC_LEFT(ic),ic,FALSE);
- aopOp (IC_RESULT(ic),ic,TRUE);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
- /* if both are in bit space then
- a special case */
- if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
- AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
+ /* if both are in bit space then
+ a special case */
+ if (AOP_TYPE(result) == AOP_CRY &&
+ AOP_TYPE(left) == AOP_CRY ) {
- pic14_emitcode("mov","c,%s",IC_LEFT(ic)->aop->aopu.aop_dir);
- pic14_emitcode("cpl","c");
- pic14_emitcode("mov","%s,c",IC_RESULT(ic)->aop->aopu.aop_dir);
- goto release;
- }
+ pic14_emitcode("mov","c,%s",left->aop->aopu.aop_dir);
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("mov","%s,c",result->aop->aopu.aop_dir);
+ goto release;
+ }
- size = AOP_SIZE(IC_RESULT(ic));
- while (size--) {
- char *l = aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("cpl","a");
- aopPut(AOP(IC_RESULT(ic)),"a",offset++);
- }
+ size = AOP_SIZE(result);
+ while (size--) {
+
+ if(AOP_TYPE(left) == AOP_ACC)
+ emitpcode(POC_XORLW, popGetLit(0xff));
+ else
+ emitpcode(POC_COMFW,popGet(AOP(left),offset));
+
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+
+ }
release:
/* release the aops */
- freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
- freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
size--;
emitpcode(POC_MOVWF, popGet(AOP(oper),size));
GpsuedoStkPtr++;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
}
while (size--) {
aopOp(IC_LEFT(sic),sic,FALSE);
size = AOP_SIZE(IC_LEFT(sic));
-
while (size--) {
DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
AopType(AOP_TYPE(IC_LEFT(sic))));
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) )
emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(sic)),offset));
else
emitpcode(POC_MOVFW,popGet(AOP(IC_LEFT(sic)),offset));
-
+*/
//}
offset++;
}
static void genPcall (iCode *ic)
{
sym_link *dtype;
- symbol *rlbl = newiTempLabel(NULL);
-
+ symbol *albl = newiTempLabel(NULL);
+ symbol *blbl = newiTempLabel(NULL);
+ PIC_OPCODE poc;
+ operand *left;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
/* if caller saves & we have not saved then */
(FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
saverbank(FUNC_REGBANK(dtype),ic,TRUE);
-
- /* push the return address on to the stack */
- pic14_emitcode("mov","a,#%05d_DS_",(rlbl->key+100));
- pic14_emitcode("push","acc");
- pic14_emitcode("mov","a,#(%05d_DS_ >> 8)",(rlbl->key+100));
- pic14_emitcode("push","acc");
-
- if (options.model == MODEL_FLAT24)
- {
- pic14_emitcode("mov","a,#(%05d_DS_ >> 16)",(rlbl->key+100));
- pic14_emitcode("push","acc");
- }
-
- /* now push the calling address */
- aopOp(IC_LEFT(ic),ic,FALSE);
+ left = IC_LEFT(ic);
+ aopOp(left,ic,FALSE);
+ DEBUGpic14_AopType(__LINE__,left,NULL,NULL);
pushSide(IC_LEFT(ic), FPTRSIZE);
- freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
-
- /* if send set is not empty the assign */
+ /* if send set is not empty, assign parameters */
if (_G.sendSet) {
- iCode *sic ;
- for (sic = setFirstItem(_G.sendSet) ; sic ;
- sic = setNextItem(_G.sendSet)) {
- int size, offset = 0;
- aopOp(IC_LEFT(sic),sic,FALSE);
- size = AOP_SIZE(IC_LEFT(sic));
- while (size--) {
- char *l = aopGet(AOP(IC_LEFT(sic)),offset,
- FALSE,FALSE);
- if (strcmp(l,fReturn[offset]))
- pic14_emitcode("mov","%s,%s",
- fReturn[offset],
- l);
- offset++;
- }
- freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
- }
- _G.sendSet = NULL;
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING arg-passing to indirect call not supported",__FUNCTION__,__LINE__);
+ /* no way to pass args - W always gets used to make the call */
+ }
+/* first idea - factor out a common helper function and call it.
+ But don't know how to get it generated only once in its own block
+
+ if(AOP_TYPE(IC_LEFT(ic)) == AOP_DIR) {
+ char *rname;
+ char *buffer;
+ rname = IC_LEFT(ic)->aop->aopu.aop_dir;
+ DEBUGpic14_emitcode ("; ***","%s %d AOP_DIR %s",__FUNCTION__,__LINE__,rname);
+ buffer = Safe_calloc(1,strlen(rname)+16);
+ sprintf(buffer, "%s_goto_helper", rname);
+ addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp(buffer,PO_STR)));
+ free(buffer);
}
+*/
+ emitpcode(POC_CALL,popGetLabel(albl->key));
+ emitpcodePagesel(popGetLabel(blbl->key)->name); /* Must restore PCLATH before goto, without destroying W */
+ emitpcode(POC_GOTO,popGetLabel(blbl->key));
+ emitpLabel(albl->key);
+
+ poc = ( (AOP_TYPE(left) == AOP_PCODE) ? POC_MOVLW : POC_MOVFW);
+
+ emitpcode(poc,popGet(AOP(left),1));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_pclath));
+ emitpcode(poc,popGet(AOP(left),0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_pcl));
- pic14_emitcode("ret","");
- pic14_emitcode("","%05d_DS_:",(rlbl->key+100));
+ emitpLabel(blbl->key);
+ freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
- /* if we need assign a result value */
+ /* if we need to assign a result value */
if ((IS_ITEMP(IC_RESULT(ic)) &&
(OP_SYMBOL(IC_RESULT(ic))->nRegs ||
OP_SYMBOL(IC_RESULT(ic))->spildir)) ||
freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
- /* adjust the stack for parameters if
- required */
- if (ic->parmBytes) {
- int i;
- if (ic->parmBytes > 3) {
- pic14_emitcode("mov","a,%s",spname);
- pic14_emitcode("add","a,#0x%02x", (- ic->parmBytes) & 0xff);
- pic14_emitcode("mov","%s,a",spname);
- } else
- for ( i = 0 ; i < ic->parmBytes ;i++)
- pic14_emitcode("dec","%s",spname);
-
- }
-
/* if register bank was saved then unsave them */
if (currFunc && dtype &&
(FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
/*-----------------------------------------------------------------*/
static int resultRemat (iCode *ic)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (SKIP_IC(ic) || ic->op == IFX)
- return 0;
+ // DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (SKIP_IC(ic) || ic->op == IFX)
+ return 0;
- if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
- symbol *sym = OP_SYMBOL(IC_RESULT(ic));
- if (sym->remat && !POINTER_SET(ic))
- return 1;
- }
+ if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
+ symbol *sym = OP_SYMBOL(IC_RESULT(ic));
+ if (sym->remat && !POINTER_SET(ic))
+ return 1;
+ }
- return 0;
+ return 0;
}
#if defined(__BORLANDC__) || defined(_MSC_VER)
}
#endif
- /* if this is an interrupt service routine then
- save acc, b, dpl, dph */
+ /* if this is an interrupt service routine */
if (IFFUNC_ISISR(sym->type)) {
+/* already done in pic14createInterruptVect() - delete me
addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("END_OF_INTERRUPT+1",PO_STR)));
emitpcodeNULLop(POC_NOP);
emitpcodeNULLop(POC_NOP);
emitpcodeNULLop(POC_NOP);
+*/
emitpcode(POC_MOVWF, popCopyReg(&pc_wsave));
emitpcode(POC_SWAPFW, popCopyReg(&pc_status));
emitpcode(POC_CLRF, popCopyReg(&pc_status));
emitpcode(POC_MOVWF, popCopyReg(&pc_ssave));
+ emitpcode(POC_MOVFW, popCopyReg(&pc_pclath));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_psave));
+ emitpcode(POC_CLRF, popCopyReg(&pc_pclath));/* durring an interrupt PCLATH must be cleared before a goto or call statement */
pBlockConvert2ISR(pb);
#if 0
pic14_emitcode(";","XG$%s$0$0 ==.",currFunc->name);
_G.debugLine = 0;
}
-
- pic14_emitcode ("reti","");
-
- emitpcode(POC_CLRF, popCopyReg(&pc_status));
- emitpcode(POC_SWAPFW, popCopyReg(&pc_ssave));
- emitpcode(POC_MOVWF, popCopyReg(&pc_status));
- emitpcode(POC_SWAPF, popCopyReg(&pc_wsave));
- emitpcode(POC_MOVFW, popCopyReg(&pc_wsave));
- addpCode2pBlock(pb,newpCodeLabel("END_OF_INTERRUPT",-1));
-
- emitpcodeNULLop(POC_RETFIE);
+ pic14_emitcode ("reti","");
+ emitpcode(POC_MOVFW, popCopyReg(&pc_psave));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
+ emitpcode(POC_CLRF, popCopyReg(&pc_status));
+ emitpcode(POC_SWAPFW, popCopyReg(&pc_ssave));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_status));
+ emitpcode(POC_SWAPF, popCopyReg(&pc_wsave));
+ emitpcode(POC_SWAPFW, popCopyReg(&pc_wsave));
+ addpCode2pBlock(pb,newpCodeLabel("END_OF_INTERRUPT",-1));
+ emitpcodeNULLop(POC_RETFIE);
}
else {
if (IFFUNC_ISCRITICAL(sym->type))
l = aopGet(AOP(IC_LEFT(ic)),offset,
FALSE,FALSE);
if (strcmp(fReturn[offset],l)) {
- if( ( (AOP(IC_LEFT(ic))->type) == AOP_IMMD) ||
- ((AOP(IC_LEFT(ic))->type) == AOP_LIT) ) {
+ if ((((AOP(IC_LEFT(ic))->type) == AOP_PCODE) &&
+ AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE) ||
+ ( (AOP(IC_LEFT(ic))->type) == AOP_IMMD) ||
+ ( (AOP(IC_LEFT(ic))->type) == AOP_LIT) ) {
emitpcode(POC_MOVLW, popGet(AOP(IC_LEFT(ic)),offset));
}else {
emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
}
if(size) {
emitpcode(POC_MOVWF,popRegFromIdx(offset + Gstack_base_addr));
- pic14_emitcode("movwf","%s",fReturn[offset]);
}
offset++;
}
/*-----------------------------------------------------------------*/
/* genSkipz2 */
/*-----------------------------------------------------------------*/
-static void genSkipz2(resolvedIfx *rifx)
+static void genSkipz2(resolvedIfx *rifx, int invert_condition)
{
if(!rifx)
return;
- if(rifx->condition)
+ if( (rifx->condition ^ invert_condition) & 1)
emitSKPZ;
else
emitSKPNZ;
// resolvedIfx rTrueIfx;
symbol *truelbl;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+/*
if(ifx) {
- DEBUGpic14_emitcode ("; ***","true ifx is %s",((IC_TRUE(ifx) == NULL) ? "false" : "true"));
- DEBUGpic14_emitcode ("; ***","false ifx is %s",((IC_FALSE(ifx) == NULL) ? "false" : "true"));
+ DEBUGpic14_emitcode ("; ***","true ifx is %s",((IC_TRUE(ifx) == NULL) ? "false" : "true"));
+ DEBUGpic14_emitcode ("; ***","false ifx is %s",((IC_FALSE(ifx) == NULL) ? "false" : "true"));
}
-
+*/
resolveIfx(&rFalseIfx,ifx);
truelbl = newiTempLabel(NULL);
+ size = max(AOP_SIZE(left),AOP_SIZE(right));
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+#define _swapp
+
+ /* if literal is on the right then swap with left */
+ if ((AOP_TYPE(right) == AOP_LIT)) {
+ operand *tmp = right ;
+ unsigned long mask = (0x100 << (8*(size-1))) - 1;
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+#ifdef _swapp
+
+ lit = (lit - 1) & mask;
+ right = left;
+ left = tmp;
+ rFalseIfx.condition ^= 1;
+#endif
+
+ } else if ((AOP_TYPE(left) == AOP_LIT)) {
+ lit = (unsigned long)floatFromVal(AOP(left)->aopu.aop_lit);
+ }
+
//if(IC_TRUE(ifx) == NULL)
/* if left & right are bit variables */
/* subtract right from left if at the
end the carry flag is set then we know that
left is greater than right */
- size = max(AOP_SIZE(left),AOP_SIZE(right));
- /* if unsigned char cmp with lit, do cjne left,#right,zz */
- //if((size == 1) && !sign &&
- // (AOP_TYPE(right) == AOP_LIT && AOP_TYPE(left) != AOP_DIR )){
- // symbol *lbl = newiTempLabel(NULL);
- // pic14_emitcode("cjne","%s,%s,%05d_DS_",
- // aopGet(AOP(left),offset,FALSE,FALSE),
- // aopGet(AOP(right),offset,FALSE,FALSE),
- // lbl->key+100);
- //pic14_emitcode("","%05d_DS_:",lbl->key+100);
- //} else
- {
+ // {
- symbol *lbl = newiTempLabel(NULL);
+ symbol *lbl = newiTempLabel(NULL);
- if(AOP_TYPE(right) == AOP_LIT) {
+#ifndef _swapp
+ if(AOP_TYPE(right) == AOP_LIT) {
- lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+ //lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
- DEBUGpic14_emitcode(";right lit","lit = 0x%x,sign=%d",lit,sign);
+ DEBUGpic14_emitcode(";right lit","lit = 0x%x,sign=%d",lit,sign);
- /* special cases */
+ /* special cases */
- if(lit == 0) {
+ if(lit == 0) {
- if(sign != 0)
- genSkipCond(&rFalseIfx,left,size-1,7);
- else
- /* no need to compare to 0...*/
- /* NOTE: this is a de-generate compare that most certainly
- * creates some dead code. */
- emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
+ if(sign != 0)
+ genSkipCond(&rFalseIfx,left,size-1,7);
+ else
+ /* no need to compare to 0...*/
+ /* NOTE: this is a de-generate compare that most certainly
+ * creates some dead code. */
+ emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
- if(ifx) ifx->generated = 1;
- return;
+ if(ifx) ifx->generated = 1;
+ return;
- }
- size--;
+ }
+ size--;
- if(size == 0) {
- //i = (lit >> (size*8)) & 0xff;
- DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+ if(size == 0) {
+ //i = (lit >> (size*8)) & 0xff;
+ DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
- emitpcode(POC_MOVFW, popGet(AOP(left),size));
-
- i = ((0-lit) & 0xff);
- if(sign) {
- if( i == 0x81) {
- /* lit is 0x7f, all signed chars are less than
- * this except for 0x7f itself */
- emitpcode(POC_XORLW, popGetLit(0x7f));
- genSkipz2(&rFalseIfx);
- } else {
- emitpcode(POC_ADDLW, popGetLit(0x80));
- emitpcode(POC_ADDLW, popGetLit(i^0x80));
- genSkipc(&rFalseIfx);
- }
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ i = ((0-lit) & 0xff);
+ if(sign) {
+ if( i == 0x81) {
+ /* lit is 0x7f, all signed chars are less than
+ * this except for 0x7f itself */
+ emitpcode(POC_XORLW, popGetLit(0x7f));
+ genSkipz2(&rFalseIfx,0);
} else {
- emitpcode(POC_ADDLW, popGetLit(i));
+ emitpcode(POC_ADDLW, popGetLit(0x80));
+ emitpcode(POC_ADDLW, popGetLit(i^0x80));
genSkipc(&rFalseIfx);
-
}
- if(ifx) ifx->generated = 1;
- return;
+ } else {
+ if(lit == 1) {
+ genSkipz2(&rFalseIfx,1);
+ } else {
+ emitpcode(POC_ADDLW, popGetLit(i));
+ genSkipc(&rFalseIfx);
+ }
}
- /* chars are out of the way. now do ints and longs */
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+ /* chars are out of the way. now do ints and longs */
- DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+
+ DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
- /* special cases */
+ /* special cases */
- if(sign) {
+ if(sign) {
- if(lit == 0) {
- genSkipCond(&rFalseIfx,left,size,7);
- if(ifx) ifx->generated = 1;
- return;
- }
+ if(lit == 0) {
+ genSkipCond(&rFalseIfx,left,size,7);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
- if(lit <0x100) {
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ if(lit <0x100) {
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- //rFalseIfx.condition ^= 1;
- //genSkipCond(&rFalseIfx,left,size,7);
- //rFalseIfx.condition ^= 1;
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,left,size,7);
+ //rFalseIfx.condition ^= 1;
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- emitpcode(POC_MOVLW, popGetLit(0x100-lit));
- emitpcode(POC_ADDFW, popGet(AOP(left),0));
- emitpcode(POC_MOVFW, popGet(AOP(left),1));
+ emitpcode(POC_MOVLW, popGetLit(0x100-lit));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),1));
- while(size > 1)
- emitpcode(POC_IORFW, popGet(AOP(left),size--));
+ while(size > 1)
+ emitpcode(POC_IORFW, popGet(AOP(left),size--));
- if(rFalseIfx.condition) {
- emitSKPZ;
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
-
- } else {
- emitSKPNZ;
- }
-
- genSkipc(&rFalseIfx);
- emitpLabel(truelbl->key);
- if(ifx) ifx->generated = 1;
- return;
+ if(rFalseIfx.condition) {
+ emitSKPZ;
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ } else {
+ emitSKPNZ;
}
- if(size == 1) {
-
- if( (lit & 0xff) == 0) {
- /* lower byte is zero */
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- i = ((lit >> 8) & 0xff) ^0x80;
- emitpcode(POC_MOVFW, popGet(AOP(left),size));
- emitpcode(POC_ADDLW, popGetLit( 0x80));
- emitpcode(POC_ADDLW, popGetLit(0x100-i));
- genSkipc(&rFalseIfx);
+ genSkipc(&rFalseIfx);
+ emitpLabel(truelbl->key);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
- if(ifx) ifx->generated = 1;
- return;
-
- }
- } else {
- /* Special cases for signed longs */
- if( (lit & 0xffffff) == 0) {
- /* lower byte is zero */
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- i = ((lit >> 8*3) & 0xff) ^0x80;
- emitpcode(POC_MOVFW, popGet(AOP(left),size));
- emitpcode(POC_ADDLW, popGetLit( 0x80));
- emitpcode(POC_ADDLW, popGetLit(0x100-i));
- genSkipc(&rFalseIfx);
+ if(size == 1) {
+ if( (lit & 0xff) == 0) {
+ /* lower byte is zero */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ i = ((lit >> 8) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ genSkipc(&rFalseIfx);
- if(ifx) ifx->generated = 1;
- return;
- }
+ if(ifx) ifx->generated = 1;
+ return;
}
+ } else {
+ /* Special cases for signed longs */
+ if( (lit & 0xffffff) == 0) {
+ /* lower byte is zero */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ i = ((lit >> 8*3) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ genSkipc(&rFalseIfx);
- if(lit & (0x80 << (size*8))) {
- /* lit is negative */
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ if(ifx) ifx->generated = 1;
+ return;
- //genSkipCond(&rFalseIfx,left,size,7);
+ }
- emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ }
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ if(lit & (0x80 << (size*8))) {
+ /* lit is negative */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- } else {
- /* lit is positive */
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ //genSkipCond(&rFalseIfx,left,size,7);
- //emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
- //emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- //rFalseIfx.condition ^= 1;
- //genSkipCond(&rFalseIfx,left,size,7);
- //rFalseIfx.condition ^= 1;
- }
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
- /*
- This works, but is only good for ints.
- It also requires a "known zero" register.
- emitpcode(POC_MOVLW, popGetLit(mlit & 0xff));
- emitpcode(POC_ADDFW, popGet(AOP(left),0));
- emitpcode(POC_RLFW, popCopyReg(&pc_kzero));
- emitpcode(POC_ADDLW, popGetLit( ((mlit>>8) & 0xff)));
- emitpcode(POC_ADDFW, popGet(AOP(left),1));
- genSkipc(&rFalseIfx);
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- emitpLabel(truelbl->key);
- if(ifx) ifx->generated = 1;
- return;
- **/
-
- /* There are no more special cases, so perform a general compare */
-
- emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
- while(size--) {
+ } else {
+ /* lit is positive */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
- emitSKPNZ;
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
- }
- //rFalseIfx.condition ^= 1;
+ }
+
+ /*
+ This works, but is only good for ints.
+ It also requires a "known zero" register.
+ emitpcode(POC_MOVLW, popGetLit(mlit & 0xff));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0));
+ emitpcode(POC_RLFW, popCopyReg(&pc_kzero));
+ emitpcode(POC_ADDLW, popGetLit( ((mlit>>8) & 0xff)));
+ emitpcode(POC_ADDFW, popGet(AOP(left),1));
genSkipc(&rFalseIfx);
emitpLabel(truelbl->key);
-
if(ifx) ifx->generated = 1;
return;
+ **/
+
+ /* There are no more special cases, so perform a general compare */
+
+ emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ while(size--) {
+ emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
}
+ //rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
+
+ emitpLabel(truelbl->key);
+ if(ifx) ifx->generated = 1;
+ return;
+
+
+ }
- /* sign is out of the way. So now do an unsigned compare */
- DEBUGpic14_emitcode(";right lit","line = %d unsigned compare to 0x%x",__LINE__,lit);
+ /* sign is out of the way. So now do an unsigned compare */
+ DEBUGpic14_emitcode(";right lit","line = %d unsigned compare to 0x%x",__LINE__,lit);
- //genChkZeroes(left)
- /* General case - compare to an unsigned literal on the right.*/
+ /* General case - compare to an unsigned literal on the right.*/
+ i = (lit >> (size*8)) & 0xff;
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ while(size--) {
i = (lit >> (size*8)) & 0xff;
- emitpcode(POC_MOVLW, popGetLit(i));
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
- while(size--) {
- i = (lit >> (size*8)) & 0xff;
- if(i) {
- emitpcode(POC_MOVLW, popGetLit(i));
- emitSKPNZ;
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
- } else {
- /* this byte of the lit is zero,
- *if it's not the last then OR in the variable */
- if(size)
- emitpcode(POC_IORFW, popGet(AOP(left),size));
- }
+ if(i) {
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ } else {
+ /* this byte of the lit is zero,
+ *if it's not the last then OR in the variable */
+ if(size)
+ emitpcode(POC_IORFW, popGet(AOP(left),size));
}
+ }
- emitpLabel(lbl->key);
- //if(emitFinalCheck)
- genSkipc(&rFalseIfx);
- if(sign)
- emitpLabel(truelbl->key);
+ emitpLabel(lbl->key);
+ //if(emitFinalCheck)
+ genSkipc(&rFalseIfx);
+ if(sign)
+ emitpLabel(truelbl->key);
- if(ifx) ifx->generated = 1;
- return;
+ if(ifx) ifx->generated = 1;
+ return;
- }
+ }
+#endif // _swapp
- if(AOP_TYPE(left) == AOP_LIT) {
- //symbol *lbl = newiTempLabel(NULL);
+ if(AOP_TYPE(left) == AOP_LIT) {
+ //symbol *lbl = newiTempLabel(NULL);
- lit = (unsigned long)(floatFromVal(AOP(left)->aopu.aop_lit));
+ //EXPERIMENTAL lit = (unsigned long)(floatFromVal(AOP(left)->aopu.aop_lit));
- DEBUGpic14_emitcode(";left lit","lit = %d,sign=%d",lit,sign);
+ DEBUGpic14_emitcode(";left lit","lit = 0x%x,sign=%d",lit,sign);
- /* Special cases */
- if((lit == 0) && (sign == 0)){
+ /* Special cases */
+ if((lit == 0) && (sign == 0)){
- size--;
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- while(size)
- emitpcode(POC_IORFW, popGet(AOP(right),--size));
+ size--;
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size)
+ emitpcode(POC_IORFW, popGet(AOP(right),--size));
+
+ genSkipz2(&rFalseIfx,0);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(size==1) {
+ /* Special cases */
+ lit &= 0xff;
+ if(((lit == 0xff) && !sign) || ((lit==0x7f) && sign)) {
+ /* degenerate compare can never be true */
+ if(rFalseIfx.condition == 0)
+ emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
- //rFalseIfx.condition ^= 1;
- genSkipz2(&rFalseIfx);
if(ifx) ifx->generated = 1;
return;
}
- if(size==1) {
- /* Special cases */
- lit &= 0xff;
- if(((lit == 0xff) && !sign) || ((lit==0x7f) && sign)) {
- /* degenerate compare can never be true */
- if(rFalseIfx.condition == 0)
- emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
+ if(sign) {
+ /* signed comparisons to a literal byte */
+
+ int lp1 = (lit+1) & 0xff;
- if(ifx) ifx->generated = 1;
- return;
+ DEBUGpic14_emitcode(";left lit","line = %d lit = 0x%x",__LINE__,lit);
+ switch (lp1) {
+ case 0:
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,0,7);
+ break;
+ case 0x7f:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_XORLW, popGetLit(0x7f));
+ genSkipz2(&rFalseIfx,1);
+ break;
+ default:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_ADDLW, popGetLit(0x80));
+ emitpcode(POC_ADDLW, popGetLit(((-(lit+1)) & 0xff) ^ 0x80));
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
+ break;
}
+ if(ifx) ifx->generated = 1;
+ } else {
+ /* unsigned comparisons to a literal byte */
- if(sign) {
- if((lit+1)&0xff) {
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- emitpcode(POC_ADDLW, popGetLit(0x80));
- emitpcode(POC_ADDLW, popGetLit(((-(lit+1)) & 0xff) ^ 0x80));
- rFalseIfx.condition ^= 1;
+ switch(lit & 0xff ) {
+ case 0:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ genSkipz2(&rFalseIfx,0);
+ if(ifx) ifx->generated = 1;
+ break;
+ case 0x7f:
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,0,7);
+ if(ifx) ifx->generated = 1;
+ break;
+
+ default:
+ emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(right),0));
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ rFalseIfx.condition ^= 1;
+ if (AOP_TYPE(result) == AOP_CRY) {
genSkipc(&rFalseIfx);
+ if(ifx) ifx->generated = 1;
} else {
- rFalseIfx.condition ^= 1;
- genSkipCond(&rFalseIfx,right,0,7);
- }
-
- } else {
- if(lit & 0xff) {
- emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
- emitpcode(POC_SUBFW, popGet(AOP(right),0));
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- rFalseIfx.condition ^= 1;
- genSkipc(&rFalseIfx);
- } else {
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- genSkipz2(&rFalseIfx);
- }
+ DEBUGpic14_emitcode ("; ***","%s %d RFIfx.cond=%d",__FUNCTION__,__LINE__, rFalseIfx.condition);
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ emitpcode(POC_MOVLW, popGetLit(0x01));
+ emitpcode(POC_XORWF, popGet(AOP(result),0));
+ }
+ break;
}
+ }
- if(ifx) ifx->generated = 1;
- return;
+ //goto check_carry;
+ return;
- } else {
+ } else {
+
+ /* Size is greater than 1 */
+
+ if(sign) {
+ int lp1 = lit+1;
+
+ size--;
- /* Size is greater than 1 */
+ if(lp1 == 0) {
+ /* this means lit = 0xffffffff, or -1 */
+ DEBUGpic14_emitcode(";left lit = -1","line = %d ",__LINE__);
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,size,7);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
- if(sign) {
- int lp1 = lit+1;
+ if(lit == 0) {
+ int s = size;
- size--;
+ if(rFalseIfx.condition) {
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ }
- if(lp1 == 0) {
- /* this means lit = 0xffffffff, or -1 */
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size--)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
- DEBUGpic14_emitcode(";left lit = -1","line = %d ",__LINE__);
+ emitSKPZ;
+ if(rFalseIfx.condition) {
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ emitpLabel(truelbl->key);
+ }else {
rFalseIfx.condition ^= 1;
- genSkipCond(&rFalseIfx,right,size,7);
- if(ifx) ifx->generated = 1;
- return;
+ genSkipCond(&rFalseIfx,right,s,7);
}
- if(lit == 0) {
- int s = size;
+ if(ifx) ifx->generated = 1;
+ return;
+ }
- if(rFalseIfx.condition) {
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- }
+ if((size == 1) && (0 == (lp1&0xff))) {
+ /* lower byte of signed word is zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x+1 low byte is zero",__LINE__,lit);
+ i = ((lp1 >> 8) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- while(size--)
- emitpcode(POC_IORFW, popGet(AOP(right),size));
+ if(ifx) ifx->generated = 1;
+ return;
+ }
- emitSKPZ;
- if(rFalseIfx.condition) {
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- emitpLabel(truelbl->key);
- }else {
- rFalseIfx.condition ^= 1;
- genSkipCond(&rFalseIfx,right,s,7);
- }
+ if(lit & (0x80 << (size*8))) {
+ /* Lit is less than zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x is less than 0",__LINE__,lit);
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,left,size,7);
+ //rFalseIfx.condition ^= 1;
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ //emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- if(ifx) ifx->generated = 1;
- return;
- }
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- if(lit & (0x80 << (size*8))) {
- /* Lit is less than zero */
- DEBUGpic14_emitcode(";left lit","line = %d 0x%x is less than 0",__LINE__,lit);
- //rFalseIfx.condition ^= 1;
- //genSkipCond(&rFalseIfx,left,size,7);
- //rFalseIfx.condition ^= 1;
- emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
- //emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ } else {
+ /* Lit is greater than or equal to zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x is greater than 0",__LINE__,lit);
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,right,size,7);
+ //rFalseIfx.condition ^= 1;
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ //emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ //emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- } else {
- /* Lit is greater than or equal to zero */
- DEBUGpic14_emitcode(";left lit","line = %d 0x%x is greater than 0",__LINE__,lit);
- //rFalseIfx.condition ^= 1;
- //genSkipCond(&rFalseIfx,right,size,7);
- //rFalseIfx.condition ^= 1;
+ }
- //emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
- //emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+
+ while(size--) {
- }
emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
+ emitSKPNZ;
emitpcode(POC_SUBFW, popGet(AOP(right),size));
+ }
+ rFalseIfx.condition ^= 1;
+ //rFalseIfx.condition = 1;
+ genSkipc(&rFalseIfx);
- while(size--) {
+ emitpLabel(truelbl->key);
- emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
- emitSKPNZ;
- emitpcode(POC_SUBFW, popGet(AOP(right),size));
+ if(ifx) ifx->generated = 1;
+ return;
+ // end of if (sign)
+ } else {
+
+ /* compare word or long to an unsigned literal on the right.*/
+
+
+ size--;
+ if(lit < 0xff) {
+ DEBUGpic14_emitcode ("; ***","%s %d lit =0x%x < 0xff",__FUNCTION__,__LINE__,lit);
+ switch (lit) {
+ case 0:
+ break; /* handled above */
+/*
+ case 0xff:
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size--)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+ genSkipz2(&rFalseIfx,0);
+ break;
+*/
+ default:
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(--size)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+
+ emitSKPZ;
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+
+ emitpcode(POC_MOVLW, popGetLit(lit+1));
+ emitpcode(POC_SUBFW, popGet(AOP(right),0));
+
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
}
- rFalseIfx.condition ^= 1;
- //rFalseIfx.condition = 1;
- genSkipc(&rFalseIfx);
emitpLabel(truelbl->key);
if(ifx) ifx->generated = 1;
return;
+ }
- } else {
- /* Unsigned compare for sizes greater than 1 */
- while(size--) {
- i = (lit >> (size*8)) & 0xff;
+ lit++;
+ DEBUGpic14_emitcode ("; ***","%s %d lit =0x%x",__FUNCTION__,__LINE__,lit);
+ i = (lit >> (size*8)) & 0xff;
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
- if(size) {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- emitpcode(POC_MOVLW, popGetLit(i&0xff));
- emitpcode(POC_SUBFW, popGet(AOP(right),size));
- emitSKPZ;
- emitpcode(POC_GOTO, popGetLabel(lbl->key));
- } else {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- emitpcode(POC_MOVLW, popGetLit((i+1)&0xff));
- emitpcode(POC_SUBFW, popGet(AOP(right),size));
+ while(size--) {
+ i = (lit >> (size*8)) & 0xff;
- }
+ if(i) {
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+ } else {
+ /* this byte of the lit is zero,
+ *if it's not the last then OR in the variable */
+ if(size)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
}
+ }
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- emitpLabel(lbl->key);
+ emitpLabel(lbl->key);
- rFalseIfx.condition ^= 1;
- genSkipc(&rFalseIfx);
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
+ }
- }
if(sign)
emitpLabel(truelbl->key);
if(ifx) ifx->generated = 1;
return;
- }
}
- /* Compare two variables */
-
- DEBUGpic14_emitcode(";sign","%d",sign);
+ }
+ /* Compare two variables */
- size--;
- if(sign) {
- /* Sigh. thus sucks... */
- if(size) {
- emitpcode(POC_MOVFW, popGet(AOP(left),size));
- emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
- emitpcode(POC_MOVLW, popGetLit(0x80));
- emitpcode(POC_XORWF, popRegFromIdx(Gstack_base_addr));
- emitpcode(POC_XORFW, popGet(AOP(right),size));
- emitpcode(POC_SUBFW, popRegFromIdx(Gstack_base_addr));
- } else {
- /* Signed char comparison */
- /* Special thanks to Nikolai Golovchenko for this snippet */
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- emitpcode(POC_SUBFW, popGet(AOP(left),0));
- emitpcode(POC_RRFW, popGet(AOP(left),0)); /* could be any register */
- emitpcode(POC_XORFW, popGet(AOP(left),0));
- emitpcode(POC_XORFW, popGet(AOP(right),0));
- emitpcode(POC_ADDLW, popGetLit(0x80));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- genSkipc(&rFalseIfx);
-
- if(ifx) ifx->generated = 1;
- return;
- }
+ DEBUGpic14_emitcode(";sign","%d",sign);
+ size--;
+ if(sign) {
+ /* Sigh. thus sucks... */
+ if(size) {
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
+ emitpcode(POC_MOVLW, popGetLit(0x80));
+ emitpcode(POC_XORWF, popRegFromIdx(Gstack_base_addr));
+ emitpcode(POC_XORFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popRegFromIdx(Gstack_base_addr));
} else {
+ /* Signed char comparison */
+ /* Special thanks to Nikolai Golovchenko for this snippet */
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_SUBFW, popGet(AOP(left),0));
+ emitpcode(POC_RRFW, popGet(AOP(left),0)); /* could be any register */
+ emitpcode(POC_XORFW, popGet(AOP(left),0));
+ emitpcode(POC_XORFW, popGet(AOP(right),0));
+ emitpcode(POC_ADDLW, popGetLit(0x80));
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ genSkipc(&rFalseIfx);
+
+ if(ifx) ifx->generated = 1;
+ return;
}
+ } else {
- /* The rest of the bytes of a multi-byte compare */
- while (size) {
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ }
- emitSKPZ;
- emitpcode(POC_GOTO, popGetLabel(lbl->key));
- size--;
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ /* The rest of the bytes of a multi-byte compare */
+ while (size) {
+
+ emitSKPZ;
+ emitpcode(POC_GOTO, popGetLabel(lbl->key));
+ size--;
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
- }
- emitpLabel(lbl->key);
+ }
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ emitpLabel(lbl->key);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if ((AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) ||
+ (AOP_TYPE(result) == AOP_REG)) {
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ } else {
genSkipc(&rFalseIfx);
- if(ifx) ifx->generated = 1;
- return;
+ }
+ //genSkipc(&rFalseIfx);
+ if(ifx) ifx->generated = 1;
+
+ return;
- }
}
- //release:
+ // check_carry:
if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
pic14_outBitC(result);
} else {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
/* if the result is used in the next
ifx conditional branch then generate
code a little differently */
{
int size = max(AOP_SIZE(left),AOP_SIZE(right));
int offset = 0;
+ int res_offset = 0; /* the result may be a different size then left or right */
+ int res_size = AOP_SIZE(result);
resolvedIfx rIfx;
symbol *lbl;
unsigned long lit = 0L;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- DEBUGpic14_AopType(__LINE__,left,right,NULL);
-
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+ if(result)
+ DEBUGpic14_emitcode ("; ***","%s %d result is not null",__FUNCTION__,__LINE__);
resolveIfx(&rIfx,ifx);
lbl = newiTempLabel(NULL);
emitSKPNZ;
emitpcode(POC_GOTO,popGetLabel(lbl->key));
offset++;
+ if(res_offset < res_size-1)
+ res_offset++;
lit >>= 8;
}
break;
AOP_TYPE(right) == AOP_DIR ||
(AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) ||
(IS_AOP_PREG(left) && !IS_AOP_PREG(right))) {
- switch(size) {
- case 2:
- genc16bit2lit(left, lit, 0);
- emitSKPNZ;
- emitpcode(POC_GOTO,popGetLabel(lbl->key));
- break;
- default:
- while (size--) {
- int emit_skip=1;
- if((AOP_TYPE(left) == AOP_DIR) &&
- ((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
+ //int lbl_key = (rIfx.condition) ? rIfx.lbl->key : lbl->key;
+ int lbl_key = lbl->key;
+
+ if(result) {
+ emitpcode(POC_CLRF,popGet(AOP(result),res_offset));
+ //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ }else {
+ DEBUGpic14_emitcode ("; ***","%s %d -- ERROR",__FUNCTION__,__LINE__);
+ fprintf(stderr, "%s %d error - expecting result to be non_null\n",
+ __FUNCTION__,__LINE__);
+ return;
+ }
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- emitpcode(POC_XORFW,popGet(AOP(right),offset));
+/* switch(size) { */
+/* case 2: */
+/* genc16bit2lit(left, lit, 0); */
+/* emitSKPNZ; */
+/* emitpcode(POC_GOTO,popGetLabel(lbl->key)); */
+/* break; */
+/* default: */
+ while (size--) {
+ int emit_skip=1;
+ if((AOP_TYPE(left) == AOP_DIR) &&
+ ((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
- } else if((AOP_TYPE(left) == AOP_DIR) && (AOP_TYPE(right) == AOP_LIT)){
+ 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));
- break;
- case 1:
- 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));
- emitpcode(POC_GOTO,popGetLabel(lbl->key));
- emit_skip=0;
- break;
- default:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- emitpcode(POC_XORLW,popGetLit(lit & 0xff));
- }
- lit >>= 8;
+ switch (lit & 0xff) {
+ case 0:
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ break;
+ case 1:
+ emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ //emitpcode(POC_GOTO,popGetLabel(lbl->key));
+ emit_skip=0;
+ break;
+ case 0xff:
+ emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ //emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_GOTO,popGetLabel(lbl_key));
+ emit_skip=0;
+ break;
+ default:
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORLW,popGetLit(lit & 0xff));
+ }
+ lit >>= 8;
+ } else {
+ emitpcode(POC_MOVF,popGet(AOP(left),offset));
+ }
+ if(emit_skip) {
+ if(AOP_TYPE(result) == AOP_CRY) {
+ pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
+ if(rIfx.condition)
+ emitSKPNZ;
+ else
+ emitSKPZ;
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
} else {
- emitpcode(POC_MOVF,popGet(AOP(left),offset));
- }
- if(emit_skip) {
- if(AOP_TYPE(result) == AOP_CRY) {
- pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
- if(rIfx.condition)
- emitSKPNZ;
- else
- emitSKPZ;
- emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
- } else {
- /* fix me. probably need to check result size too */
- emitpcode(POC_CLRF,popGet(AOP(result),0));
- if(rIfx.condition)
- emitSKPNZ;
- else
- emitSKPZ;
- emitpcode(POC_INCF,popGet(AOP(result),0));
- }
- if(ifx)
- ifx->generated=1;
+ /* fix me. probably need to check result size too */
+ //emitpcode(POC_CLRF,popGet(AOP(result),0));
+ if(rIfx.condition)
+ emitSKPZ;
+ else
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(lbl_key));
+ //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
}
- emit_skip++;
- offset++;
+ if(ifx)
+ ifx->generated=1;
}
- break;
+ emit_skip++;
+ offset++;
+ if(res_offset < res_size-1)
+ res_offset++;
}
+/* break; */
+/* } */
} else if(AOP_TYPE(right) == AOP_REG &&
AOP_TYPE(left) != AOP_DIR){
emitSKPZ;
emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
offset++;
+ if(res_offset < res_size-1)
+ res_offset++;
}
}else{
offset++;
}
}
+
+ emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ if(!rIfx.condition)
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+
emitpLabel(lbl->key);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
if(ifx)
ifx->generated = 1;
}
emitpcode(POC_ANDFW,popGet(AOP(left),0));
emitpcode(POC_BTFSC,popGet(AOP(right),0));
emitpcode(POC_ANDLW,popGet(AOP(left),0));
- genSkipz2(&rIfx);
+ genSkipz2(&rIfx,0);
}
} else {
pic14_outBitC(result);
} else {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
gencjne(left,right,result,ifx);
/*
if(ifx)
static void genAndOp (iCode *ic)
{
operand *left,*right, *result;
- symbol *tlbl;
+/* symbol *tlbl; */
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
/* note here that && operations that are in an
aopOp((right=IC_RIGHT(ic)),ic,FALSE);
aopOp((result=IC_RESULT(ic)),ic,FALSE);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ emitpcode(POC_MOVFW,popGet(AOP(left),0));
+ emitpcode(POC_ANDFW,popGet(AOP(right),0));
+ emitpcode(POC_MOVWF,popGet(AOP(result),0));
+
/* if both are bit variables */
- if (AOP_TYPE(left) == AOP_CRY &&
- AOP_TYPE(right) == AOP_CRY ) {
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir);
- pic14_outBitC(result);
- } else {
- tlbl = newiTempLabel(NULL);
- pic14_toBoolean(left);
- pic14_emitcode("jz","%05d_DS_",tlbl->key+100);
- pic14_toBoolean(right);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_outBitAcc(result);
- }
+/* if (AOP_TYPE(left) == AOP_CRY && */
+/* AOP_TYPE(right) == AOP_CRY ) { */
+/* pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir); */
+/* pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir); */
+/* pic14_outBitC(result); */
+/* } else { */
+/* tlbl = newiTempLabel(NULL); */
+/* pic14_toBoolean(left); */
+/* pic14_emitcode("jz","%05d_DS_",tlbl->key+100); */
+/* pic14_toBoolean(right); */
+/* pic14_emitcode("","%05d_DS_:",tlbl->key+100); */
+/* pic14_outBitAcc(result); */
+/* } */
freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
} else {
pic14_emitcode("movlw","0x%x", (lit & 0xff));
pic14_emitcode("andwf","%s,f",aopGet(AOP(left),offset,FALSE,TRUE));
- if(know_W != (lit&0xff))
+ if(know_W != (int)(lit&0xff))
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
know_W = lit &0xff;
emitpcode(POC_ANDWF,popGet(AOP(left),offset));
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));
+ if(AOP_TYPE(left) != AOP_ACC) {
+ 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));
+ }
emitpcode(POC_MOVWF,popGet(AOP(result),offset));
break;
default:
- pic14_emitcode("movlw","0x%x",t);
- pic14_emitcode("andwf","%s,w",
- aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s",
- aopGet(AOP(result),offset,FALSE,FALSE));
+ if(AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_ANDLW, popGetLit(t));
+ } else {
+ pic14_emitcode("movlw","0x%x",t);
+ pic14_emitcode("andwf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",
+ aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+ }
emitpcode(POC_MOVWF,popGet(AOP(result),offset));
}
continue;
emitpcode(POC_BSF,
newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
} else {
- if(know_W != (lit & 0xff))
+ if(know_W != (int)(lit & 0xff))
emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
know_W = lit & 0xff;
emitpcode(POC_IORWF, popGet(AOP(left),offset));
int t = (lit >> (offset*8)) & 0x0FFL;
switch(t) {
case 0x00:
- emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ if (AOP_TYPE(left) != AOP_ACC) {
+ 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;
default:
- emitpcode(POC_MOVLW, popGetLit(t));
- 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",
- aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s",
- aopGet(AOP(result),offset,FALSE,FALSE));
-
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_IORLW, popGetLit(t));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_IORFW, popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
}
continue;
}
int t = (lit >> (offset*8)) & 0x0FFL;
switch(t) {
case 0x00:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ if (AOP_TYPE(left) != AOP_ACC) {
+ 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));
aopGet(AOP(result),offset,FALSE,FALSE));
break;
case 0xff:
- emitpcode(POC_COMFW,popGet(AOP(left),offset));
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_XORLW, popGetLit(t));
+ } else {
+ 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",
- aopGet(AOP(result),offset,FALSE,FALSE));
break;
default:
- emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_XORFW,popGet(AOP(left),offset));
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_XORLW, popGetLit(t));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ 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",
while (*bp) {
if (*bp == '\n') {
*bp++ = '\0';
- pic14_emitcode(bp1,"");
- addpCode2pBlock(pb,newpCodeInlineP(bp1));
+
+ if(*bp1)
+ addpCode2pBlock(pb,AssembleLine(bp1));
bp1 = bp;
} else {
if (*bp == ':') {
bp++;
}
}
- if (bp1 != bp) {
- pic14_emitcode(bp1,"");
- addpCode2pBlock(pb,newpCodeInlineP(bp1));
- }
- /* pic14_emitcode("",buffer); */
+ if ((bp1 != bp) && *bp1)
+ addpCode2pBlock(pb,AssembleLine(bp1));
+
+ Safe_free(buffer);
+
_G.inLine -= (!options.asmpeep);
}
/* don't crash result[offr] */
MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
pic14_emitcode("xch","a,%s", aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
- } else {
+ }
+/* else {
movLeft2Result(left,offl, result, offr);
MOVA(aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
}
+*/
/* a:x >> shCount (x = lsb(result))*/
/*
if(sign)
emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- emitpcode(POC_RLFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr+MSB16));
emitpcode(POC_ANDLW,popGetLit(0x03));
if(sign) {
emitpcode(POC_BTFSC,
newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),0,0));
emitpcode(POC_IORLW,popGetLit(0xfc));
}
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ //emitpcode(POC_RLF, popGet(AOP(result),offr));
}
return ;
}
-
+#if 0
/*-----------------------------------------------------------------*/
/* genDataPointerGet - generates code when ptr offset is known */
/*-----------------------------------------------------------------*/
freeAsmop(left,NULL,ic,TRUE);
freeAsmop(result,NULL,ic,TRUE);
}
-
+#endif
/*-----------------------------------------------------------------*/
/* genNearPointerGet - pic14_emitcode for near pointer fetch */
/*-----------------------------------------------------------------*/
iCode *ic)
{
asmop *aop = NULL;
- regs *preg = NULL ;
+ //regs *preg = NULL ;
char *rname ;
sym_link *rtype, *retype;
sym_link *ltype = operandType(left);
- char buffer[80];
+ //char buffer[80];
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if (!AOP_INPREG(AOP(left))) {
/* otherwise get a free pointer register */
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+/*
aop = newAsmop(0);
preg = getFreePtr(ic,&aop,FALSE);
pic14_emitcode("mov","%s,%s",
preg->name,
aopGet(AOP(left),0,FALSE,TRUE));
rname = preg->name ;
+*/
+ rname ="BAD";
} else
rname = aopGet(AOP(left),0,FALSE,FALSE);
- freeAsmop(left,NULL,ic,TRUE);
aopOp (result,ic,FALSE);
/* if bitfield then unpack the bits */
genUnpackBits (result,rname,POINTER);
else {
/* we have can just get the values */
- int size = AOP_SIZE(result);
- int offset = 0 ;
+ int size = AOP_SIZE(result);
+ int offset = 0 ;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ emitpcode(POC_MOVFW,popGet(AOP(left),0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+ while(size--) {
+ emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset++));
+ if(size)
+ emitpcode(POC_INCF,popCopyReg(&pc_fsr));
+ }
+/*
while (size--) {
if (IS_AOP_PREG(result) || AOP_TYPE(result) == AOP_STK ) {
if (size)
pic14_emitcode("inc","%s",rname);
}
+*/
}
/* now some housekeeping stuff */
}
/* done */
+ freeAsmop(left,NULL,ic,TRUE);
freeAsmop(result,NULL,ic,TRUE);
}
DEBUGpic14_emitcode ("; "," %d getting const pointer",__LINE__);
emitpcode(POC_CALL,popGetLabel(albl->key));
+ emitpcodePagesel(popGetLabel(blbl->key)->name); /* Must restore PCLATH before goto, without destroying W */
emitpcode(POC_GOTO,popGetLabel(blbl->key));
emitpLabel(albl->key);
type = operandType(left);
etype = getSpec(type);
+#if 0
if (IS_PTR_CONST(type))
+#else
+ if (IS_CODEPTR(type))
+#endif
DEBUGpic14_emitcode ("; ***","%d - const pointer",__LINE__);
/* if left is of type of pointer then it is simple */
break;
case GPOINTER:
+#if 0
if (IS_PTR_CONST(type))
genConstPointerGet (left,result,ic);
else
+#endif
genGenPointerGet (left,result,ic);
break;
}
operand *result,
iCode *ic)
{
- asmop *aop = NULL;
- char *l;
- sym_link *retype;
- sym_link *ptype = operandType(result);
+ asmop *aop = NULL;
+ char *l;
+ sym_link *retype;
+ sym_link *ptype = operandType(result);
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- retype= getSpec(operandType(right));
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ retype= getSpec(operandType(right));
+
+ aopOp(result,ic,FALSE);
- aopOp(result,ic,FALSE);
- /* if the result is rematerializable &
- in data space & not a bit variable */
- //if (AOP_TYPE(result) == AOP_IMMD &&
- if (AOP_TYPE(result) == AOP_PCODE && //AOP_TYPE(result) == AOP_IMMD &&
- DCL_TYPE(ptype) == POINTER &&
- !IS_BITVAR(retype)) {
- genDataPointerSet (right,result,ic);
- return;
- }
+ /* if the result is rematerializable &
+ in data space & not a bit variable */
+ //if (AOP_TYPE(result) == AOP_IMMD &&
+ if (AOP_TYPE(result) == AOP_PCODE && //AOP_TYPE(result) == AOP_IMMD &&
+ DCL_TYPE(ptype) == POINTER &&
+ !IS_BITVAR(retype)) {
+ genDataPointerSet (right,result,ic);
+ freeAsmop(result,NULL,ic,TRUE);
+ return;
+ }
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(right,ic,FALSE);
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
+ /* if the value is already in a pointer register
+ then don't need anything more */
+ if (!AOP_INPREG(AOP(result))) {
+ /* otherwise get a free pointer register */
+ //aop = newAsmop(0);
+ //preg = getFreePtr(ic,&aop,FALSE);
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ //pic14_emitcode("mov","%s,%s",
+ // preg->name,
+ // aopGet(AOP(result),0,FALSE,TRUE));
+ //rname = preg->name ;
+ //pic14_emitcode("movwf","fsr");
+ emitpcode(POC_MOVFW, popGet(AOP(result),0));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_fsr));
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_indf));
+ goto release;
- /* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG(AOP(result))) {
- /* otherwise get a free pointer register */
- //aop = newAsmop(0);
- //preg = getFreePtr(ic,&aop,FALSE);
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- //pic14_emitcode("mov","%s,%s",
- // preg->name,
- // aopGet(AOP(result),0,FALSE,TRUE));
- //rname = preg->name ;
- pic14_emitcode("movwf","fsr");
- }// else
- // rname = aopGet(AOP(result),0,FALSE,FALSE);
+ }// else
+ // rname = aopGet(AOP(result),0,FALSE,FALSE);
- freeAsmop(result,NULL,ic,TRUE);
- aopOp (right,ic,FALSE);
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if bitfield then unpack the bits */
- if (IS_BITVAR(retype)) {
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "The programmer is obviously confused");
- //genPackBits (retype,right,rname,POINTER);
- exit(1);
- }
- else {
- /* we have can just get the values */
- int size = AOP_SIZE(right);
- int offset = 0 ;
+ /* if bitfield then unpack the bits */
+ if (IS_BITVAR(retype)) {
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "The programmer is obviously confused");
+ //genPackBits (retype,right,rname,POINTER);
+ exit(1);
+ }
+ else {
+ /* we have can just get the values */
+ int size = AOP_SIZE(right);
+ int offset = 0 ;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- while (size--) {
- l = aopGet(AOP(right),offset,FALSE,TRUE);
- if (*l == '@' ) {
- //MOVA(l);
- //pic14_emitcode("mov","@%s,a",rname);
- pic14_emitcode("movf","indf,w ;1");
- } else {
+ while (size--) {
+ l = aopGet(AOP(right),offset,FALSE,TRUE);
+ if (*l == '@' ) {
+ //MOVA(l);
+ //pic14_emitcode("mov","@%s,a",rname);
+ pic14_emitcode("movf","indf,w ;1");
+ } else {
- if (AOP_TYPE(right) == AOP_LIT) {
- unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
- if(lit) {
- pic14_emitcode("movlw","%s",l);
- pic14_emitcode("movwf","indf ;2");
- } else
- pic14_emitcode("clrf","indf");
- }else {
- pic14_emitcode("movf","%s,w",l);
- pic14_emitcode("movwf","indf ;2");
- }
- //pic14_emitcode("mov","@%s,%s",rname,l);
- }
- if (size)
- pic14_emitcode("incf","fsr,f ;3");
- //pic14_emitcode("inc","%s",rname);
- offset++;
- }
+ if (AOP_TYPE(right) == AOP_LIT) {
+ unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
+ if(lit) {
+ pic14_emitcode("movlw","%s",l);
+ pic14_emitcode("movwf","indf ;2");
+ } else
+ pic14_emitcode("clrf","indf");
+ }else {
+ pic14_emitcode("movf","%s,w",l);
+ pic14_emitcode("movwf","indf ;2");
+ }
+ //pic14_emitcode("mov","@%s,%s",rname,l);
+ }
+ if (size)
+ pic14_emitcode("incf","fsr,f ;3");
+ //pic14_emitcode("inc","%s",rname);
+ offset++;
}
+ }
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
+ /* we did not allocate which means left
+ already in a pointer register, then
+ if size > 0 && this could be used again
+ we have to point it back to where it
+ belongs */
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* now some housekeeping stuff */
- if (aop) {
- /* we had to allocate for this iCode */
- freeAsmop(NULL,aop,ic,TRUE);
- } else {
- /* we did not allocate which means left
- already in a pointer register, then
- if size > 0 && this could be used again
- we have to point it back to where it
- belongs */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (AOP_SIZE(right) > 1 &&
- !OP_SYMBOL(result)->remat &&
- ( OP_SYMBOL(result)->liveTo > ic->seq ||
- ic->depth )) {
- int size = AOP_SIZE(right) - 1;
- while (size--)
- pic14_emitcode("decf","fsr,f");
- //pic14_emitcode("dec","%s",rname);
- }
+ if (AOP_SIZE(right) > 1 &&
+ !OP_SYMBOL(result)->remat &&
+ ( OP_SYMBOL(result)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(right) - 1;
+ while (size--)
+ pic14_emitcode("decf","fsr,f");
+ //pic14_emitcode("dec","%s",rname);
}
+ }
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* done */
- freeAsmop(right,NULL,ic,TRUE);
-
-
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* done */
+ release:
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/* hack hack! see if this the FSR. If so don't load W */
if(AOP_TYPE(right) != AOP_ACC) {
+
emitpcode(POC_MOVFW,popGet(AOP(result),0));
emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+ if(AOP_SIZE(result) > 1) {
+ emitpcode(POC_BCF, popCopyGPR2Bit(PCOP(&pc_status),PIC_IRP_BIT));
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),1,FALSE,FALSE),0,0));
+ emitpcode(POC_BSF, popCopyGPR2Bit(PCOP(&pc_status),PIC_IRP_BIT));
+
+ }
+
//if(size==2)
//emitpcode(POC_DECF,popCopyReg(&pc_fsr));
//if(size==4) {
size = AOP_SIZE(right);
offset = 0 ;
- while (--size) {
- //char *l = aopGet(AOP(right),offset++,FALSE,FALSE);
- if(size)
- pic14_emitcode("incf","fsr,f");
- pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset++,FALSE,FALSE));
- pic14_emitcode("movwf","indf");
- //MOVA(l);
- //DEBUGpic14_emitcode(";lcall","__gptrput");
- //if (size)
- // pic14_emitcode("inc","dptr");
+ DEBUGpic14_emitcode ("; ***","%s %d size=%d",__FUNCTION__,__LINE__,size);
+
+ while (size--) {
+
+ emitpcode(POC_MOVFW,popGet(AOP(result),offset));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+
+ if (AOP_TYPE(right) == AOP_LIT)
+ emitpcode(POC_MOVLW, popGet(AOP(right),offset));
+ else
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+
+ emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
+
+ offset++;
}
}
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(AOP_TYPE(right) == AOP_LIT) {
if(lit&0xff) {
- if(know_W != (lit&0xff))
+ if(know_W != (int)(lit&0xff))
emitpcode(POC_MOVLW,popGetLit(lit&0xff));
know_W = lit&0xff;
emitpcode(POC_MOVWF, popGet(AOP(result),offset));
emitpcode(POC_INCF, popGet(AOP(result),0));
}
} else {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ mov2w (AOP(right), offset);
emitpcode(POC_MOVWF, popGet(AOP(result),offset));
}
pic14_emitcode("jmp","@a+dptr");
pic14_emitcode("","%05d_DS_:",jtab->key+100);
+ emitpcode(POC_MOVLW, popGetHighLabel(jtab->key));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
emitpcode(POC_MOVLW, popGetLabel(jtab->key));
emitpcode(POC_ADDFW, popGet(AOP(IC_JTCOND(ic)),0));
emitSKPNC;
goto release;
DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+#if 0
if (IS_PTR_CONST(rtype))
+#else
+ if (IS_CODEPTR(rtype))
+#endif
DEBUGpic14_emitcode ("; ***","%d - right is const pointer",__LINE__);
+#if 0
if (IS_PTR_CONST(operandType(IC_RESULT(ic))))
+#else
+ if (IS_CODEPTR(operandType(IC_RESULT(ic))))
+#endif
DEBUGpic14_emitcode ("; ***","%d - result is const pointer",__LINE__);
if ((AOP_TYPE(right) == AOP_PCODE) && AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
}
/* the first two bytes are known */
+ DEBUGpic14_emitcode("; ***","%s %d - pointer cast2",__FUNCTION__,__LINE__);
size = GPTRSIZE - 1;
offset = 0 ;
while (size--) {
- if(offset < AOP_SIZE(right))
- aopPut(AOP(result),
- aopGet(AOP(right),offset,FALSE,FALSE),
- offset);
- else
+ if(offset < AOP_SIZE(right)) {
+ DEBUGpic14_emitcode("; ***","%s %d - pointer cast3",__FUNCTION__,__LINE__);
+ if ((AOP_TYPE(right) == AOP_PCODE) &&
+ AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
+ emitpcode(POC_MOVLW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ } else {
+ aopPut(AOP(result),
+ aopGet(AOP(right),offset,FALSE,FALSE),
+ offset);
+ }
+ } else
emitpcode(POC_CLRF,popGet(AOP(result),offset));
offset++;
}
/* genReceive - generate code for a receive iCode */
/*-----------------------------------------------------------------*/
static void genReceive (iCode *ic)
-{
+{
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (isOperandInFarSpace(IC_RESULT(ic)) &&
+ if (isOperandInFarSpace(IC_RESULT(ic)) &&
( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
fReturn[fReturnSizePic - offset - 1] : "acc"));
offset++;
}
- aopOp(IC_RESULT(ic),ic,FALSE);
+ aopOp(IC_RESULT(ic),ic,FALSE);
size = AOP_SIZE(IC_RESULT(ic));
offset = 0;
while (size--) {
pic14_emitcode ("pop","acc");
aopPut (AOP(IC_RESULT(ic)),"a",offset++);
}
-
+
} else {
_G.accInUse++;
- aopOp(IC_RESULT(ic),ic,FALSE);
+ aopOp(IC_RESULT(ic),ic,FALSE);
_G.accInUse--;
- assignResultValue(IC_RESULT(ic));
+ assignResultValue(IC_RESULT(ic));
}
freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
+/*-----------------------------------------------------------------*/
+/* genDummyRead - generate code for dummy read of volatiles */
+/*-----------------------------------------------------------------*/
+static void
+genDummyRead (iCode * ic)
+{
+ pic14_emitcode ("; genDummyRead","");
+ pic14_emitcode ("; not implemented","");
+
+ ic = ic;
+}
+
/*-----------------------------------------------------------------*/
/* genpic14Code - generate code for pic14 based controllers */
/*-----------------------------------------------------------------*/
/* if debug information required */
if (options.debug && currFunc) {
if (currFunc) {
- cdbSymbol(currFunc,cdbFile,FALSE,TRUE);
+ debugFile->writeFunction(currFunc);
_G.debugLine = 1;
if (IS_STATIC(currFunc->etype)) {
pic14_emitcode("",";F%s$%s$0$0 %d",moduleName,currFunc->name,__LINE__);
ic->level,ic->block);
_G.debugLine = 0;
}
- pic14_emitcode("#CSRC","%s %d",FileBaseName(ic->filename),ic->lineno);
- pic14_emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
- printCLine(ic->filename, ic->lineno));
+ /*
+ pic14_emitcode("#CSRC","%s %d",FileBaseName(ic->filename),ic->lineno);
+ pic14_emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
+ printCLine(ic->filename, ic->lineno));
+ */
+ if (!options.noCcodeInAsm) {
+ addpCode2pBlock(pb,
+ newpCodeCSource(ic->lineno,
+ ic->filename,
+ printCLine(ic->filename, ic->lineno)));
+ }
cln = ic->lineno ;
}
+
+ // if you want printILine too, look at ../mcs51/gen.c, i don't understand this :)
+
/* if the result is marked as
spilt and rematerializable or code for
this has already been generated then
addSet(&_G.sendSet,ic);
break;
+ case DUMMY_READ_VOLATILE:
+ genDummyRead (ic);
+ break;
+
default :
ic = ic;
}
}
-
- /* now we are ready to call the
+
+ /* now we are ready to call the
peep hole optimizer */
if (!options.nopeep) {
peepHole (&lineHead);