#include "gen.h"
char *aopLiteral (value * val, int offset);
+char *aopLiteralLong (value * val, int offset, int size);
extern int allocInfo;
/* this is the down and dirty file with all kinds of
static unsigned short rbank = -1;
+#define AOP(op) op->aop
+#define AOP_TYPE(op) AOP(op)->type
+#define AOP_SIZE(op) AOP(op)->size
+#define IS_AOP_PREG(x) (AOP(x) && (AOP_TYPE(x) == AOP_R1 || \
+ AOP_TYPE(x) == AOP_R0))
+
+#define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY || \
+ AOP_TYPE(x) == AOP_DPTR || AOP(x)->paged))
+
+#define AOP_INPREG(x) (x && (x->type == AOP_REG && \
+ (x->aopu.aop_reg[0] == mcs51_regWithIdx(R0_IDX) || \
+ x->aopu.aop_reg[0] == mcs51_regWithIdx(R1_IDX) )))
+
+
+#define SYM_BP(sym) (SPEC_OCLS (sym->etype)->paged ? "_bpx" : "_bp")
+
+#define R0INB _G.bu.bs.r0InB
+#define R1INB _G.bu.bs.r1InB
+#define OPINB _G.bu.bs.OpInB
+#define BINUSE _G.bu.BInUse
+
static struct
{
short r0Pushed;
short r1Pushed;
- short r0InB;
- short r1InB;
+ union
+ {
+ struct
+ {
+ short r0InB : 2;//2 so we can see it overflow
+ short r1InB : 2;//2 so we can see it overflow
+ short OpInB : 2;//2 so we can see it overflow
+ } bs;
+ short BInUse;
+ } bu;
short accInUse;
short inLine;
short debugLine;
_G;
static char *rb1regs[] = {
- "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7"
+ "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7",
+ "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7"
};
extern int mcs51_ptrRegReq;
extern int mcs51_nRegs;
extern FILE *codeOutFile;
static void saveRBank (int, iCode *, bool);
+
#define RESULTONSTACK(x) \
(IC_RESULT(x) && IC_RESULT(x)->aop && \
IC_RESULT(x)->aop->type == AOP_STK )
-#define MOVA(x) mova(x) /* use function to avoid multiple eval */
-#define CLRC emitcode("clr","c")
-#define SETC emitcode("setb","c")
+#define MOVA(x) mova(x) /* use function to avoid multiple eval */
+#define CLRC emitcode("clr","c")
+#define SETC emitcode("setb","c")
static lineNode *lineHead = NULL;
static lineNode *lineCurr = NULL;
if (inst && *inst)
{
if (fmt && *fmt)
- SNPRINTF (lb, sizeof(lb), "%s\t", inst);
+ SNPRINTF (lb, sizeof(lb), "%s\t", inst);
else
- SNPRINTF (lb, sizeof(lb), "%s", inst);
+ SNPRINTF (lb, sizeof(lb), "%s", inst);
tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb), fmt, ap);
}
else
- tvsprintf (lb, sizeof(lb), fmt, ap);
+ tvsprintf (lb, sizeof(lb), fmt, ap);
while (isspace (*lbp))
- lbp++;
-
- //printf ("%s\n", lb);
+ lbp++;
if (lbp && *lbp)
- lineCurr = (lineCurr ?
- connectLine (lineCurr, newLineNode (lb)) :
- (lineHead = newLineNode (lb)));
+ lineCurr = (lineCurr ?
+ connectLine (lineCurr, newLineNode (lb)) :
+ (lineHead = newLineNode (lb)));
lineCurr->isInline = _G.inLine;
lineCurr->isDebug = _G.debugLine;
lineCurr->ic = _G.current_iCode;
mova (const char *x)
{
/* do some early peephole optimization */
- if (!strcmp(x, "a") || !strcmp(x, "acc"))
+ if (!strncmp(x, "a", 2) || !strncmp(x, "acc", 4))
return;
emitcode("mov","a,%s", x);
}
+/*-----------------------------------------------------------------*/
+/* movc - moves specified value into the carry */
+/*-----------------------------------------------------------------*/
+static void
+movc (const char *s)
+{
+ if (s == zero)
+ CLRC;
+ else if (s == one)
+ SETC;
+ else if (strcmp (s, "c"))
+ {/* it's not in carry already */
+ MOVA (s);
+ /* set C, if a >= 1 */
+ emitcode ("add", "a,#0xff");
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* pushB - saves register B if necessary */
+/*-----------------------------------------------------------------*/
+static bool
+pushB (void)
+{
+ bool pushedB = FALSE;
+
+ if (BINUSE)
+ {
+ emitcode ("push", "b");
+// printf("B was in use !\n");
+ pushedB = TRUE;
+ }
+ else
+ {
+ OPINB++;
+ }
+ return pushedB;
+}
+
+/*-----------------------------------------------------------------*/
+/* popB - restores value of register B if necessary */
+/*-----------------------------------------------------------------*/
+static void
+popB (bool pushedB)
+{
+ if (pushedB)
+ {
+ emitcode ("pop", "b");
+ }
+ else
+ {
+ OPINB--;
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* pushReg - saves register */
+/*-----------------------------------------------------------------*/
+static bool
+pushReg (int index, bool bits_pushed)
+{
+ regs * reg = mcs51_regWithIdx (index);
+ if (reg->type == REG_BIT)
+ {
+ if (!bits_pushed)
+ emitcode ("push", "%s", reg->base);
+ return TRUE;
+ }
+ else
+ emitcode ("push", "%s", reg->dname);
+ return bits_pushed;
+}
+
+/*-----------------------------------------------------------------*/
+/* popReg - restores register */
+/*-----------------------------------------------------------------*/
+static bool
+popReg (int index, bool bits_popped)
+{
+ regs * reg = mcs51_regWithIdx (index);
+ if (reg->type == REG_BIT)
+ {
+ if (!bits_popped)
+ emitcode ("pop", "%s", reg->base);
+ return TRUE;
+ }
+ else
+ emitcode ("pop", "%s", reg->dname);
+ return bits_popped;
+}
+
/*-----------------------------------------------------------------*/
/* getFreePtr - returns r0 or r1 whichever is free or can be pushed */
/*-----------------------------------------------------------------*/
static regs *
getFreePtr (iCode * ic, asmop ** aopp, bool result)
{
- bool r0iu = FALSE, r1iu = FALSE;
- bool r0ou = FALSE, r1ou = FALSE;
+ bool r0iu, r1iu;
+ bool r0ou, r1ou;
/* the logic: if r0 & r1 used in the instruction
then we are in trouble otherwise */
{
emitcode ("mov", "b,%s",
mcs51_regWithIdx (R0_IDX)->dname);
- _G.r0InB++;
+ R0INB++;
}
else if (!_G.r0Pushed)
{
{
emitcode ("mov", "b,%s",
mcs51_regWithIdx (R1_IDX)->dname);
- _G.r1InB++;
+ R1INB++;
}
else if (!_G.r1Pushed)
{
}
-
/*-----------------------------------------------------------------*/
/* leftRightUseAcc - returns size of accumulator use by operands */
/*-----------------------------------------------------------------*/
return accuse;
}
-
/*-----------------------------------------------------------------*/
/* aopForSym - for a true symbol */
/*-----------------------------------------------------------------*/
if (sym->onStack)
{
- if (_G.accInUse || leftRightUseAcc (ic))
- emitcode ("push", "acc");
-
- emitcode ("mov", "a,_bp");
- emitcode ("add", "a,#0x%02x",
- ((sym->stack < 0) ?
+ char offset = ((sym->stack < 0) ?
((char) (sym->stack - _G.nRegsSaved)) :
- ((char) sym->stack)) & 0xff);
- emitcode ("mov", "%s,a",
- aop->aopu.aop_ptr->name);
+ ((char) sym->stack)) & 0xff;
- if (_G.accInUse || leftRightUseAcc (ic))
- emitcode ("pop", "acc");
+ if ((offset >= -3) && (offset <= 3))
+ {
+ emitcode ("mov", "%s,%s",
+ aop->aopu.aop_ptr->name, SYM_BP (sym));
+ while (offset < 0)
+ {
+ emitcode ("dec", aop->aopu.aop_ptr->name);
+ offset++;
+ }
+ while (offset > 0)
+ {
+ emitcode ("inc", aop->aopu.aop_ptr->name);
+ offset--;
+ }
+ }
+ else
+ {
+ if (_G.accInUse || leftRightUseAcc (ic))
+ emitcode ("push", "acc");
+ emitcode ("mov", "a,%s", SYM_BP (sym));
+ emitcode ("add", "a,#0x%02x", offset);
+ emitcode ("mov", "%s,a",
+ aop->aopu.aop_ptr->name);
+ if (_G.accInUse || leftRightUseAcc (ic))
+ emitcode ("pop", "acc");
+ }
}
else
emitcode ("mov", "%s,#%s",
sym->aop = aop = newAsmop (AOP_IMMD);
aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (sym->rname) + 1);
strcpy (aop->aopu.aop_immd.aop_immd1, sym->rname);
- aop->size = FPTRSIZE;
+ aop->size = getSize (sym->type);
return aop;
}
{
iCode *ic = sym->rematiCode;
asmop *aop = newAsmop (AOP_IMMD);
- int ptr_type=0;
+ int ptr_type = 0;
int val = 0;
for (;;)
sym_link *from_type = operandType(IC_RIGHT(ic));
aop->aopu.aop_immd.from_cast_remat = 1;
ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
- ptr_type = DCL_TYPE(from_type);
- if (ptr_type == IPOINTER) {
- // bug #481053
- ptr_type = POINTER;
- }
+ ptr_type = pointerTypeToGPByte (DCL_TYPE(from_type), NULL, NULL);
continue ;
} else break;
{
symbol *sym1, *sym2;
- /* if they not symbols */
+ /* if they're not symbols */
if (!IS_SYMOP (op1) || !IS_SYMOP (op2))
return FALSE;
if (sym1 == sym2)
return TRUE;
- if (sym1->rname[0] && sym2->rname[0]
- && strcmp (sym1->rname, sym2->rname) == 0)
+ /* if they have the same rname */
+ if (sym1->rname[0] && sym2->rname[0] &&
+ strcmp (sym1->rname, sym2->rname) == 0 &&
+ !(IS_PARM (op2) && IS_ITEMP (op1)))
return TRUE;
/* if left is a tmp & right is not */
if (aop1 == aop2)
return TRUE;
- if (aop1->type != AOP_REG ||
- aop2->type != AOP_REG)
+ if (aop1->type != AOP_REG && aop1->type != AOP_CRY)
+ return FALSE;
+
+ if (aop1->type != aop2->type)
return FALSE;
if (aop1->size != aop2->size)
}
/* this is a temporary : this has
- only four choices :
+ only five choices :
a) register
b) spillocation
c) rematerialize
return;
}
+ /* if the type is a bit register */
+ if (sym->regType == REG_BIT)
+ {
+ sym->aop = op->aop = aop = newAsmop (AOP_CRY);
+ aop->size = sym->nRegs;//1???
+ aop->aopu.aop_reg[0] = sym->regs[0];
+ aop->aopu.aop_dir = sym->regs[0]->name;
+ return;
+ }
+
/* must be in a register */
sym->aop = op->aop = aop = newAsmop (AOP_REG);
aop->size = sym->nRegs;
switch (aop->type)
{
case AOP_R0:
- if (_G.r0InB)
+ if (R0INB)
{
emitcode ("mov", "r0,b");
- _G.r0InB--;
+ R0INB--;
}
else if (_G.r0Pushed)
{
break;
case AOP_R1:
- if (_G.r1InB)
+ if (R1INB)
{
emitcode ("mov", "r1,b");
- _G.r1InB--;
+ R1INB--;
}
if (_G.r1Pushed)
{
switch (aop->type)
{
case AOP_R0:
- if (_G.r0InB)
+ if (R0INB)
{
emitcode ("mov", "r0,b");
}
break;
case AOP_R1:
- if (_G.r1InB)
+ if (R1INB)
{
emitcode ("mov", "r1,b");
}
/* clobber the accumulator */
/*-----------------------------------------------------------------*/
static bool
-aopGetUsesAcc (asmop *aop, int offset)
+aopGetUsesAcc (operand * oper, int offset)
{
+ asmop * aop = AOP (oper);
+
if (offset > (aop->size - 1))
return FALSE;
case AOP_CRY:
return TRUE;
case AOP_ACC:
+ if (offset)
+ return FALSE;
return TRUE;
case AOP_LIT:
return FALSE;
/* aopGet - for fetching value of the aop */
/*-----------------------------------------------------------------*/
static char *
-aopGet (asmop * aop, int offset, bool bit16, bool dname)
+aopGet (operand * oper, int offset, bool bit16, bool dname)
{
char *s = buffer;
char *rs;
+ asmop * aop = AOP (oper);
/* offset is greater than
size then zero */
return rs;
case AOP_DIR:
- if (offset)
+ if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset)
+ sprintf (s, "(%s >> %d)",
+ aop->aopu.aop_dir, offset * 8);
+ else if (offset)
sprintf (s, "(%s + %d)",
aop->aopu.aop_dir,
offset);
exit (1);
}
/*-----------------------------------------------------------------*/
-/* aopPut - puts a string for a aop */
+/* aopPut - puts a string for a aop and indicates if acc is in use */
/*-----------------------------------------------------------------*/
-static void
-aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
+static bool
+aopPut (operand * result, const char *s, int offset, bool bvolatile)
{
char *d = buffer;
+ bool accuse = FALSE;
+ asmop * aop = AOP (result);
if (aop->size && offset > (aop->size - 1))
{
{
case AOP_DUMMY:
MOVA (s); /* read s in case it was volatile */
+ accuse = TRUE;
break;
case AOP_DIR:
- if (offset)
+ if (SPEC_SCLS (getSpec (operandType (result))) == S_SFR && offset)
+ sprintf (d, "(%s >> %d)",
+ aop->aopu.aop_dir, offset * 8);
+ else if (offset)
sprintf (d, "(%s + %d)",
aop->aopu.aop_dir, offset);
else
if (strcmp (d, s) ||
bvolatile)
- emitcode ("mov", "%s,%s", d, s);
+ emitcode ("mov", "%s,%s", d, s);
+ if (!strcmp (d, "acc"))
+ accuse = TRUE;
break;
aop->coff = offset;
- /* if not in accumulater */
+ /* if not in accumulator */
MOVA (s);
emitcode ("movx", "@dptr,a");
break;
case AOP_CRY:
- /* if bit variable */
+ /* if not bit variable */
if (!aop->aopu.aop_dir)
{
+ /* inefficient: move carry into A and use jz/jnz */
emitcode ("clr", "a");
emitcode ("rlc", "a");
+ accuse = TRUE;
}
else
{
emitcode ("setb", "%s", aop->aopu.aop_dir);
else if (!strcmp (s, "c"))
emitcode ("mov", "%s,c", aop->aopu.aop_dir);
- else
+ else if (strcmp (s, aop->aopu.aop_dir))
{
- if (strcmp (s, "a"))
- {
- MOVA (s);
- }
- {
- /* set C, if a >= 1 */
- emitcode ("add", "a,#0xff");
- emitcode ("mov", "%s,c", aop->aopu.aop_dir);
- }
+ MOVA (s);
+ /* set C, if a >= 1 */
+ emitcode ("add", "a,#0xff");
+ emitcode ("mov", "%s,c", aop->aopu.aop_dir);
}
}
break;
break;
case AOP_ACC:
+ accuse = TRUE;
aop->coff = offset;
if (!offset && (strcmp (s, "acc") == 0) &&
!bvolatile)
exit (1);
}
+ return accuse;
}
aop->coff = 0;
}
-#define AOP(op) op->aop
-#define AOP_TYPE(op) AOP(op)->type
-#define AOP_SIZE(op) AOP(op)->size
-#define IS_AOP_PREG(x) (AOP(x) && (AOP_TYPE(x) == AOP_R1 || \
- AOP_TYPE(x) == AOP_R0))
-
-#define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY || \
- AOP_TYPE(x) == AOP_DPTR || AOP(x)->paged))
-
-#define AOP_INPREG(x) (x && (x->type == AOP_REG && \
- (x->aopu.aop_reg[0] == mcs51_regWithIdx(R0_IDX) || \
- x->aopu.aop_reg[0] == mcs51_regWithIdx(R1_IDX) )))
-
-
/*-----------------------------------------------------------------*/
/* opIsGptr: returns non-zero if the passed operand is */
/* a generic pointer type. */
size = getDataSize (result);
if (size)
{
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
size--;
offset = 1;
/* unsigned or positive */
while (size--)
{
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
}
}
}
{
/* if the result is bit */
if (AOP_TYPE (result) == AOP_CRY)
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
else
{
emitcode ("clr", "a");
{
int size = AOP_SIZE (oper) - 1;
int offset = 1;
- MOVA (aopGet (AOP (oper), 0, FALSE, FALSE));
- while (size--)
- emitcode ("orl", "a,%s", aopGet (AOP (oper), offset++, FALSE, FALSE));
+ bool AccUsed = FALSE;
+ bool pushedB;
+
+ while (!AccUsed && size--)
+ {
+ AccUsed |= aopGetUsesAcc(oper, offset++);
+ }
+
+ size = AOP_SIZE (oper) - 1;
+ offset = 1;
+ MOVA (aopGet (oper, 0, FALSE, FALSE));
+ if (size && AccUsed && (AOP (oper)->type != AOP_ACC))
+ {
+ pushedB = pushB ();
+ emitcode("mov", "b,a");
+ while (--size)
+ {
+ MOVA (aopGet (oper, offset++, FALSE, FALSE));
+ emitcode ("orl", "b,a");
+ }
+ MOVA (aopGet (oper, offset++, FALSE, FALSE));
+ emitcode ("orl", "a,b");
+ popB (pushedB);
+ }
+ else
+ {
+ while (size--)
+ {
+ emitcode ("orl", "a,%s", aopGet (oper, offset++, FALSE, FALSE));
+ }
+ }
}
int offset = 0;
int size;
symbol *tlbl;
+ sym_link *letype = getSpec (operandType (IC_LEFT (ic)));
- D(emitcode ("; genCpl",""));
+ D(emitcode (";", "genCpl"));
/* assign asmOps to operand & result */
aopOp (IC_LEFT (ic), ic, FALSE);
/* special case if in bit space */
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
+ char *l;
+
+ if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY ||
+ (SPEC_USIGN (letype) && IS_CHAR (letype)))
{
- /* promotion rules are responsible for this strange result: */
+ /* promotion rules are responsible for this strange result:
+ bit -> int -> ~int -> bit
+ uchar -> int -> ~int -> bit
+ */
+ werror(W_COMPLEMENT);
emitcode ("setb", "%s", IC_RESULT (ic)->aop->aopu.aop_dir);
goto release;
}
tlbl=newiTempLabel(NULL);
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC ||
+ l = aopGet (IC_LEFT (ic), offset++, FALSE, FALSE);
+ if ((AOP_TYPE (IC_LEFT (ic)) == AOP_ACC && offset == 0) ||
AOP_TYPE (IC_LEFT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_LEFT (ic)))
{
- emitcode ("cjne", "%s,#0x01,%05d$",
- aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE),
- tlbl->key + 100);
+ emitcode ("cjne", "%s,#0xFF,%05d$", l, tlbl->key + 100);
}
else
{
- char *l = aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE);
MOVA (l);
- emitcode ("cjne", "a,#0x01,%05d$", tlbl->key + 100);
+ emitcode ("cjne", "a,#0xFF,%05d$", tlbl->key + 100);
}
emitcode ("", "%05d$:", tlbl->key + 100);
outBitC (IC_RESULT(ic));
size = AOP_SIZE (IC_RESULT (ic));
while (size--)
{
- char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE);
+ char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
MOVA (l);
emitcode ("cpl", "a");
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (op), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (op, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
offset++;
}
- l = aopGet (AOP (op), offset, FALSE, FALSE);
+ l = aopGet (op, offset, FALSE, FALSE);
MOVA (l);
emitcode ("cpl", "acc.7");
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
//CLRC ;
while (size--)
{
- char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE);
+ char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
if (!strcmp (l, "a"))
{
if (offset == 0)
emitcode ("clr", "a");
emitcode ("subb", "a,%s", l);
}
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
/* if any remaining bytes in the result */
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
release:
IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT (ic)))))
return;
- /* safe the registers in use at this time but skip the
+ /* save the registers in use at this time but skip the
ones for the result */
rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
mcs51_rUmaskForOp (IC_RESULT(ic)));
ic->regsSaved = 1;
if (options.useXstack)
{
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "b,r0");
- emitcode ("mov", "r0,%s", spname);
- for (i = 0; i < mcs51_nRegs; i++)
+ int count = bitVectnBitsOn (rsave);
+
+ if (count == 1)
{
- if (bitVectBitValue (rsave, i))
+ regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));
+ if (reg->type == REG_BIT)
{
- if (i == R0_IDX)
- emitcode ("mov", "a,b");
- else
- emitcode ("mov", "a,%s", mcs51_regWithIdx (i)->name);
- emitcode ("movx", "@r0,a");
- emitcode ("inc", "r0");
+ emitcode ("mov", "a,%s", reg->base);
+ }
+ else
+ {
+ emitcode ("mov", "a,%s", reg->name);
+ }
+ emitcode ("mov", "r0,%s", spname);
+ emitcode ("inc", "%s", spname);// allocate before use
+ emitcode ("movx", "@r0,a");
+ if (bitVectBitValue (rsave, R0_IDX))
+ emitcode ("mov", "r0,a");
+ }
+ else if (count != 0)
+ {
+ bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+ int nBits = bitVectnBitsOn (rsavebits);
+
+ if (nBits != 0)
+ {
+ count = count - nBits + 1;
+ /* remove all but the first bits as they are pushed all at once */
+ rsave = bitVectCplAnd (rsave, rsavebits);
+ rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
+ }
+
+ if (bitVectBitValue (rsave, R0_IDX))
+ {
+ emitcode ("push", "%s", mcs51_regWithIdx (R0_IDX)->dname);
+ }
+ emitcode ("mov", "r0,%s", spname);
+ MOVA ("r0");
+ emitcode ("add", "a,#%d", count);
+ emitcode ("mov", "%s,a", spname);
+ for (i = 0; i < mcs51_nRegs; i++)
+ {
+ if (bitVectBitValue (rsave, i))
+ {
+ regs * reg = mcs51_regWithIdx (i);
+ if (i == R0_IDX)
+ {
+ emitcode ("pop", "acc");
+ emitcode ("push", "acc");
+ }
+ else if (reg->type == REG_BIT)
+ {
+ emitcode ("mov", "a,%s", reg->base);
+ }
+ else
+ {
+ emitcode ("mov", "a,%s", reg->name);
+ }
+ emitcode ("movx", "@r0,a");
+ if (--count)
+ {
+ emitcode ("inc", "r0");
+ }
+ }
+ }
+ if (bitVectBitValue (rsave, R0_IDX))
+ {
+ emitcode ("pop", "%s", mcs51_regWithIdx (R0_IDX)->dname);
}
}
- emitcode ("mov", "%s,r0", spname);
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "r0,b");
}
else
+ {
+ bool bits_pushed = FALSE;
for (i = 0; i < mcs51_nRegs; i++)
{
if (bitVectBitValue (rsave, i))
- emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
+ {
+ bits_pushed = pushReg (i, bits_pushed);
+ }
+ }
}
}
if (options.useXstack)
{
- emitcode ("mov", "r0,%s", spname);
- for (i = mcs51_nRegs; i >= 0; i--)
+ int count = bitVectnBitsOn (rsave);
+
+ if (count == 1)
{
- if (bitVectBitValue (rsave, i))
+ regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));
+ emitcode ("mov", "r0,%s", spname);
+ emitcode ("dec", "r0");
+ emitcode ("movx", "a,@r0");
+ if (reg->type == REG_BIT)
{
- emitcode ("dec", "r0");
- emitcode ("movx", "a,@r0");
- if (i == R0_IDX)
- emitcode ("mov", "b,a");
- else
- emitcode ("mov", "%s,a", mcs51_regWithIdx (i)->name);
+ emitcode ("mov", "%s,a", reg->base);
+ }
+ else
+ {
+ emitcode ("mov", "%s,a", reg->name);
+ }
+ emitcode ("dec", "%s", spname);
+ }
+ else if (count != 0)
+ {
+ bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+ int nBits = bitVectnBitsOn (rsavebits);
+
+ if (nBits != 0)
+ {
+ count = count - nBits + 1;
+ /* remove all but the first bits as they are popped all at once */
+ rsave = bitVectCplAnd (rsave, rsavebits);
+ rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
}
+ emitcode ("mov", "r0,%s", spname);
+ for (i = mcs51_nRegs; i >= 0; i--)
+ {
+ if (bitVectBitValue (rsave, i))
+ {
+ regs * reg = mcs51_regWithIdx (i);
+ emitcode ("dec", "r0");
+ emitcode ("movx", "a,@r0");
+ if (i == R0_IDX)
+ {
+ emitcode ("push", "acc");
+ }
+ else if (reg->type == REG_BIT)
+ {
+ emitcode ("mov", "%s,a", reg->base);
+ }
+ else
+ {
+ emitcode ("mov", "%s,a", reg->name);
+ }
+ }
+ }
+ emitcode ("mov", "%s,r0", spname);
+ if (bitVectBitValue (rsave, R0_IDX))
+ {
+ emitcode ("pop", "ar0");
+ }
}
- emitcode ("mov", "%s,r0", spname);
- if (bitVectBitValue (rsave, R0_IDX))
- emitcode ("mov", "r0,b");
}
else
+ {
+ bool bits_popped = FALSE;
for (i = mcs51_nRegs; i >= 0; i--)
{
if (bitVectBitValue (rsave, i))
- emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
+ {
+ bits_popped = popReg (i, bits_popped);
+ }
+ }
}
-
}
int offset = 0;
while (size--)
{
- char *l = aopGet (AOP (oper), offset++, FALSE, TRUE);
+ char *l = aopGet (oper, offset++, FALSE, TRUE);
if (AOP_TYPE (oper) != AOP_REG &&
AOP_TYPE (oper) != AOP_DIR &&
strcmp (l, "a"))
emitcode ("push", "acc");
}
else
- emitcode ("push", "%s", l);
+ {
+ emitcode ("push", "%s", l);
+ }
}
}
/*-----------------------------------------------------------------*/
-/* assignResultValue - */
+/* assignResultValue - also indicates if acc is in use afterwards */
/*-----------------------------------------------------------------*/
-static void
-assignResultValue (operand * oper)
+static bool
+assignResultValue (operand * oper, operand * func)
{
int offset = 0;
int size = AOP_SIZE (oper);
+ bool accuse = FALSE;
+
+ if (func && IS_BIT (OP_SYM_ETYPE (func)))
+ {
+ outBitC (oper);
+ return FALSE;
+ }
+
while (size--)
{
- aopPut (AOP (oper), fReturn[offset], offset, isOperandVolatile (oper, FALSE));
+ accuse |= aopPut (oper, fReturn[offset], offset, isOperandVolatile (oper, FALSE));
offset++;
}
+ return accuse;
}
aopOp (IC_LEFT (ic), ic, FALSE);
r = getFreePtr (ic, &aop, FALSE);
-
- emitcode ("mov", "%s,_spx", r->name);
-
size = AOP_SIZE (IC_LEFT (ic));
- while (size--)
- {
- char *l = aopGet (AOP (IC_LEFT (ic)),
- offset++, FALSE, FALSE);
- MOVA (l);
+ if (size == 1)
+ {
+ MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
+ emitcode ("mov", "%s,%s", r->name, spname);
+ emitcode ("inc", "%s", spname); // allocate space first
emitcode ("movx", "@%s,a", r->name);
- emitcode ("inc", "%s", r->name);
-
}
+ else
+ {
+ // allocate space first
+ emitcode ("mov", "%s,%s", r->name, spname);
+ MOVA (r->name);
+ emitcode ("add", "a,#%d", size);
+ emitcode ("mov", "%s,a", spname);
-
- emitcode ("mov", "_spx,%s", r->name);
+ while (size--)
+ {
+ MOVA (aopGet (IC_LEFT (ic), offset++, FALSE, FALSE));
+ emitcode ("movx", "@%s,a", r->name);
+ emitcode ("inc", "%s", r->name);
+ }
+ }
freeAsmop (NULL, aop, ic, TRUE);
freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
-/* genIpush - genrate code for pushing this gets a little complex */
+/* genIpush - generate code for pushing this gets a little complex */
/*-----------------------------------------------------------------*/
static void
genIpush (iCode * ic)
{
int size, offset = 0;
char *l;
+ char *prev = "";
D(emitcode ("; genIpush",""));
/* push it on the stack */
while (size--)
{
- l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE);
+ l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE);
if (*l == '#')
{
MOVA (l);
return;
}
- /* this is a paramter push: in this case we call
+ /* this is a parameter push: in this case we call
the routine to find the call and save those
registers that need to be saved */
saveRegisters (ic);
/* then do the push */
aopOp (IC_LEFT (ic), ic, FALSE);
-
// pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
size = AOP_SIZE (IC_LEFT (ic));
while (size--)
{
- l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE);
+ l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE);
if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG &&
AOP_TYPE (IC_LEFT (ic)) != AOP_DIR &&
strcmp (l, "a"))
{
+ if (strcmp (l, prev) || *l == '@')
MOVA (l);
emitcode ("push", "acc");
}
else
- emitcode ("push", "%s", l);
+ {
+ emitcode ("push", "%s", l);
+ }
+ prev = l;
}
freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
size = AOP_SIZE (IC_LEFT (ic));
offset = (size - 1);
while (size--)
- emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--,
+ emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--,
FALSE, TRUE));
freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
-/* unsaveRBank - restores the resgister bank from stack */
+/* saveRBank - saves an entire register bank on the stack */
/*-----------------------------------------------------------------*/
static void
-unsaveRBank (int bank, iCode * ic, bool popPsw)
+saveRBank (int bank, iCode * ic, bool pushPsw)
{
int i;
+ int count = mcs51_nRegs + (pushPsw ? 1 : 0);
asmop *aop = NULL;
regs *r = NULL;
if (options.useXstack)
- {
+ {
if (!ic)
{
/* Assume r0 is available for use. */
aop = newAsmop (0);
r = getFreePtr (ic, &aop, FALSE);
}
- emitcode ("mov", "%s,_spx", r->name);
- }
+ // allocate space first
+ emitcode ("mov", "%s,%s", r->name, spname);
+ MOVA (r->name);
+ emitcode ("add", "a,#%d", count);
+ emitcode ("mov", "%s,a", spname);
+ }
- if (popPsw)
+ for (i = 0; i < mcs51_nRegs; i++)
{
if (options.useXstack)
- {
- emitcode ("movx", "a,@%s", r->name);
- emitcode ("mov", "psw,a");
- emitcode ("dec", "%s", r->name);
+ {
+ emitcode ("mov", "a,(%s+%d)",
+ regs8051[i].base, 8 * bank + regs8051[i].offset);
+ emitcode ("movx", "@%s,a", r->name);
+ if (--count)
+ emitcode ("inc", "%s", r->name);
}
else
- {
- emitcode ("pop", "psw");
- }
+ emitcode ("push", "(%s+%d)",
+ regs8051[i].base, 8 * bank + regs8051[i].offset);
}
- for (i = (mcs51_nRegs - 1); i >= 0; i--)
+ if (pushPsw)
{
if (options.useXstack)
{
- emitcode ("movx", "a,@%s", r->name);
- emitcode ("mov", "(%s+%d),a",
- regs8051[i].base, 8 * bank + regs8051[i].offset);
- emitcode ("dec", "%s", r->name);
+ emitcode ("mov", "a,psw");
+ emitcode ("movx", "@%s,a", r->name);
}
else
- emitcode ("pop", "(%s+%d)",
- regs8051[i].base, 8 * bank + regs8051[i].offset);
+ {
+ emitcode ("push", "psw");
+ }
+
+ emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
}
- if (options.useXstack)
+ if (aop)
{
- emitcode ("mov", "_spx,%s", r->name);
+ freeAsmop (NULL, aop, ic, TRUE);
}
- if (aop)
+ if (ic)
{
- freeAsmop (NULL, aop, ic, TRUE);
+ ic->bankSaved = 1;
}
}
/*-----------------------------------------------------------------*/
-/* saveRBank - saves an entire register bank on the stack */
+/* unsaveRBank - restores the register bank from stack */
/*-----------------------------------------------------------------*/
static void
-saveRBank (int bank, iCode * ic, bool pushPsw)
+unsaveRBank (int bank, iCode * ic, bool popPsw)
{
int i;
asmop *aop = NULL;
if (options.useXstack)
{
if (!ic)
- {
+ {
/* Assume r0 is available for use. */
r = mcs51_regWithIdx (R0_IDX);;
- }
+ }
else
- {
+ {
aop = newAsmop (0);
r = getFreePtr (ic, &aop, FALSE);
- }
- emitcode ("mov", "%s,_spx", r->name);
+ }
+ emitcode ("mov", "%s,%s", r->name, spname);
}
- for (i = 0; i < mcs51_nRegs; i++)
+ if (popPsw)
{
if (options.useXstack)
{
- emitcode ("inc", "%s", r->name);
- emitcode ("mov", "a,(%s+%d)",
- regs8051[i].base, 8 * bank + regs8051[i].offset);
- emitcode ("movx", "@%s,a", r->name);
+ emitcode ("dec", "%s", r->name);
+ emitcode ("movx", "a,@%s", r->name);
+ emitcode ("mov", "psw,a");
}
else
- emitcode ("push", "(%s+%d)",
- regs8051[i].base, 8 * bank + regs8051[i].offset);
+ {
+ emitcode ("pop", "psw");
+ }
}
- if (pushPsw)
+ for (i = (mcs51_nRegs - 1); i >= 0; i--)
{
if (options.useXstack)
{
- emitcode ("mov", "a,psw");
- emitcode ("movx", "@%s,a", r->name);
- emitcode ("inc", "%s", r->name);
- emitcode ("mov", "_spx,%s", r->name);
-
+ emitcode ("dec", "%s", r->name);
+ emitcode ("movx", "a,@%s", r->name);
+ emitcode ("mov", "(%s+%d),a",
+ regs8051[i].base, 8 * bank + regs8051[i].offset);
}
else
- {
- emitcode ("push", "psw");
- }
-
- emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
+ {
+ emitcode ("pop", "(%s+%d)",
+ regs8051[i].base, 8 * bank + regs8051[i].offset);
+ }
}
- if (aop)
+ if (options.useXstack)
{
- freeAsmop (NULL, aop, ic, TRUE);
+ emitcode ("mov", "%s,%s", spname, r->name);
}
- if (ic)
- {
- ic->bankSaved = 1;
- }
+ if (aop)
+ {
+ freeAsmop (NULL, aop, ic, TRUE);
+ }
}
/*-----------------------------------------------------------------*/
static void genSend(set *sendSet)
{
iCode *sic;
- int rb1_count = 0 ;
+ int bit_count = 0;
+
+ /* first we do all bit parameters */
+ for (sic = setFirstItem (sendSet); sic;
+ sic = setNextItem (sendSet))
+ {
+ aopOp (IC_LEFT (sic), sic, FALSE);
+
+ if (sic->argreg > 12)
+ {
+ int bit = sic->argreg-13;
+
+ /* if left is a literal then
+ we know what the value is */
+ if (AOP_TYPE (IC_LEFT (sic)) == AOP_LIT)
+ {
+ if (((int) operandLitValue (IC_LEFT (sic))))
+ emitcode ("setb", "b[%d]", bit);
+ else
+ emitcode ("clr", "b[%d]", bit);
+ }
+ else if (AOP_TYPE (IC_LEFT (sic)) == AOP_CRY)
+ {
+ char *l = AOP (IC_LEFT (sic))->aopu.aop_dir;
+ if (strcmp (l, "c"))
+ emitcode ("mov", "c,%s", l);
+ emitcode ("mov", "b[%d],c", bit);
+ }
+ else
+ {
+ /* we need to or */
+ toBoolean (IC_LEFT (sic));
+ /* set C, if a >= 1 */
+ emitcode ("add", "a,#0xff");
+ emitcode ("mov", "b[%d],c", bit);
+ }
+ bit_count++;
+ }
+ freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+ }
- for (sic = setFirstItem (_G.sendSet); sic;
- sic = setNextItem (_G.sendSet)) {
+ if (bit_count)
+ {
+ saveRegisters (setFirstItem (sendSet));
+ emitcode ("mov", "bits,b");
+ }
+
+ /* then we do all other parameters */
+ for (sic = setFirstItem (sendSet); sic;
+ sic = setNextItem (sendSet))
+ {
int size, offset = 0;
aopOp (IC_LEFT (sic), sic, FALSE);
size = AOP_SIZE (IC_LEFT (sic));
- if (sic->argreg == 1) {
- while (size--) {
- char *l = aopGet (AOP (IC_LEFT (sic)), offset,
- FALSE, FALSE);
+ if (sic->argreg == 1)
+ {
+ while (size--)
+ {
+ char *l = aopGet (IC_LEFT (sic), offset, FALSE, FALSE);
if (strcmp (l, fReturn[offset]))
emitcode ("mov", "%s,%s", fReturn[offset], l);
offset++;
}
- rb1_count = 0;
- } else {
- while (size--) {
- emitcode ("mov","b1_%d,%s",rb1_count++,
- aopGet (AOP (IC_LEFT (sic)), offset++,FALSE, FALSE));
+ }
+ else if (sic->argreg <= 12)
+ {
+ while (size--)
+ {
+ emitcode ("mov","%s,%s", rb1regs[sic->argreg+offset-5],
+ aopGet (IC_LEFT (sic), offset,FALSE, FALSE));
+ offset++;
}
}
freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
sym_link *dtype;
// bool restoreBank = FALSE;
bool swapBanks = FALSE;
+ bool accuse = FALSE;
+ bool accPushed = FALSE;
+ bool resultInF0 = FALSE;
D(emitcode("; genCall",""));
dtype = operandType (IC_LEFT (ic));
- /* if send set is not empty the assign */
+ /* if send set is not empty then assign */
if (_G.sendSet)
{
if (IFFUNC_ISREENT(dtype)) { /* need to reverse the send set */
}
/* make the call */
- emitcode ("lcall", "%s", (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
- OP_SYMBOL (IC_LEFT (ic))->rname :
- OP_SYMBOL (IC_LEFT (ic))->name));
+ if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT(getSpec(dtype)))
+ {
+ if (IFFUNC_CALLEESAVES(dtype))
+ {
+ werror (E_BANKED_WITH_CALLEESAVES);
+ }
+ else
+ {
+ char *l = (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
+ OP_SYMBOL (IC_LEFT (ic))->rname :
+ OP_SYMBOL (IC_LEFT (ic))->name);
+
+ emitcode ("mov", "r0,#%s", l);
+ emitcode ("mov", "r1,#(%s >> 8)", l);
+ emitcode ("mov", "r2,#(%s >> 16)", l);
+ emitcode ("lcall", "__sdcc_banked_call");
+ }
+ }
+ else
+ {
+ emitcode ("lcall", "%s", (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
+ OP_SYMBOL (IC_LEFT (ic))->rname :
+ OP_SYMBOL (IC_LEFT (ic))->name));
+ }
if (swapBanks)
{
- emitcode ("mov", "psw,#0x%02x",
- ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
- }
+ /* if result is in carry */
+ if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))))
+ {
+ emitcode ("anl", "psw,#0xE7");
+ if (FUNC_REGBANK(currFunc->type))
+ emitcode ("orl", "psw,#0x%02x",
+ ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
+ }
+ else
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
+ }
+ }
/* if we need assign a result value */
if ((IS_ITEMP (IC_RESULT (ic)) &&
+ !IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) &&
(OP_SYMBOL (IC_RESULT (ic))->nRegs ||
OP_SYMBOL (IC_RESULT (ic))->accuse ||
OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
aopOp (IC_RESULT (ic), ic, FALSE);
_G.accInUse--;
- assignResultValue (IC_RESULT (ic));
+ accuse = assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
}
- /* adjust the stack for parameters if
- required */
+ /* adjust the stack for parameters if required */
if (ic->parmBytes)
{
int i;
if (ic->parmBytes > 3)
{
+ if (accuse)
+ {
+ emitcode ("push", "acc");
+ accPushed = TRUE;
+ }
+ if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) &&
+ IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))))
+ {
+ emitcode ("mov", "F0,c");
+ resultInF0 = TRUE;
+ }
+
emitcode ("mov", "a,%s", spname);
emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
emitcode ("mov", "%s,a", spname);
+
+ /* unsaveRegisters from xstack needs acc, but */
+ /* unsaveRegisters from stack needs this popped */
+ if (accPushed && !options.useXstack)
+ {
+ emitcode ("pop", "acc");
+ accPushed = FALSE;
+ }
}
else
for (i = 0; i < ic->parmBytes; i++)
emitcode ("dec", "%s", spname);
}
- /* if we hade saved some registers then unsave them */
+ /* if we had saved some registers then unsave them */
if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
- unsaveRegisters (ic);
+ {
+ if (accuse && !accPushed && options.useXstack)
+ {
+ /* xstack needs acc, but doesn't touch normal stack */
+ emitcode ("push", "acc");
+ accPushed = TRUE;
+ }
+ unsaveRegisters (ic);
+ }
// /* if register bank was saved then pop them */
// if (restoreBank)
// unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
+
+ if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))))
+ {
+ if (resultInF0)
+ emitcode ("mov", "c,F0");
+
+ aopOp (IC_RESULT (ic), ic, FALSE);
+ assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
+ freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ }
+
+ if (accPushed)
+ emitcode ("pop", "acc");
}
/*-----------------------------------------------------------------*/
genPcall (iCode * ic)
{
sym_link *dtype;
+ sym_link *etype;
symbol *rlbl = newiTempLabel (NULL);
// bool restoreBank=FALSE;
bool swapBanks = FALSE;
// need caution message to user here
}
- /* push the return address on to the stack */
- emitcode ("mov", "a,#%05d$", (rlbl->key + 100));
- emitcode ("push", "acc");
- emitcode ("mov", "a,#(%05d$ >> 8)", (rlbl->key + 100));
- emitcode ("push", "acc");
-
- /* now push the calling address */
- aopOp (IC_LEFT (ic), ic, FALSE);
+ etype = getSpec(dtype);
+ if (IS_LITERAL(etype))
+ {
+ /* if send set is not empty then assign */
+ if (_G.sendSet)
+ {
+ genSend(reverseSet(_G.sendSet));
+ _G.sendSet = NULL;
+ }
- pushSide (IC_LEFT (ic), FPTRSIZE);
+ if (swapBanks)
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+ }
- freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+ if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT(getSpec(dtype)))
+ {
+ if (IFFUNC_CALLEESAVES(dtype))
+ {
+ werror (E_BANKED_WITH_CALLEESAVES);
+ }
+ else
+ {
+ char *l = aopLiteralLong (OP_VALUE (IC_LEFT (ic)), 0, 2);
- /* if send set is not empty the assign */
- if (_G.sendSet)
- {
- genSend(reverseSet(_G.sendSet));
- _G.sendSet = NULL;
+ emitcode ("mov", "r0,#%s", l);
+ emitcode ("mov", "r1,#(%s >> 8)", l);
+ emitcode ("mov", "r2,#(%s >> 16)", l);
+ emitcode ("lcall", "__sdcc_banked_call");
+ }
+ }
+ else
+ {
+ emitcode ("lcall", "%s", aopLiteralLong (OP_VALUE (IC_LEFT (ic)), 0, 2));
+ }
}
+ else
+ {
+ if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT(getSpec(dtype)))
+ {
+ if (IFFUNC_CALLEESAVES(dtype))
+ {
+ werror (E_BANKED_WITH_CALLEESAVES);
+ }
+ else
+ {
+ aopOp (IC_LEFT (ic), ic, FALSE);
- if (swapBanks)
- {
- emitcode ("mov", "psw,#0x%02x",
- ((FUNC_REGBANK(dtype)) << 3) & 0xff);
- }
+ if (!swapBanks)
+ {
+ emitcode ("mov", "ar0,%s", aopGet(IC_LEFT (ic), 0, FALSE, FALSE));
+ emitcode ("mov", "ar1,%s", aopGet(IC_LEFT (ic), 1, FALSE, FALSE));
+ emitcode ("mov", "ar2,%s", aopGet(IC_LEFT (ic), 2, FALSE, FALSE));
+ }
+ else
+ {
+ int reg = ((FUNC_REGBANK(dtype)) << 3) & 0xff;
+ emitcode ("mov", "0x%02x,%s", reg++, aopGet(IC_LEFT (ic), 0, FALSE, FALSE));
+ emitcode ("mov", "0x%02x,%s", reg++, aopGet(IC_LEFT (ic), 1, FALSE, FALSE));
+ emitcode ("mov", "0x%02x,%s", reg, aopGet(IC_LEFT (ic), 2, FALSE, FALSE));
+ }
- /* make the call */
- emitcode ("ret", "");
- emitcode ("", "%05d$:", (rlbl->key + 100));
+ freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+ /* if send set is not empty then assign */
+ if (_G.sendSet)
+ {
+ genSend(reverseSet(_G.sendSet));
+ _G.sendSet = NULL;
+ }
+
+ if (swapBanks)
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+ }
+
+ /* make the call */
+ emitcode ("lcall", "__sdcc_banked_call");
+ }
+ }
+ else
+ {
+ /* push the return address on to the stack */
+ emitcode ("mov", "a,#%05d$", (rlbl->key + 100));
+ emitcode ("push", "acc");
+ emitcode ("mov", "a,#(%05d$ >> 8)", (rlbl->key + 100));
+ emitcode ("push", "acc");
+
+ /* now push the calling address */
+ aopOp (IC_LEFT (ic), ic, FALSE);
+
+ pushSide (IC_LEFT (ic), FPTRSIZE);
+
+ freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+
+ /* if send set is not empty the assign */
+ if (_G.sendSet)
+ {
+ genSend(reverseSet(_G.sendSet));
+ _G.sendSet = NULL;
+ }
+
+ if (swapBanks)
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+ }
+ /* make the call */
+ emitcode ("ret", "");
+ emitcode ("", "%05d$:", (rlbl->key + 100));
+ }
+ }
if (swapBanks)
{
emitcode ("mov", "psw,#0x%02x",
aopOp (IC_RESULT (ic), ic, FALSE);
_G.accInUse--;
- assignResultValue (IC_RESULT (ic));
+ assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
}
static void
genFunction (iCode * ic)
{
- symbol *sym = OP_SYMBOL (IC_LEFT (ic));
+ symbol *sym = OP_SYMBOL (IC_LEFT (ic));
sym_link *ftype;
- bool switchedPSW = FALSE;
- int calleesaves_saved_register = -1;
- int stackAdjust = sym->stack;
- int accIsFree = sym->recvSize < 4;
- iCode * ric = (ic->next && ic->next->op == RECEIVE) ? ic->next : NULL;
+ bool switchedPSW = FALSE;
+ int calleesaves_saved_register = -1;
+ int stackAdjust = sym->stack;
+ int accIsFree = sym->recvSize < 4;
+ iCode *ric = (ic->next && ic->next->op == RECEIVE) ? ic->next : NULL;
+ bool fReentrant = (IFFUNC_ISREENT (sym->type) || options.stackAuto);
_G.nRegsSaved = 0;
/* create the function header */
rbank = FUNC_REGBANK (ftype);
for (i = 0; i < mcs51_nRegs; i++)
{
- if (strcmp (regs8051[i].base, "0") == 0)
- emitcode ("", "%s = 0x%02x",
- regs8051[i].dname,
- 8 * rbank + regs8051[i].offset);
- else
- emitcode ("", "%s = %s + 0x%02x",
- regs8051[i].dname,
- regs8051[i].base,
- 8 * rbank + regs8051[i].offset);
+ if (regs8051[i].type != REG_BIT)
+ {
+ if (strcmp (regs8051[i].base, "0") == 0)
+ emitcode ("", "%s = 0x%02x",
+ regs8051[i].dname,
+ 8 * rbank + regs8051[i].offset);
+ else
+ emitcode ("", "%s = %s + 0x%02x",
+ regs8051[i].dname,
+ regs8051[i].base,
+ 8 * rbank + regs8051[i].offset);
+ }
}
}
/* if any registers used */
if (sym->regsUsed)
{
+ bool bits_pushed = FALSE;
/* save the registers used */
for (i = 0; i < sym->regsUsed->size; i++)
{
if (bitVectBitValue (sym->regsUsed, i))
- emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
+ bits_pushed = pushReg (i, bits_pushed);
}
}
}
/* if any registers used */
if (sym->regsUsed)
{
+ bool bits_pushed = FALSE;
/* save the registers used */
for (i = 0; i < sym->regsUsed->size; i++)
{
/* remember one saved register for later usage */
if (calleesaves_saved_register < 0)
calleesaves_saved_register = i;
- emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
+ bits_pushed = pushReg (i, bits_pushed);
_G.nRegsSaved++;
}
}
}
- if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
+ if (fReentrant)
{
-
if (options.useXstack)
{
- if (!accIsFree)
- emitcode ("push", "acc");
- emitcode ("mov", "r0,%s", spname);
- emitcode ("mov", "a,_bp");
- emitcode ("movx", "@r0,a");
- emitcode ("inc", "%s", spname);
- if (!accIsFree)
- emitcode ("pop", "acc");
+ if (sym->xstack || FUNC_HASSTACKPARM(sym->type))
+ {
+ emitcode ("mov", "r0,%s", spname);
+ emitcode ("inc", "%s", spname);
+ emitcode ("xch", "a,_bpx");
+ emitcode ("movx", "@r0,a");
+ emitcode ("inc", "r0");
+ emitcode ("mov", "a,r0");
+ emitcode ("xch", "a,_bpx");
+ }
+ if (sym->stack)
+ {
+ emitcode ("push", "_bp"); /* save the callers stack */
+ emitcode ("mov", "_bp,sp");
+ }
}
else
{
- /* set up the stack */
- emitcode ("push", "_bp"); /* save the callers stack */
+ if (sym->stack || FUNC_HASSTACKPARM(sym->type))
+ {
+ /* set up the stack */
+ emitcode ("push", "_bp"); /* save the callers stack */
+ emitcode ("mov", "_bp,sp");
+ }
}
- emitcode ("mov", "_bp,%s", spname);
}
/* For some cases it is worthwhile to perform a RECEIVE iCode */
/* adjust the stack for the function */
if (stackAdjust)
{
-
int i = stackAdjust;
if (i > 256)
werror (W_STACK_OVERFLOW, sym->name);
if (i > 3 && accIsFree)
{
-
emitcode ("mov", "a,sp");
emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
emitcode ("mov", "sp,a");
-
}
else if (i > 5)
{
if (sym->xstack)
{
+ char i = ((char) sym->xstack & 0xff);
- if (!accIsFree)
- emitcode ("push", "acc");
- emitcode ("mov", "a,_spx");
- emitcode ("add", "a,#0x%02x", ((char) sym->xstack & 0xff));
- emitcode ("mov", "_spx,a");
- if (!accIsFree)
- emitcode ("pop", "acc");
+ if (i > 3 && accIsFree)
+ {
+ emitcode ("mov", "a,_spx");
+ emitcode ("add", "a,#0x%02x", i);
+ emitcode ("mov", "_spx,a");
+ }
+ else if (i > 5)
+ {
+ emitcode ("push", "acc");
+ emitcode ("mov", "a,_spx");
+ emitcode ("add", "a,#0x%02x", i);
+ emitcode ("mov", "_spx,a");
+ emitcode ("pop", "acc");
+ }
+ else
+ {
+ while (i--)
+ emitcode ("inc", "_spx");
+ }
}
/* if critical function then turn interrupts off */
static void
genEndFunction (iCode * ic)
{
- symbol *sym = OP_SYMBOL (IC_LEFT (ic));
+ symbol *sym = OP_SYMBOL (IC_LEFT (ic));
lineNode *lnp = lineCurr;
- bitVect *regsUsed;
- bitVect *regsUsedPrologue;
- bitVect *regsUnneeded;
- int idx;
+ bitVect *regsUsed;
+ bitVect *regsUsedPrologue;
+ bitVect *regsUnneeded;
+ int idx;
_G.currentFunc = NULL;
if (IFFUNC_ISNAKED(sym->type))
if (IFFUNC_ISCRITICAL (sym->type))
{
- emitcode ("pop", "psw"); /* restore ea via c in psw */
- emitcode ("mov", "ea,c");
- }
-
- if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
- {
- emitcode ("mov", "%s,_bp", spname);
- }
-
- /* if use external stack but some variables were
- added to the local stack then decrement the
- local stack */
- if (options.useXstack && sym->stack)
- {
- emitcode ("mov", "a,sp");
- emitcode ("add", "a,#0x%02x", ((char) -sym->stack) & 0xff);
- emitcode ("mov", "sp,a");
+ if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))))
+ {
+ emitcode ("rlc", "a"); /* save c in a */
+ emitcode ("pop", "psw"); /* restore ea via c in psw */
+ emitcode ("mov", "ea,c");
+ emitcode ("rrc", "a"); /* restore c from a */
+ }
+ else
+ {
+ emitcode ("pop", "psw"); /* restore ea via c in psw */
+ emitcode ("mov", "ea,c");
+ }
}
-
if ((IFFUNC_ISREENT (sym->type) || options.stackAuto))
{
if (options.useXstack)
{
- emitcode ("mov", "r0,%s", spname);
- emitcode ("movx", "a,@r0");
- emitcode ("mov", "_bp,a");
- emitcode ("dec", "%s", spname);
+ if (sym->stack)
+ {
+ emitcode ("mov", "sp,_bp");
+ emitcode ("pop", "_bp");
+ }
+ if (sym->xstack || FUNC_HASSTACKPARM(sym->type))
+ {
+ emitcode ("xch", "a,_bpx");
+ emitcode ("mov", "r0,a");
+ emitcode ("dec", "r0");
+ emitcode ("movx", "a,@r0");
+ emitcode ("xch", "a,_bpx");
+ emitcode ("mov", "%s,r0", spname); //read before freeing stack space (interrupts)
+ }
}
- else
+ else if (sym->stack || FUNC_HASSTACKPARM(sym->type))
{
+ emitcode ("mov", "sp,_bp");
emitcode ("pop", "_bp");
}
}
/* if any registers used */
if (sym->regsUsed)
{
+ bool bits_popped = FALSE;
/* save the registers used */
for (i = sym->regsUsed->size; i >= 0; i--)
{
if (bitVectBitValue (sym->regsUsed, i))
- emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
+ bits_popped = popReg (i, bits_popped);
}
}
}
debugFile->writeEndFunction (currFunc, ic, 1);
}
- emitcode ("ret", "");
+ if (IFFUNC_ISBANKEDCALL (sym->type) && !SPEC_STAT(getSpec(sym->type)))
+ {
+ emitcode ("ljmp", "__sdcc_banked_ret");
+ }
+ else
+ {
+ emitcode ("ret", "");
+ }
}
if (!port->peep.getRegsRead || !port->peep.getRegsWritten || options.nopeep)
aopOp (IC_LEFT (ic), ic, FALSE);
size = AOP_SIZE (IC_LEFT (ic));
+
+ if (IS_BIT(_G.currentFunc->etype))
+ {
+ movc (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
+ size = 0;
+ }
+
while (size--)
{
char *l;
if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
{
/* #NOCHANGE */
- l = aopGet (AOP (IC_LEFT (ic)), offset++,
+ l = aopGet (IC_LEFT (ic), offset++,
FALSE, TRUE);
emitcode ("push", "%s", l);
pushed++;
}
else
{
- l = aopGet (AOP (IC_LEFT (ic)), offset,
+ l = aopGet (IC_LEFT (ic), offset,
FALSE, FALSE);
if (strcmp (fReturn[offset], l))
emitcode ("mov", "%s,%s", fReturn[offset++], l);
}
}
- if (pushed)
+ while (pushed)
{
- while (pushed)
- {
- pushed--;
- if (strcmp (fReturn[pushed], "a"))
- emitcode ("pop", fReturn[pushed]);
- else
- emitcode ("pop", "acc");
- }
+ pushed--;
+ if (strcmp (fReturn[pushed], "a"))
+ emitcode ("pop", fReturn[pushed]);
+ else
+ emitcode ("pop", "acc");
}
freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
return FALSE;
- /* if the literal value of the right hand side
- is greater than 4 then it is not worth it */
- if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
- return FALSE;
+ icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
D(emitcode ("; genPlusIncr",""));
/* if increment >=16 bits in register or direct space */
if ((AOP_TYPE(IC_LEFT(ic)) == AOP_REG || AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) &&
sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
+ !isOperandVolatile (IC_RESULT (ic), FALSE) &&
(size > 1) &&
(icount == 1))
{
tlbl = newiTempLabel (NULL);
emitTlbl = 1;
}
- emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
+ emitcode ("inc", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE));
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
emitcode ("cjne", "%s,#0x00,%05d$",
- aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE),
+ aopGet (IC_RESULT (ic), LSB, FALSE, FALSE),
tlbl->key + 100);
else
{
emitcode ("clr", "a");
emitcode ("cjne", "a,%s,%05d$",
- aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE),
+ aopGet (IC_RESULT (ic), LSB, FALSE, FALSE),
tlbl->key + 100);
}
- emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE));
+ emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE));
if (size > 2)
{
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
emitcode ("cjne", "%s,#0x00,%05d$",
- aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
+ aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE),
tlbl->key + 100);
else
emitcode ("cjne", "a,%s,%05d$",
- aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
+ aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE),
tlbl->key + 100);
- emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE));
+ emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE));
}
if (size > 3)
{
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
emitcode ("cjne", "%s,#0x00,%05d$",
- aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
+ aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE),
tlbl->key + 100);
else
{
emitcode ("cjne", "a,%s,%05d$",
- aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
+ aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE),
tlbl->key + 100);
}
- emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
+ emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE));
}
if (emitTlbl)
return TRUE;
}
+ /* if result is dptr */
+ if ((AOP_TYPE (IC_RESULT (ic)) == AOP_STR) &&
+ (AOP_SIZE (IC_RESULT (ic)) == 2) &&
+ !strncmp(AOP (IC_RESULT (ic))->aopu.aop_str[0], "dpl", 4) &&
+ !strncmp(AOP (IC_RESULT (ic))->aopu.aop_str[1], "dph", 4))
+ {
+ if (aopGetUsesAcc (IC_LEFT (ic), 0))
+ return FALSE;
+
+ if (icount > 9)
+ return FALSE;
+
+ if ((AOP_TYPE (IC_LEFT (ic)) != AOP_DIR) && (icount > 5))
+ return FALSE;
+
+ aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 0, FALSE, FALSE), 0, FALSE);
+ aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1, FALSE);
+ while (icount--)
+ emitcode ("inc", "dptr");
+
+ return TRUE;
+ }
+
+ /* if the literal value of the right hand side
+ is greater than 4 then it is not worth it */
+ if (icount > 4)
+ return FALSE;
+
/* if the sizes are greater than 1 then we cannot */
if (AOP_SIZE (IC_RESULT (ic)) > 1 ||
AOP_SIZE (IC_LEFT (ic)) > 1)
if (icount > 3)
{
- MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
+ MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff);
- aopPut (AOP (IC_RESULT (ic)), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
}
else
{
while (icount--)
- emitcode ("inc", "%s", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
+ emitcode ("inc", "%s", aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
}
return TRUE;
/* if the result is a bit */
if (AOP_TYPE (result) == AOP_CRY)
{
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
}
else
{
if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
AOP_SIZE (IC_LEFT (ic)) == 3 &&
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
- aopPut (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_LEFT (ic)), 2, FALSE, FALSE),
+ aopPut (IC_RESULT (ic),
+ aopGet (IC_LEFT (ic)), 2, FALSE, FALSE),
2,
isOperandVolatile (IC_RESULT (ic), FALSE));
if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
AOP_SIZE (IC_RIGHT (ic)) == 3 &&
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
- aopPut (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_RIGHT (ic)), 2, FALSE, FALSE),
+ aopPut (IC_RESULT (ic),
+ aopGet (IC_RIGHT (ic)), 2, FALSE, FALSE),
2,
isOperandVolatile (IC_RESULT (ic), FALSE));
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
{
char buffer[5];
- sprintf (buffer, "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
- aopPut (AOP (IC_RESULT (ic)), buffer, 2, isOperandVolatile (IC_RESULT (ic), FALSE));
+ sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
+ aopPut (IC_RESULT (ic), buffer, 2, isOperandVolatile (IC_RESULT (ic), FALSE));
}
}
#else
opIsGptr (IC_LEFT (ic)) &&
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
{
- aopPut (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE),
+ aopPut (IC_RESULT (ic),
+ aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE),
GPTRSIZE - 1,
isOperandVolatile (IC_RESULT (ic), FALSE));
}
opIsGptr (IC_RIGHT (ic)) &&
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
{
- aopPut (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_RIGHT (ic)), GPTRSIZE - 1, FALSE, FALSE),
+ aopPut (IC_RESULT (ic),
+ aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE),
GPTRSIZE - 1,
isOperandVolatile (IC_RESULT (ic), FALSE));
}
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
{
char buffer[5];
- sprintf (buffer, "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
- aopPut (AOP (IC_RESULT (ic)), buffer, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+ sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
+ aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE));
}
}
#endif
int size, offset = 0;
int skip_bytes = 0;
char *add = "add";
- asmop *leftOp, *rightOp;
+ operand *leftOp, *rightOp;
operand * op;
/* special cases :- */
size = getDataSize (IC_RESULT (ic));
while (size--)
{
- MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
+ MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE));
emitcode ("addc", "a,#00");
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
}
goto release;
goto release;
size = getDataSize (IC_RESULT (ic));
- leftOp = AOP(IC_LEFT(ic));
- rightOp = AOP(IC_RIGHT(ic));
+ leftOp = IC_LEFT(ic);
+ rightOp = IC_RIGHT(ic);
op=IC_LEFT(ic);
/* if this is an add for an array access
)
{
D(emitcode ("; genPlus aligned array",""));
- aopPut (AOP (IC_RESULT (ic)),
+ aopPut (IC_RESULT (ic),
aopGet (rightOp, 0, FALSE, FALSE),
0,
isOperandVolatile (IC_RESULT (ic), FALSE));
if( 1 == getDataSize (IC_RIGHT (ic)) )
{
- aopPut (AOP (IC_RESULT (ic)),
+ aopPut (IC_RESULT (ic),
aopGet (leftOp, 1, FALSE, FALSE),
1,
isOperandVolatile (IC_RESULT (ic), FALSE));
}
else
{
- MOVA (aopGet (AOP (IC_LEFT (ic)), 1, FALSE, FALSE));
+ MOVA (aopGet (IC_LEFT (ic), 1, FALSE, FALSE));
emitcode ("add", "a,%s", aopGet (rightOp, 1, FALSE, FALSE));
- aopPut (AOP (IC_RESULT (ic)), "a", 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 1, isOperandVolatile (IC_RESULT (ic), FALSE));
}
goto release;
}
{
if (aopGetUsesAcc (leftOp, offset) && aopGetUsesAcc (rightOp, offset))
{
- emitcode("mov", "b,a");
+ bool pushedB;
MOVA (aopGet (leftOp, offset, FALSE, TRUE));
+ pushedB = pushB ();
emitcode("xch", "a,b");
MOVA (aopGet (rightOp, offset, FALSE, TRUE));
emitcode (add, "a,b");
+ popB (pushedB);
}
else if (aopGetUsesAcc (leftOp, offset))
{
MOVA (aopGet (rightOp, offset, FALSE, TRUE));
emitcode (add, "a,%s", aopGet (leftOp, offset, FALSE, TRUE));
}
- aopPut (AOP (IC_RESULT (ic)), "a", offset, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset, isOperandVolatile (IC_RESULT (ic), FALSE));
add = "addc"; /* further adds must propagate carry */
}
else
isOperandVolatile (IC_RESULT (ic), FALSE))
{
/* just move */
- aopPut (AOP (IC_RESULT (ic)),
+ aopPut (IC_RESULT (ic),
aopGet (leftOp, offset, FALSE, FALSE),
offset,
isOperandVolatile (IC_RESULT (ic), FALSE));
emitTlbl = 1;
}
- emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
+ emitcode ("dec", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE));
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE)
+ ,aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)
,tlbl->key + 100);
else
{
emitcode ("mov", "a,#0xff");
emitcode ("cjne", "a,%s,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE)
+ ,aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)
,tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE));
+ emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE));
if (size > 2)
{
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE)
+ ,aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE)
,tlbl->key + 100);
else
{
emitcode ("cjne", "a,%s,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE)
+ ,aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE)
,tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE));
+ emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE));
}
if (size > 3)
{
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE)
+ ,aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE)
,tlbl->key + 100);
else
{
emitcode ("cjne", "a,%s,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE)
+ ,aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE)
,tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
+ emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE));
}
if (emitTlbl)
{
{
while (icount--)
- emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
+ emitcode ("dec", "%s", aopGet (IC_RESULT (ic), 0, FALSE, FALSE));
return TRUE;
}
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
}
else
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
}
}
emitcode ("jnb", "%s,%05d$", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
emitcode ("inc", "a");
emitcode ("", "%05d$:", (lbl->key + 100));
- aopPut (AOP (IC_RESULT (ic)), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
}
}
if (AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT)
{
unsigned long lit = 0L;
+ bool useCarry = FALSE;
lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
lit = -(long) lit;
while (size--)
{
- MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- /* first add without previous c */
- if (!offset) {
- if (!size && lit== (unsigned long) -1) {
+ if (useCarry || ((lit >> (offset * 8)) & 0x0FFL)) {
+ MOVA (aopGet (IC_LEFT (ic), offset, FALSE, FALSE));
+ if (!offset && !size && lit== (unsigned long) -1) {
emitcode ("dec", "a");
- } else {
+ } else if (!useCarry) {
+ /* first add without previous c */
emitcode ("add", "a,#0x%02x",
- (unsigned int) (lit & 0x0FFL));
- }
+ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+ useCarry = TRUE;
} else {
emitcode ("addc", "a,#0x%02x",
(unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
}
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ } else {
+ /* no need to add zeroes */
+ offset++;
+ }
}
}
else
{
- asmop *leftOp, *rightOp;
+ operand *leftOp, *rightOp;
- leftOp = AOP(IC_LEFT(ic));
- rightOp = AOP(IC_RIGHT(ic));
+ leftOp = IC_LEFT(ic);
+ rightOp = IC_RIGHT(ic);
while (size--)
{
if (aopGetUsesAcc(rightOp, offset)) {
- wassertl(!aopGetUsesAcc(leftOp, offset), "accumulator clash");
- MOVA (aopGet(rightOp, offset, FALSE, TRUE));
- if (offset == 0) {
- emitcode( "setb", "c");
+ if (aopGetUsesAcc(leftOp, offset)) {
+ bool pushedB;
+
+ MOVA (aopGet (rightOp, offset, FALSE, FALSE));
+ pushedB = pushB ();
+ emitcode ("mov", "b,a");
+ if (offset == 0)
+ CLRC;
+ MOVA (aopGet (leftOp, offset, FALSE, FALSE));
+ emitcode ("subb", "a,b");
+ popB (pushedB);
+ } else {
+ wassertl(!aopGetUsesAcc(leftOp, offset), "accumulator clash");
+ MOVA (aopGet(rightOp, offset, FALSE, TRUE));
+ if (offset == 0) {
+ emitcode( "setb", "c");
+ }
+ emitcode("subb", "a,%s", aopGet(leftOp, offset, FALSE, TRUE));
+ emitcode("cpl", "a");
}
- emitcode("subb", "a,%s", aopGet(leftOp, offset, FALSE, TRUE));
- emitcode("cpl", "a");
} else {
MOVA (aopGet (leftOp, offset, FALSE, FALSE));
if (offset == 0)
aopGet(rightOp, offset, FALSE, TRUE));
}
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
}
symbol *lbl;
int size = AOP_SIZE (result);
bool runtimeSign, compiletimeSign;
- bool lUnsigned, rUnsigned;
+ bool lUnsigned, rUnsigned, pushedB;
D(emitcode ("; genMultOneByte",""));
lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
+ pushedB = pushB ();
+
if (size == 1 /* no, this is not a bug; with a 1 byte result there's
no need to take care about the signedness! */
|| (lUnsigned && rUnsigned))
if (AOP_TYPE (right) == AOP_LIT)
{
/* moving to accumulator first helps peepholes */
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
}
else
{
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
}
emitcode ("mul", "ab");
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
if (size == 2)
- aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 1, isOperandVolatile (result, FALSE));
+
+ popB (pushedB);
return;
}
{
if (rUnsigned) /* emitcode (";", "signed"); */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
else
{
- MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVA (aopGet (right, 0, FALSE, FALSE));
lbl = newiTempLabel (NULL);
emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
emitcode ("cpl", "F0"); /* complement sign flag */
}
else /* ! literal */
{
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
if (!lUnsigned)
{
}
emitcode ("", "%05d$:", (lbl->key + 100));
}
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
if (size == 2)
- aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 1, isOperandVolatile (result, FALSE));
+
+ popB (pushedB);
}
/*-----------------------------------------------------------------*/
operand * right,
operand * result)
{
-
char *l;
+ bool pushedB;
D(emitcode ("; genDivbits",""));
+ pushedB = pushB ();
+
/* the result must be bit */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- l = aopGet (AOP (left), 0, FALSE, FALSE);
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
+ l = aopGet (left, 0, FALSE, FALSE);
MOVA (l);
emitcode ("div", "ab");
emitcode ("rrc", "a");
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+
+ popB (pushedB);
+
+ aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
operand * right,
operand * result)
{
- bool lUnsigned, rUnsigned;
+ bool lUnsigned, rUnsigned, pushedB;
bool runtimeSign, compiletimeSign;
symbol *lbl;
int size, offset;
lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
+ pushedB = pushB ();
+
/* signed or unsigned */
if (lUnsigned && rUnsigned)
{
/* unsigned is easy */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
emitcode ("div", "ab");
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+
+ popB (pushedB);
return;
}
else /* ! literal */
{
if (rUnsigned)
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
else
{
- MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVA (aopGet (right, 0, FALSE, FALSE));
lbl = newiTempLabel (NULL);
emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
emitcode ("cpl", "F0"); /* complement sign flag */
}
else /* ! literal */
{
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
if (!lUnsigned)
{
emitcode ("inc", "a");
emitcode ("", "%05d$:", (lbl->key + 100));
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
if (size > 0)
{
/* msb is 0x00 or 0xff depending on the sign */
emitcode ("mov", "c,F0");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
}
else /* compiletimeSign */
while (size--)
- aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE));
}
}
else
{
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
}
+
+ popB (pushedB);
}
/*-----------------------------------------------------------------*/
operand * right,
operand * result)
{
-
char *l;
+ bool pushedB;
D(emitcode ("; genModbits",""));
+ pushedB = pushB ();
+
/* the result must be bit */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- l = aopGet (AOP (left), 0, FALSE, FALSE);
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
+ l = aopGet (left, 0, FALSE, FALSE);
MOVA (l);
emitcode ("div", "ab");
emitcode ("mov", "a,b");
emitcode ("rrc", "a");
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+
+ popB (pushedB);
+
+ aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
operand * right,
operand * result)
{
- bool lUnsigned, rUnsigned;
+ bool lUnsigned, rUnsigned, pushedB;
bool runtimeSign, compiletimeSign;
symbol *lbl;
int size, offset;
lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
+ /* if right is a literal, check it for 2^n */
+ if (AOP_TYPE(right) == AOP_LIT)
+ {
+ unsigned char val = abs((int) operandLitValue(right));
+ symbol *lbl2 = NULL;
+
+ switch (val)
+ {
+ case 1: /* sometimes it makes sense (on tricky code and hardware)... */
+ case 2:
+ case 4:
+ case 8:
+ case 16:
+ case 32:
+ case 64:
+ case 128:
+ if (lUnsigned)
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "modulus of unsigned char by 2^n literal shouldn't be processed here");
+ /* because iCode should have been changed to genAnd */
+ /* see file "SDCCopt.c", function "convertToFcall()" */
+
+ MOVA (aopGet (left, 0, FALSE, FALSE));
+ emitcode ("mov", "c,acc.7");
+ emitcode ("anl", "a,#0x%02x", val - 1);
+ lbl = newiTempLabel (NULL);
+ emitcode ("jz", "%05d$", (lbl->key + 100));
+ emitcode ("jnc", "%05d$", (lbl->key + 100));
+ emitcode ("orl", "a,#0x%02x", 0xff ^ (val - 1));
+ if (size)
+ {
+ int size2 = size;
+ int offs2 = offset;
+
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ while (size2--)
+ aopPut (result, "#0xff", offs2++, isOperandVolatile (result, FALSE));
+ lbl2 = newiTempLabel (NULL);
+ emitcode ("sjmp", "%05d$", (lbl2->key + 100));
+ }
+ emitcode ("", "%05d$:", (lbl->key + 100));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ while (size--)
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ if (lbl2)
+ {
+ emitcode ("", "%05d$:", (lbl2->key + 100));
+ }
+ return;
+
+ default:
+ break;
+ }
+ }
+
+ pushedB = pushB ();
+
/* signed or unsigned */
if (lUnsigned && rUnsigned)
{
/* unsigned is easy */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
emitcode ("div", "ab");
- aopPut (AOP (result), "b", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 0, isOperandVolatile (result, FALSE));
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+
+ popB (pushedB);
return;
}
/* modulus: sign of the right operand has no influence on the result! */
if (AOP_TYPE(right) == AOP_LIT)
{
- signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+ signed char val = (char) operandLitValue(right);
if (!rUnsigned && val < 0)
emitcode ("mov", "b,#0x%02x", -val);
else /* not literal */
{
if (rUnsigned)
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
else
{
- MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVA (aopGet (right, 0, FALSE, FALSE));
lbl = newiTempLabel (NULL);
emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
emitcode ("cpl", "a"); /* 2's complement */
}
else /* ! literal */
{
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
if (!lUnsigned)
{
emitcode ("inc", "a");
emitcode ("", "%05d$:", (lbl->key + 100));
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
if (size > 0)
{
/* msb is 0x00 or 0xff depending on the sign */
emitcode ("mov", "c,F0");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
}
else /* compiletimeSign */
while (size--)
- aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE));
}
}
else
{
- aopPut (AOP (result), "b", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 0, isOperandVolatile (result, FALSE));
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
}
+
+ popB (pushedB);
}
/*-----------------------------------------------------------------*/
D(emitcode ("; genMod",""));
- /* assign the amsops */
+ /* assign the asmops */
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
aopOp (result, ic, TRUE);
{
symbol *lbl = newiTempLabel (NULL);
emitcode ("cjne", "%s,%s,%05d$",
- aopGet (AOP (left), offset, FALSE, FALSE),
- aopGet (AOP (right), offset, FALSE, FALSE),
+ aopGet (left, offset, FALSE, FALSE),
+ aopGet (right, offset, FALSE, FALSE),
lbl->key + 100);
emitcode ("", "%05d$:", lbl->key + 100);
}
}
else
{
- MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE));
+ MOVA (aopGet (left, AOP_SIZE (left) - 1, FALSE, FALSE));
if (!(AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) && ifx)
{
genIfxJump (ifx, "acc.7", left, right, result);
CLRC;
while (size--)
{
- rightInB = aopGetUsesAcc(AOP (right), offset);
+ bool pushedB = FALSE;
+ rightInB = aopGetUsesAcc(right, offset);
if (rightInB)
- emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ {
+ pushedB = pushB ();
+ emitcode ("mov", "b,%s", aopGet (right, offset, FALSE, FALSE));
+ }
+ MOVA (aopGet (left, offset, FALSE, FALSE));
if (sign && size == 0)
{
emitcode ("xrl", "a,#0x80");
else
{
if (!rightInB)
- emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ {
+ pushedB = pushB ();
+ rightInB++;
+ emitcode ("mov", "b,%s", aopGet (right, offset, FALSE, FALSE));
+ }
emitcode ("xrl", "b,#0x80");
emitcode ("subb", "a,b");
}
if (rightInB)
emitcode ("subb", "a,b");
else
- emitcode ("subb", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ emitcode ("subb", "a,%s", aopGet (right, offset, FALSE, FALSE));
}
+ if (rightInB)
+ popB (pushedB);
offset++;
}
}
aopOp (right, ic, FALSE);
aopOp (result, ic, TRUE);
- genCmp (right, left, result, ifx, sign,ic);
+ genCmp (right, left, result, ifx, sign, ic);
freeAsmop (result, NULL, ic, TRUE);
}
while (size--)
{
emitcode ("cjne", "%s,%s,%05d$",
- aopGet (AOP (left), offset, FALSE, FALSE),
- aopGet (AOP (right), offset, FALSE, FALSE),
+ aopGet (left, offset, FALSE, FALSE),
+ aopGet (right, offset, FALSE, FALSE),
lbl->key + 100);
offset++;
}
{
while (size--)
{
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
if ((AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) &&
((unsigned int) ((lit >> (offset * 8)) & 0x0FFL) == 0))
emitcode ("jnz", "%05d$", lbl->key + 100);
else
emitcode ("cjne", "a,%s,%05d$",
- aopGet (AOP (right), offset, FALSE, TRUE),
+ aopGet (right, offset, FALSE, TRUE),
lbl->key + 100);
offset++;
}
/* right is a pointer reg need both a & b */
while (size--)
{
- char *l = aopGet (AOP (left), offset, FALSE, FALSE);
+ char *l;
+ //if B in use: push B; mov B,left; mov A,right; clrc; subb A,B; pop B; jnz
+ wassertl(!BINUSE, "B was in use");
+ l = aopGet (left, offset, FALSE, FALSE);
if (strcmp (l, "b"))
emitcode ("mov", "b,%s", l);
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("cjne", "a,b,%05d$", lbl->key + 100);
offset++;
}
gencjne (left, right, newiTempLabel (NULL));
if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
{
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
goto release;
}
if (ifx)
return lic;
}
/* if the operand used or deffed */
- if (bitVectBitValue(OP_USES(op),lic->key) || (unsigned) lic->defKey == op->key) {
+ if (bitVectBitValue(OP_USES(op),lic->key) || lic->defKey == op->key) {
return NULL;
}
/* if GOTO or IFX */
else
{
// c = bit & val;
- MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVA (aopGet (right, 0, FALSE, FALSE));
// c = lsb
emitcode ("rrc", "a");
emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
if (posbit)
{
posbit--;
- MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE));
+ MOVA (aopGet (left, posbit >> 3, FALSE, FALSE));
// bit = left & 2^n
if (size)
- emitcode ("mov", "c,acc.%d", posbit & 0x07);
+ {
+ switch (posbit & 0x07)
+ {
+ case 0: emitcode ("rrc", "a");
+ break;
+ case 7: emitcode ("rlc", "a");
+ break;
+ default: emitcode ("mov", "c,acc.%d", posbit & 0x07);
+ break;
+ }
+ }
// if(left & 2^n)
else
{
"acc.%d", posbit & 0x07);
genIfxJump (ifx, buffer, left, right, result);
}
- else
+ else
{// what is this case? just found it in ds390/gen.c
emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07));
}
{
if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L)
{
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
// byte == 2^n ?
if ((posbit = isLiteralBit (bytelit)) != 0)
emitcode ("jb", "acc.%d,%05d$", (posbit - 1) & 0x07, tlbl->key + 100);
{
if (bytelit != 0x0FFL)
emitcode ("anl", "a,%s",
- aopGet (AOP (right), offset, FALSE, TRUE));
+ aopGet (right, offset, FALSE, TRUE));
emitcode ("jnz", "%05d$", tlbl->key + 100);
}
}
{
/* dummy read of volatile operand */
if (isOperandVolatile (left, FALSE))
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
else
- continue;
+ continue;
}
else if (bytelit == 0)
{
- aopPut (AOP (result), zero, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset, isOperandVolatile (result, FALSE));
}
else if (IS_AOP_PREG (result))
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("anl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, offset, FALSE, TRUE));
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
emitcode ("anl", "%s,%s",
- aopGet (AOP (left), offset, FALSE, TRUE),
- aopGet (AOP (right), offset, FALSE, FALSE));
+ aopGet (left, offset, FALSE, TRUE),
+ aopGet (right, offset, FALSE, FALSE));
}
else
{
- if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("anl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ if (AOP_TYPE (left) == AOP_ACC && offset == 0)
+ {
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
if (IS_AOP_PREG (result))
{
- emitcode ("anl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, TRUE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
emitcode ("anl", "%s,a",
- aopGet (AOP (left), offset, FALSE, TRUE));
+ aopGet (left, offset, FALSE, TRUE));
}
}
}
emitcode ("setb", "c");
while (sizer--)
{
- if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
- emitcode ("anl", "a,%s",
- aopGet (AOP (right), offset, FALSE, FALSE));
- } else {
- if (AOP_TYPE(left)==AOP_ACC) {
- emitcode("mov", "b,a");
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode("anl", "a,b");
- }else {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ if ((AOP_TYPE(right)==AOP_REG || IS_AOP_PREG(right) || AOP_TYPE(right)==AOP_DIR)
+ && AOP_TYPE(left)==AOP_ACC)
+ {
+ if (offset)
+ emitcode("mov", "a,b");
+ emitcode ("anl", "a,%s",
+ aopGet (right, offset, FALSE, FALSE));
+ } else {
+ if (AOP_TYPE(left)==AOP_ACC)
+ {
+ if (!offset)
+ {
+ bool pushedB = pushB ();
+ emitcode("mov", "b,a");
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode("anl", "a,b");
+ popB (pushedB);
+ }
+ else
+ {
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode("anl", "a,b");
+ }
+ } else {
+ MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("anl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
+ aopGet (left, offset, FALSE, FALSE));
}
}
emitcode ("jnz", "%05d$", tlbl->key + 100);
bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
if (bytelit == 0x0FF)
{
- aopPut (AOP (result),
- aopGet (AOP (left), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (left, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
continue;
{
/* dummy read of volatile operand */
if (isOperandVolatile (left, FALSE))
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
- aopPut (AOP (result), zero, offset, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ aopPut (result, zero, offset, isOperandVolatile (result, FALSE));
continue;
}
+ else if (AOP_TYPE (left) == AOP_ACC)
+ {
+ if (!offset)
+ {
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ continue;
+ }
+ else
+ {
+ emitcode ("anl", "b,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "b", offset, isOperandVolatile (result, FALSE));
+ continue;
+ }
+ }
}
// faster than result <- left, anl result,right
// and better if result is SFR
if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("anl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ {
+ if (offset)
+ emitcode("mov", "a,b");
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("anl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
+ aopGet (left, offset, FALSE, FALSE));
}
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
}
}
{
/* dummy read of volatile operand */
if (isOperandVolatile (left, FALSE))
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
else
continue;
}
else if (bytelit == 0x0FF)
{
- aopPut (AOP (result), "#0xFF", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xFF", offset, isOperandVolatile (result, FALSE));
}
else if (IS_AOP_PREG (left))
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("orl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, offset, FALSE, TRUE));
+ emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
{
emitcode ("orl", "%s,%s",
- aopGet (AOP (left), offset, FALSE, TRUE),
- aopGet (AOP (right), offset, FALSE, FALSE));
+ aopGet (left, offset, FALSE, TRUE),
+ aopGet (right, offset, FALSE, FALSE));
}
}
else
{
if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("orl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ {
+ if (offset)
+ emitcode("mov", "a,b");
+ emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
if (IS_AOP_PREG (left))
{
- emitcode ("orl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, TRUE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
{
emitcode ("orl", "%s,a",
- aopGet (AOP (left), offset, FALSE, TRUE));
+ aopGet (left, offset, FALSE, TRUE));
}
}
}
while (sizer--)
{
if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+ if (offset)
+ emitcode("mov", "a,b");
emitcode ("orl", "a,%s",
- aopGet (AOP (right), offset, FALSE, FALSE));
+ aopGet (right, offset, FALSE, FALSE));
} else {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("orl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
+ aopGet (left, offset, FALSE, FALSE));
}
emitcode ("jnz", "%05d$", tlbl->key + 100);
offset++;
bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
if (bytelit == 0)
{
- aopPut (AOP (result),
- aopGet (AOP (left), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (left, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
continue;
{
/* dummy read of volatile operand */
if (isOperandVolatile (left, FALSE))
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
- aopPut (AOP (result), "#0xFF", offset, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ aopPut (result, "#0xFF", offset, isOperandVolatile (result, FALSE));
continue;
}
}
// faster than result <- left, anl result,right
// and better if result is SFR
if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("orl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ {
+ if (offset)
+ emitcode("mov", "a,b");
+ emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("orl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
+ aopGet (left, offset, FALSE, FALSE));
}
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
}
}
emitcode ("setb", "c");
while (sizer)
{
- MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE));
+ MOVA (aopGet (right, sizer - 1, FALSE, FALSE));
if (sizer == 1)
// test the msb of the lsb
emitcode ("anl", "a,#0xfe");
{
/* dummy read of volatile operand */
if (isOperandVolatile (left, FALSE))
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
else
- continue;
+ continue;
}
else if (IS_AOP_PREG (left))
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, offset, FALSE, TRUE));
+ emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
{
emitcode ("xrl", "%s,%s",
- aopGet (AOP (left), offset, FALSE, TRUE),
- aopGet (AOP (right), offset, FALSE, FALSE));
+ aopGet (left, offset, FALSE, TRUE),
+ aopGet (right, offset, FALSE, FALSE));
}
}
else
{
if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("xrl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ {
+ if (offset)
+ emitcode("mov", "a,b");
+ emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
if (IS_AOP_PREG (left))
{
- emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
emitcode ("xrl", "%s,a",
- aopGet (AOP (left), offset, FALSE, TRUE));
+ aopGet (left, offset, FALSE, TRUE));
}
}
}
if ((AOP_TYPE (right) == AOP_LIT) &&
(((lit >> (offset * 8)) & 0x0FFL) == 0x00L))
{
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
}
else
{
if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+ if (offset)
+ emitcode("mov", "a,b");
emitcode ("xrl", "a,%s",
- aopGet (AOP (right), offset, FALSE, FALSE));
+ aopGet (right, offset, FALSE, FALSE));
} else {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("xrl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
+ aopGet (left, offset, FALSE, FALSE));
}
}
emitcode ("jnz", "%05d$", tlbl->key + 100);
bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
if (bytelit == 0)
{
- aopPut (AOP (result),
- aopGet (AOP (left), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (left, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
continue;
// faster than result <- left, anl result,right
// and better if result is SFR
if (AOP_TYPE (left) == AOP_ACC)
- emitcode ("xrl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ {
+ if (offset)
+ emitcode("mov", "a,b");
+ emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("xrl", "a,%s",
- aopGet (AOP (left), offset, FALSE, TRUE));
+ aopGet (left, offset, FALSE, TRUE));
}
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
}
}
size = AOP_SIZE (result);
offset = size - 1;
if (size == 1) { /* special case for 1 byte */
- l = aopGet (AOP (left), offset, FALSE, FALSE);
+ l = aopGet (left, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rr", "a");
goto release;
}
- CLRC;
+ /* no need to clear carry, bit7 will be written later */
while (size--)
{
- l = aopGet (AOP (left), offset, FALSE, FALSE);
+ l = aopGet (left, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rrc", "a");
if (AOP_SIZE (result) > 1)
- aopPut (AOP (result), "a", offset--, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
}
/* now we need to put the carry into the
highest order byte of the result */
if (AOP_SIZE (result) > 1)
{
- l = aopGet (AOP (result), AOP_SIZE (result) - 1, FALSE, FALSE);
+ l = aopGet (result, AOP_SIZE (result) - 1, FALSE, FALSE);
MOVA (l);
}
emitcode ("mov", "acc.7,c");
release:
- aopPut (AOP (result), "a", AOP_SIZE (result) - 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", AOP_SIZE (result) - 1, isOperandVolatile (result, FALSE));
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
offset = 0;
if (size--)
{
- l = aopGet (AOP (left), offset, FALSE, FALSE);
+ l = aopGet (left, offset, FALSE, FALSE);
MOVA (l);
if (size == 0) { /* special case for 1 byte */
emitcode("rl","a");
goto release;
}
- emitcode ("add", "a,acc");
+ emitcode("rlc","a"); /* bit0 will be written later */
if (AOP_SIZE (result) > 1)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
while (size--)
{
- l = aopGet (AOP (left), offset, FALSE, FALSE);
+ l = aopGet (left, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rlc", "a");
if (AOP_SIZE (result) > 1)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
}
}
/* now we need to put the carry into the
highest order byte of the result */
if (AOP_SIZE (result) > 1)
{
- l = aopGet (AOP (result), 0, FALSE, FALSE);
+ l = aopGet (result, 0, FALSE, FALSE);
MOVA (l);
}
emitcode ("mov", "acc.0,c");
release:
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
aopOp (result, ic, FALSE);
/* get the highest order byte into a */
- MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE));
+ MOVA (aopGet (left, AOP_SIZE (left) - 1, FALSE, FALSE));
if (AOP_TYPE (result) == AOP_CRY)
{
emitcode ("rlc", "a");
switch (AOP_SIZE (left))
{
case 1: /* swap nibbles in byte */
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
emitcode ("swap", "a");
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
break;
case 2: /* swap bytes in word */
if (AOP_TYPE(left) == AOP_REG && sameRegs(AOP(left), AOP(result)))
{
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
- aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
+ MOVA (aopGet (left, 0, FALSE, FALSE));
+ aopPut (result, aopGet (left, 1, FALSE, FALSE),
0, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), "a", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 1, isOperandVolatile (result, FALSE));
}
else if (operandsEqu (left, result))
{
char * reg = "a";
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
- if (aopGetUsesAcc(AOP (left), 1) || aopGetUsesAcc(AOP (result), 0))
+ bool pushedB = FALSE, leftInB = FALSE;
+
+ MOVA (aopGet (left, 0, FALSE, FALSE));
+ if (aopGetUsesAcc(left, 1) || aopGetUsesAcc(result, 0))
{
+ pushedB = pushB ();
emitcode ("mov", "b,a");
reg = "b";
+ leftInB = TRUE;
}
- aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
+ aopPut (result, aopGet (left, 1, FALSE, FALSE),
0, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), reg, 1, isOperandVolatile (result, FALSE));
+ aopPut (result, reg, 1, isOperandVolatile (result, FALSE));
+
+ if (leftInB)
+ popB (pushedB);
}
else
{
- aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
+ aopPut (result, aopGet (left, 1, FALSE, FALSE),
0, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), aopGet (AOP (left), 0, FALSE, FALSE),
+ aopPut (result, aopGet (left, 0, FALSE, FALSE),
1, isOperandVolatile (result, FALSE));
}
break;
operand * result, int offr,
int shCount, int sign)
{
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
+ MOVA (aopGet (left, offl, FALSE, FALSE));
/* shift right accumulator */
if (sign)
AccSRsh (shCount);
else
AccRsh (shCount);
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
operand * result, int offr, int shCount)
{
char *l;
- l = aopGet (AOP (left), offl, FALSE, FALSE);
+ l = aopGet (left, offl, FALSE, FALSE);
MOVA (l);
/* shift left accumulator */
AccLsh (shCount);
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
char *l;
if (!sameRegs (AOP (left), AOP (result)) || (offl != offr))
{
- l = aopGet (AOP (left), offl, FALSE, FALSE);
+ l = aopGet (left, offl, FALSE, FALSE);
if (*l == '@' && (IS_AOP_PREG (result)))
{
emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
}
else
{
if (!sign)
- aopPut (AOP (result), l, offr, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offr, isOperandVolatile (result, FALSE));
else
{
/* MSB sign in acc.7 ! */
if (getDataSize (left) == offl + 1)
{
emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
}
}
}
((offl + MSB16) == offr))
{
/* don't crash result[offr] */
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
- emitcode ("xch", "a,%s", aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+ MOVA (aopGet (left, offl, FALSE, FALSE));
+ emitcode ("xch", "a,%s", aopGet (left, offl + MSB16, FALSE, FALSE));
}
else
{
movLeft2Result (left, offl, result, offr, 0);
- MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+ MOVA (aopGet (left, offl + MSB16, FALSE, FALSE));
}
/* ax << shCount (x = lsb(result)) */
- AccAXLsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
- aopPut (AOP (result), "a", offr + MSB16, isOperandVolatile (result, FALSE));
+ AccAXLsh (aopGet (result, offr, FALSE, FALSE), shCount);
+ aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE));
}
((offl + MSB16) == offr))
{
/* don't crash result[offr] */
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
- emitcode ("xch", "a,%s", aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+ MOVA (aopGet (left, offl, FALSE, FALSE));
+ emitcode ("xch", "a,%s", aopGet (left, offl + MSB16, FALSE, FALSE));
}
else
{
movLeft2Result (left, offl, result, offr, 0);
- MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+ MOVA (aopGet (left, offl + MSB16, FALSE, FALSE));
}
/* a:x >> shCount (x = lsb(result)) */
if (sign)
- AccAXRshS (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
+ AccAXRshS (aopGet (result, offr, FALSE, FALSE), shCount);
else
- AccAXRsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
+ AccAXRsh (aopGet (result, offr, FALSE, FALSE), shCount);
if (getDataSize (result) > 1)
- aopPut (AOP (result), "a", offr + MSB16, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
shiftLLeftOrResult (operand * left, int offl,
operand * result, int offr, int shCount)
{
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
+ MOVA (aopGet (left, offl, FALSE, FALSE));
/* shift left accumulator */
AccLsh (shCount);
/* or with result */
- emitcode ("orl", "a,%s", aopGet (AOP (result), offr, FALSE, FALSE));
+ emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
/* back to result */
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
shiftRLeftOrResult (operand * left, int offl,
operand * result, int offr, int shCount)
{
- MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
+ MOVA (aopGet (left, offl, FALSE, FALSE));
/* shift right accumulator */
AccRsh (shCount);
/* or with result */
- emitcode ("orl", "a,%s", aopGet (AOP (result), offr, FALSE, FALSE));
+ emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
/* back to result */
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
else
movLeft2Result (left, LSB, result, MSB16, 0);
}
- aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
}
/* 1 <= shCount <= 7 */
if (size >= LSB + offr)
{
- l = aopGet (AOP (left), LSB, FALSE, FALSE);
+ l = aopGet (left, LSB, FALSE, FALSE);
MOVA (l);
emitcode ("add", "a,acc");
if (sameRegs (AOP (left), AOP (result)) &&
size >= MSB16 + offr && offr != LSB)
emitcode ("xch", "a,%s",
- aopGet (AOP (left), LSB + offr, FALSE, FALSE));
+ aopGet (left, LSB + offr, FALSE, FALSE));
else
- aopPut (AOP (result), "a", LSB + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", LSB + offr, isOperandVolatile (result, FALSE));
}
if (size >= MSB16 + offr)
{
if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB16 + offr && offr != LSB))
{
- l = aopGet (AOP (left), MSB16, FALSE, FALSE);
+ l = aopGet (left, MSB16, FALSE, FALSE);
MOVA (l);
}
emitcode ("rlc", "a");
if (sameRegs (AOP (left), AOP (result)) &&
size >= MSB24 + offr && offr != LSB)
emitcode ("xch", "a,%s",
- aopGet (AOP (left), MSB16 + offr, FALSE, FALSE));
+ aopGet (left, MSB16 + offr, FALSE, FALSE));
else
- aopPut (AOP (result), "a", MSB16 + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB16 + offr, isOperandVolatile (result, FALSE));
}
if (size >= MSB24 + offr)
{
- if (!(sameRegs (AOP (left), AOP (left)) && size >= MSB24 + offr && offr != LSB))
+ if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB24 + offr && offr != LSB))
{
- l = aopGet (AOP (left), MSB24, FALSE, FALSE);
+ l = aopGet (left, MSB24, FALSE, FALSE);
MOVA (l);
}
emitcode ("rlc", "a");
if (sameRegs (AOP (left), AOP (result)) &&
size >= MSB32 + offr && offr != LSB)
emitcode ("xch", "a,%s",
- aopGet (AOP (left), MSB24 + offr, FALSE, FALSE));
+ aopGet (left, MSB24 + offr, FALSE, FALSE));
else
- aopPut (AOP (result), "a", MSB24 + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB24 + offr, isOperandVolatile (result, FALSE));
}
if (size > MSB32 + offr)
{
if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB32 + offr && offr != LSB))
{
- l = aopGet (AOP (left), MSB32, FALSE, FALSE);
+ l = aopGet (left, MSB32, FALSE, FALSE);
MOVA (l);
}
emitcode ("rlc", "a");
- aopPut (AOP (result), "a", MSB32 + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB32 + offr, isOperandVolatile (result, FALSE));
}
if (offr != LSB)
- aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
}
/*-----------------------------------------------------------------*/
shiftL1Left2Result (left, LSB, result, MSB32, shCount);
else
movLeft2Result (left, LSB, result, MSB32, 0);
- aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), zero, MSB16, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), zero, MSB24, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, MSB24, isOperandVolatile (result, FALSE));
return;
}
movLeft2Result (left, MSB16, result, MSB32, 0);
movLeft2Result (left, LSB, result, MSB24, 0);
}
- aopPut (AOP (result), zero, MSB16, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
return;
}
movLeft2Result (left, MSB24, result, MSB32, 0);
movLeft2Result (left, MSB16, result, MSB24, 0);
movLeft2Result (left, LSB, result, MSB16, 0);
- aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
}
else if (shCount == 1)
shiftLLong (left, result, MSB16);
shiftL2Left2Result (left, MSB16, result, MSB24, shCount);
shiftL1Left2Result (left, LSB, result, MSB16, shCount);
shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount);
- aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
}
}
}
else if (shCount >= (size * 8))
while (size--)
- aopPut (AOP (result), zero, size, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, size, isOperandVolatile (result, FALSE));
else
{
switch (size)
int size, offset;
char *l;
symbol *tlbl, *tlbl1;
+ bool pushedB;
D(emitcode ("; genLeftShift",""));
more that 32 bits make no sense anyway, ( the
largest size of an object can be only 32 bits ) */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ pushedB = pushB ();
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
emitcode ("inc", "b");
freeAsmop (right, NULL, ic, TRUE);
aopOp (left, ic, FALSE);
aopOp (result, ic, FALSE);
- /* now move the left to the result if they are not the
- same */
+ /* now move the left to the result if they are not the same */
if (!sameRegs (AOP (left), AOP (result)) &&
AOP_SIZE (result) > 1)
{
offset = 0;
while (size--)
{
- l = aopGet (AOP (left), offset, FALSE, TRUE);
+ l = aopGet (left, offset, FALSE, TRUE);
if (*l == '@' && (IS_AOP_PREG (result)))
{
emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
- aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset, isOperandVolatile (result, FALSE));
offset++;
}
}
{
symbol *tlbl1 = newiTempLabel (NULL);
- l = aopGet (AOP (left), 0, FALSE, FALSE);
+ l = aopGet (left, 0, FALSE, FALSE);
MOVA (l);
emitcode ("sjmp", "%05d$", tlbl1->key + 100);
emitcode ("", "%05d$:", tlbl->key + 100);
emitcode ("add", "a,acc");
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ popB (pushedB);
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
goto release;
}
emitcode ("sjmp", "%05d$", tlbl1->key + 100);
emitcode ("", "%05d$:", tlbl->key + 100);
- l = aopGet (AOP (result), offset, FALSE, FALSE);
+ l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("add", "a,acc");
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
while (--size)
{
- l = aopGet (AOP (result), offset, FALSE, FALSE);
+ l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rlc", "a");
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
}
reAdjustPreg (AOP (result));
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ popB (pushedB);
release:
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
werror(E_INTERNAL_ERROR, __FILE__, __LINE__);
}
- MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
+ MOVA (aopGet (left, MSB32, FALSE, FALSE));
if (offl==MSB16) {
// shift is > 8
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
if (isSameRegs)
- emitcode ("xch", "a,%s", aopGet(AOP(left), MSB32, FALSE, FALSE));
+ emitcode ("xch", "a,%s", aopGet (left, MSB32, FALSE, FALSE));
else {
- aopPut (AOP (result), "a", MSB32, isOperandVolatile (result, FALSE));
- MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
+ aopPut (result, "a", MSB32, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, MSB32, FALSE, FALSE));
}
} else {
- aopPut (AOP(result), zero, MSB32, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, MSB32, isOperandVolatile (result, FALSE));
}
}
emitcode ("rrc", "a");
if (isSameRegs && offl==MSB16) {
- emitcode ("xch", "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE));
+ emitcode ("xch", "a,%s",aopGet (left, MSB24, FALSE, FALSE));
} else {
- aopPut (AOP (result), "a", MSB32-offl, isOperandVolatile (result, FALSE));
- MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
+ aopPut (result, "a", MSB32-offl, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, MSB24, FALSE, FALSE));
}
emitcode ("rrc", "a");
if (isSameRegs && offl==1) {
- emitcode ("xch", "a,%s",aopGet (AOP (left), MSB16, FALSE, FALSE));
+ emitcode ("xch", "a,%s",aopGet (left, MSB16, FALSE, FALSE));
} else {
- aopPut (AOP (result), "a", MSB24-offl, isOperandVolatile (result, FALSE));
- MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
+ aopPut (result, "a", MSB24-offl, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, MSB16, FALSE, FALSE));
}
emitcode ("rrc", "a");
- aopPut (AOP (result), "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
if (offl == LSB)
{
- MOVA (aopGet (AOP (left), LSB, FALSE, FALSE));
+ MOVA (aopGet (left, LSB, FALSE, FALSE));
emitcode ("rrc", "a");
- aopPut (AOP (result), "a", LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", LSB, isOperandVolatile (result, FALSE));
}
}
{
if (sign) {
/* get sign in acc.7 */
- MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE));
+ MOVA (aopGet (left, size - 1, FALSE, FALSE));
}
addSign (result, LSB, sign);
}
int size, offset;
char *l;
symbol *tlbl, *tlbl1;
+ bool pushedB;
D(emitcode ("; genSignedRightShift",""));
more that 32 bits make no sense anyway, ( the
largest size of an object can be only 32 bits ) */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ pushedB = pushB ();
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
emitcode ("inc", "b");
freeAsmop (right, NULL, ic, TRUE);
aopOp (left, ic, FALSE);
offset = 0;
while (size--)
{
- l = aopGet (AOP (left), offset, FALSE, TRUE);
+ l = aopGet (left, offset, FALSE, TRUE);
if (*l == '@' && IS_AOP_PREG (result))
{
emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
- aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset, isOperandVolatile (result, FALSE));
offset++;
}
}
size = AOP_SIZE (result);
offset = size - 1;
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
emitcode ("rlc", "a");
emitcode ("mov", "ov,c");
/* if it is only one byte then */
if (size == 1)
{
- l = aopGet (AOP (left), 0, FALSE, FALSE);
+ l = aopGet (left, 0, FALSE, FALSE);
MOVA (l);
emitcode ("sjmp", "%05d$", tlbl1->key + 100);
emitcode ("", "%05d$:", tlbl->key + 100);
emitcode ("rrc", "a");
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ popB (pushedB);
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
goto release;
}
emitcode ("mov", "c,ov");
while (size--)
{
- l = aopGet (AOP (result), offset, FALSE, FALSE);
+ l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rrc", "a");
- aopPut (AOP (result), "a", offset--, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
}
reAdjustPreg (AOP (result));
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ popB (pushedB);
release:
freeAsmop (left, NULL, ic, TRUE);
int size, offset;
char *l;
symbol *tlbl, *tlbl1;
+ bool pushedB;
D(emitcode ("; genRightShift",""));
more that 32 bits make no sense anyway, ( the
largest size of an object can be only 32 bits ) */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ pushedB = pushB ();
+ emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
emitcode ("inc", "b");
freeAsmop (right, NULL, ic, TRUE);
aopOp (left, ic, FALSE);
offset = 0;
while (size--)
{
- l = aopGet (AOP (left), offset, FALSE, TRUE);
+ l = aopGet (left, offset, FALSE, TRUE);
if (*l == '@' && IS_AOP_PREG (result))
{
emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
- aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset, isOperandVolatile (result, FALSE));
offset++;
}
}
/* if it is only one byte then */
if (size == 1)
{
- l = aopGet (AOP (left), 0, FALSE, FALSE);
+ l = aopGet (left, 0, FALSE, FALSE);
MOVA (l);
emitcode ("sjmp", "%05d$", tlbl1->key + 100);
emitcode ("", "%05d$:", tlbl->key + 100);
emitcode ("rrc", "a");
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ popB (pushedB);
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
goto release;
}
CLRC;
while (size--)
{
- l = aopGet (AOP (result), offset, FALSE, FALSE);
+ l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rrc", "a");
- aopPut (AOP (result), "a", offset--, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
}
reAdjustPreg (AOP (result));
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+ popB (pushedB);
release:
freeAsmop (left, NULL, ic, TRUE);
/* genUnpackBits - generates code for unpacking bits */
/*-----------------------------------------------------------------*/
static void
-genUnpackBits (operand * result, char *rname, int ptype)
+genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx)
{
int offset = 0; /* result byte offset */
int rsize; /* result size */
sym_link *etype; /* bitfield type information */
int blen; /* bitfield length */
int bstr; /* bitfield starting bit within byte */
+ char buffer[10];
D(emitcode ("; genUnpackBits",""));
blen = SPEC_BLEN (etype);
bstr = SPEC_BSTR (etype);
+ if (ifx && blen <= 8)
+ {
+ emitPtrByteGet (rname, ptype, FALSE);
+ if (blen == 1)
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "acc.%d", bstr);
+ genIfxJump (ifx, buffer, NULL, NULL, NULL);
+ }
+ else
+ {
+ if (blen < 8)
+ emitcode ("anl", "a,#0x%02x",
+ (((unsigned char) -1) >> (8 - blen)) << bstr);
+ genIfxJump (ifx, "a", NULL, NULL, NULL);
+ }
+ return;
+ }
+ wassert (!ifx);
+
/* If the bitfield length is less than a byte */
if (blen < 8)
{
emitPtrByteGet (rname, ptype, FALSE);
AccRsh (bstr);
emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (8 - blen));
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
goto finish;
}
for (rlen=blen;rlen>=8;rlen-=8)
{
emitPtrByteGet (rname, ptype, FALSE);
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
if (rlen>8)
emitcode ("inc", "%s", rname);
}
{
emitPtrByteGet (rname, ptype, FALSE);
emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (8-rlen));
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
}
finish:
{
rsize -= offset;
while (rsize--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
}
}
aopOp (result, ic, TRUE);
/* get the string representation of the name */
- l = aopGet (AOP (left), 0, FALSE, TRUE);
+ l = aopGet (left, 0, FALSE, TRUE);
size = AOP_SIZE (result);
while (size--)
{
sprintf (buffer, "(%s + %d)", l + 1, offset);
else
sprintf (buffer, "%s", l + 1);
- aopPut (AOP (result), buffer, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, buffer, offset++, isOperandVolatile (result, FALSE));
}
freeAsmop (left, NULL, ic, TRUE);
genNearPointerGet (operand * left,
operand * result,
iCode * ic,
- iCode * pi)
+ iCode * pi,
+ iCode * ifx)
{
asmop *aop = NULL;
regs *preg = NULL;
if (IS_AOP_PREG (left))
{
// Aha, it is a pointer, just in disguise.
- rname = aopGet (AOP (left), 0, FALSE, FALSE);
+ rname = aopGet (left, 0, FALSE, FALSE);
if (*rname != '@')
{
fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
preg = getFreePtr (ic, &aop, FALSE);
emitcode ("mov", "%s,%s",
preg->name,
- aopGet (AOP (left), 0, FALSE, TRUE));
+ aopGet (left, 0, FALSE, TRUE));
rname = preg->name;
}
}
else
- rname = aopGet (AOP (left), 0, FALSE, FALSE);
+ rname = aopGet (left, 0, FALSE, FALSE);
//aopOp (result, ic, FALSE);
aopOp (result, ic, result?TRUE:FALSE);
/* if bitfield then unpack the bits */
if (IS_BITFIELD (retype))
- genUnpackBits (result, rname, POINTER);
+ genUnpackBits (result, rname, POINTER, ifx);
else
{
/* we have can just get the values */
while (size--)
{
- if (IS_AOP_PREG (result) || AOP_TYPE (result) == AOP_STK)
+ if (ifx || IS_AOP_PREG (result) || AOP_TYPE (result) == AOP_STK)
{
emitcode ("mov", "a,@%s", rname);
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ if (!ifx)
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
}
else
{
sprintf (buffer, "@%s", rname);
- aopPut (AOP (result), buffer, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, buffer, offset, isOperandVolatile (result, FALSE));
}
offset++;
if (size || pi)
if (aop) /* we had to allocate for this iCode */
{
if (pi) { /* post increment present */
- aopPut(AOP ( left ),rname,0, isOperandVolatile (left, FALSE));
+ aopPut (left, rname, 0, isOperandVolatile (left, FALSE));
}
freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
}
}
}
+ if (ifx && !ifx->generated)
+ {
+ genIfxJump (ifx, "a", left, NULL, result);
+ }
+
/* done */
freeAsmop (result, NULL, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
freeAsmop (left, NULL, ic, TRUE);
genPagedPointerGet (operand * left,
operand * result,
iCode * ic,
- iCode *pi)
+ iCode *pi,
+ iCode *ifx)
{
asmop *aop = NULL;
regs *preg = NULL;
preg = getFreePtr (ic, &aop, FALSE);
emitcode ("mov", "%s,%s",
preg->name,
- aopGet (AOP (left), 0, FALSE, TRUE));
+ aopGet (left, 0, FALSE, TRUE));
rname = preg->name;
}
else
- rname = aopGet (AOP (left), 0, FALSE, FALSE);
+ rname = aopGet (left, 0, FALSE, FALSE);
aopOp (result, ic, FALSE);
/* if bitfield then unpack the bits */
if (IS_BITFIELD (retype))
- genUnpackBits (result, rname, PPOINTER);
+ genUnpackBits (result, rname, PPOINTER, ifx);
else
{
/* we have can just get the values */
{
emitcode ("movx", "a,@%s", rname);
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ if (!ifx)
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
offset++;
/* now some housekeeping stuff */
if (aop) /* we had to allocate for this iCode */
{
- if (pi) aopPut ( AOP (left), rname, 0, isOperandVolatile (left, FALSE));
+ if (pi) aopPut (left, rname, 0, isOperandVolatile (left, FALSE));
freeAsmop (NULL, aop, ic, TRUE);
}
else
}
}
+ if (ifx && !ifx->generated)
+ {
+ genIfxJump (ifx, "a", left, NULL, result);
+ }
+
/* done */
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
{
if (AOP_TYPE (op) != AOP_STR)
{
- /* if this is remateriazable */
+ /* if this is rematerializable */
if (AOP_TYPE (op) == AOP_IMMD)
{
- emitcode ("mov", "dptr,%s", aopGet (AOP (op), 0, TRUE, FALSE));
+ emitcode ("mov", "dptr,%s", aopGet (op, 0, TRUE, FALSE));
if (loadBToo)
{
if (AOP(op)->aopu.aop_immd.from_cast_remat)
- emitcode ("mov", "b,%s",aopGet(AOP (op), AOP_SIZE(op)-1, FALSE, FALSE));
+ emitcode ("mov", "b,%s",aopGet (op, AOP_SIZE(op)-1, FALSE, FALSE));
else
{
wassertl(FALSE, "need pointerCode");
** from genPointerGet:
** emitcode ("mov", "b,#%d", pointerCode (retype));
** from genPointerSet:
- ** emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE));
+ ** emitcode ("mov", "b,%s + 1", aopGet (result, 0, TRUE, FALSE));
*/
}
}
{
if (loadBToo)
{
- MOVA (aopGet (AOP (op), 0, FALSE, FALSE));
+ MOVA (aopGet (op, 0, FALSE, FALSE));
emitcode ("push", "acc");
- MOVA (aopGet (AOP (op), 1, FALSE, FALSE));
+ MOVA (aopGet (op, 1, FALSE, FALSE));
emitcode ("push", "acc");
- emitcode ("mov", "b,%s", aopGet (AOP (op), 2, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (op, 2, FALSE, FALSE));
emitcode ("pop", "dph");
emitcode ("pop", "dpl");
}
else
{
- MOVA (aopGet (AOP (op), 0, FALSE, FALSE));
+ MOVA (aopGet (op, 0, FALSE, FALSE));
emitcode ("push", "acc");
- emitcode ("mov", "dph,%s", aopGet (AOP (op), 1, FALSE, FALSE));
+ emitcode ("mov", "dph,%s", aopGet (op, 1, FALSE, FALSE));
emitcode ("pop", "dpl");
}
}
else
{ /* we need to get it byte by byte */
- emitcode ("mov", "dpl,%s", aopGet (AOP (op), 0, FALSE, FALSE));
- emitcode ("mov", "dph,%s", aopGet (AOP (op), 1, FALSE, FALSE));
+ emitcode ("mov", "dpl,%s", aopGet (op, 0, FALSE, FALSE));
+ emitcode ("mov", "dph,%s", aopGet (op, 1, FALSE, FALSE));
if (loadBToo)
- emitcode ("mov", "b,%s", aopGet (AOP (op), 2, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (op, 2, FALSE, FALSE));
}
}
}
/*-----------------------------------------------------------------*/
static void
genFarPointerGet (operand * left,
- operand * result, iCode * ic, iCode * pi)
+ operand * result, iCode * ic, iCode * pi, iCode * ifx)
{
int size, offset;
sym_link *retype = getSpec (operandType (result));
/* if bit then unpack */
if (IS_BITFIELD (retype))
- genUnpackBits (result, "dptr", FPOINTER);
+ genUnpackBits (result, "dptr", FPOINTER, ifx);
else
{
size = AOP_SIZE (result);
while (size--)
{
emitcode ("movx", "a,@dptr");
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ if (!ifx)
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
if (size || pi)
emitcode ("inc", "dptr");
}
}
- if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR) {
- aopPut ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
- aopPut ( AOP (left), "dph", 1, isOperandVolatile (left, FALSE));
+ if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
+ {
+ aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
+ aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
pi->generated = 1;
}
+
+ if (ifx && !ifx->generated)
+ {
+ genIfxJump (ifx, "a", left, NULL, result);
+ }
+
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
static void
genCodePointerGet (operand * left,
- operand * result, iCode * ic, iCode *pi)
+ operand * result, iCode * ic, iCode *pi, iCode *ifx)
{
int size, offset;
sym_link *retype = getSpec (operandType (result));
/* if bit then unpack */
if (IS_BITFIELD (retype))
- genUnpackBits (result, "dptr", CPOINTER);
+ genUnpackBits (result, "dptr", CPOINTER, ifx);
else
{
size = AOP_SIZE (result);
{
emitcode ("clr", "a");
emitcode ("movc", "a,@a+dptr");
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ if (!ifx)
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
emitcode ("inc", "dptr");
}
else
{
emitcode ("mov", "a,#0x%02x", offset);
emitcode ("movc", "a,@a+dptr");
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ if (!ifx)
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
}
}
}
- if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR) {
- aopPut ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
- aopPut ( AOP (left), "dph", 1, isOperandVolatile (left, FALSE));
+ if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
+ {
+ aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
+ aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
pi->generated = 1;
}
+
+ if (ifx && !ifx->generated)
+ {
+ genIfxJump (ifx, "a", left, NULL, result);
+ }
+
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
static void
genGenPointerGet (operand * left,
- operand * result, iCode * ic, iCode *pi)
+ operand * result, iCode * ic, iCode *pi, iCode *ifx)
{
int size, offset;
sym_link *retype = getSpec (operandType (result));
/* if bit then unpack */
if (IS_BITFIELD (retype))
- genUnpackBits (result, "dptr", GPOINTER);
+ genUnpackBits (result, "dptr", GPOINTER, ifx);
else
{
size = AOP_SIZE (result);
while (size--)
{
emitcode ("lcall", "__gptrget");
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ if (!ifx)
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
if (size || pi)
emitcode ("inc", "dptr");
}
}
- if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR) {
- aopPut ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
- aopPut ( AOP (left), "dph", 1, isOperandVolatile (left, FALSE));
+ if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
+ {
+ aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
+ aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
pi->generated = 1;
}
+
+ if (ifx && !ifx->generated)
+ {
+ genIfxJump (ifx, "a", left, NULL, result);
+ }
+
+
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
/* genPointerGet - generate code for pointer get */
/*-----------------------------------------------------------------*/
static void
-genPointerGet (iCode * ic, iCode *pi)
+genPointerGet (iCode * ic, iCode *pi, iCode *ifx)
{
operand *left, *result;
sym_link *type, *etype;
left = IC_LEFT (ic);
result = IC_RESULT (ic);
+ if (getSize (operandType (result))>1)
+ ifx = NULL;
+
/* depending on the type of pointer we need to
move it to the correct pointer register */
type = operandType (left);
case POINTER:
case IPOINTER:
- genNearPointerGet (left, result, ic, pi);
+ genNearPointerGet (left, result, ic, pi, ifx);
break;
case PPOINTER:
- genPagedPointerGet (left, result, ic, pi);
+ genPagedPointerGet (left, result, ic, pi, ifx);
break;
case FPOINTER:
- genFarPointerGet (left, result, ic, pi);
+ genFarPointerGet (left, result, ic, pi, ifx);
break;
case CPOINTER:
- genCodePointerGet (left, result, ic, pi);
+ genCodePointerGet (left, result, ic, pi, ifx);
break;
case GPOINTER:
- genGenPointerGet (left, result, ic, pi);
+ genGenPointerGet (left, result, ic, pi, ifx);
break;
}
emitcode ("mov", "c,%s", AOP(right)->aopu.aop_dir);
else
{
- MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVA (aopGet (right, 0, FALSE, FALSE));
emitcode ("rrc","a");
}
emitPtrByteGet (rname, p_type, FALSE);
}
else
{
+ bool pushedB;
/* Case with a bitfield length < 8 and arbitrary source
*/
- MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVA (aopGet (right, 0, FALSE, FALSE));
/* shift and mask source value */
AccLsh (bstr);
emitcode ("anl", "a,#0x%02x", (~mask) & 0xff);
+ pushedB = pushB ();
/* transfer A to B and get next byte */
emitPtrByteGet (rname, p_type, TRUE);
emitcode ("orl", "a,b");
if (p_type == GPOINTER)
emitcode ("pop", "b");
+
+ popB (pushedB);
}
}
for (rlen=blen;rlen>=8;rlen-=8)
{
emitPtrByteSet (rname, p_type,
- aopGet (AOP (right), offset++, FALSE, TRUE) );
+ aopGet (right, offset++, FALSE, TRUE) );
if (rlen>8)
emitcode ("inc", "%s", rname);
}
}
else
{
+ bool pushedB;
/* Case with partial byte and arbitrary source
*/
- MOVA (aopGet (AOP (right), offset++, FALSE, FALSE));
+ MOVA (aopGet (right, offset++, FALSE, FALSE));
emitcode ("anl", "a,#0x%02x", (~mask) & 0xff);
+ pushedB = pushB ();
/* transfer A to B and get next byte */
emitPtrByteGet (rname, p_type, TRUE);
emitcode ("orl", "a,b");
if (p_type == GPOINTER)
emitcode ("pop", "b");
+
+ popB (pushedB);
}
emitPtrByteSet (rname, p_type, "a");
}
aopOp (right, ic, FALSE);
- l = aopGet (AOP (result), 0, FALSE, TRUE);
+ l = aopGet (result, 0, FALSE, TRUE);
size = AOP_SIZE (right);
while (size--)
{
else
sprintf (buffer, "%s", l + 1);
emitcode ("mov", "%s,%s", buffer,
- aopGet (AOP (right), offset++, FALSE, FALSE));
+ aopGet (right, offset++, FALSE, FALSE));
}
freeAsmop (right, NULL, ic, TRUE);
)
{
// Aha, it is a pointer, just in disguise.
- rname = aopGet (AOP (result), 0, FALSE, FALSE);
+ rname = aopGet (result, 0, FALSE, FALSE);
if (*rname != '@')
{
fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
preg = getFreePtr (ic, &aop, FALSE);
emitcode ("mov", "%s,%s",
preg->name,
- aopGet (AOP (result), 0, FALSE, TRUE));
+ aopGet (result, 0, FALSE, TRUE));
rname = preg->name;
}
}
else
{
- rname = aopGet (AOP (result), 0, FALSE, FALSE);
+ rname = aopGet (result, 0, FALSE, FALSE);
}
aopOp (right, ic, FALSE);
while (size--)
{
- l = aopGet (AOP (right), offset, FALSE, TRUE);
+ l = aopGet (right, offset, FALSE, TRUE);
if (*l == '@')
{
MOVA (l);
if (aop) /* we had to allocate for this iCode */
{
if (pi)
- aopPut (AOP (result), rname, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, rname, 0, isOperandVolatile (result, FALSE));
freeAsmop (NULL, aop, ic, TRUE);
}
else
preg = getFreePtr (ic, &aop, FALSE);
emitcode ("mov", "%s,%s",
preg->name,
- aopGet (AOP (result), 0, FALSE, TRUE));
+ aopGet (result, 0, FALSE, TRUE));
rname = preg->name;
}
else
- rname = aopGet (AOP (result), 0, FALSE, FALSE);
+ rname = aopGet (result, 0, FALSE, FALSE);
aopOp (right, ic, FALSE);
while (size--)
{
- l = aopGet (AOP (right), offset, FALSE, TRUE);
+ l = aopGet (right, offset, FALSE, TRUE);
MOVA (l);
emitcode ("movx", "@%s,a", rname);
if (aop) /* we had to allocate for this iCode */
{
if (pi)
- aopPut (AOP (result), rname, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, rname, 0, isOperandVolatile (result, FALSE));
freeAsmop (NULL, aop, ic, TRUE);
}
else
while (size--)
{
- char *l = aopGet (AOP (right), offset++, FALSE, FALSE);
+ char *l = aopGet (right, offset++, FALSE, FALSE);
MOVA (l);
emitcode ("movx", "@dptr,a");
if (size || pi)
}
}
if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
- aopPut (AOP(result), "dpl", 0, isOperandVolatile (result, FALSE));
- aopPut (AOP(result), "dph", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "dpl", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "dph", 1, isOperandVolatile (result, FALSE));
pi->generated=1;
}
freeAsmop (result, NULL, ic, TRUE);
while (size--)
{
- char *l = aopGet (AOP (right), offset++, FALSE, FALSE);
+ char *l = aopGet (right, offset++, FALSE, FALSE);
MOVA (l);
emitcode ("lcall", "__gptrput");
if (size || pi)
}
if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
- aopPut (AOP(result), "dpl", 0, isOperandVolatile (result, FALSE));
- aopPut (AOP(result), "dph", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "dpl", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "dph", 1, isOperandVolatile (result, FALSE));
pi->generated=1;
}
freeAsmop (result, NULL, ic, TRUE);
{
operand *cond = IC_COND (ic);
int isbit = 0;
+ char *dup = NULL;
D(emitcode ("; genIfx",""));
if (AOP_TYPE (cond) != AOP_CRY)
toBoolean (cond);
else
- isbit = 1;
- /* the result is now in the accumulator */
+ {
+ isbit = 1;
+ if (AOP(cond)->aopu.aop_dir)
+ dup = Safe_strdup(AOP(cond)->aopu.aop_dir);
+ }
+ /* the result is now in the accumulator or a directly addressable bit */
freeAsmop (cond, NULL, ic, TRUE);
/* if there was something to be popped then do it */
if (popIc)
genIpop (popIc);
- /* if the condition is a bit variable */
- if (isbit && IS_ITEMP (cond) &&
- SPIL_LOC (cond))
+ /* if the condition is a bit variable */
+ if (isbit && dup)
+ genIfxJump(ic, dup, NULL, NULL, NULL);
+ else if (isbit && IS_ITEMP (cond) && SPIL_LOC (cond))
genIfxJump (ic, SPIL_LOC (cond)->rname, NULL, NULL, NULL);
else if (isbit && !IS_ITEMP (cond))
genIfxJump (ic, OP_SYMBOL (cond)->rname, NULL, NULL, NULL);
it */
if (sym->stack)
{
- emitcode ("mov", "a,_bp");
+ emitcode ("mov", "a,%s", SYM_BP (sym));
emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ?
((char) (sym->stack - _G.nRegsSaved)) :
((char) sym->stack)) & 0xff);
- aopPut (AOP (IC_RESULT (ic)), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
}
else
{
/* we can just move _bp */
- aopPut (AOP (IC_RESULT (ic)), "_bp", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), SYM_BP (sym), 0, isOperandVolatile (IC_RESULT (ic), FALSE));
}
/* fill the result with zero */
size = AOP_SIZE (IC_RESULT (ic)) - 1;
offset = 1;
while (size--)
{
- aopPut (AOP (IC_RESULT (ic)), zero, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), zero, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
goto release;
offset * 8);
else
sprintf (s, "#%s", sym->rname);
- aopPut (AOP (IC_RESULT (ic)), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
release:
/* first push the right side on to the stack */
while (size--)
{
- l = aopGet (AOP (right), offset++, FALSE, FALSE);
+ l = aopGet (right, offset++, FALSE, FALSE);
MOVA (l);
emitcode ("push", "acc");
}
while (size--)
{
emitcode ("pop", "acc");
- aopPut (AOP (result), "a", --offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", --offset, isOperandVolatile (result, FALSE));
}
freeAsmop (result, NULL, ic, FALSE);
if (AOP_TYPE (right) == AOP_LIT)
{
if (((int) operandLitValue (right)))
- aopPut (AOP (result), one, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, one, 0, isOperandVolatile (result, FALSE));
else
- aopPut (AOP (result), zero, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, 0, isOperandVolatile (result, FALSE));
goto release;
}
if (AOP_TYPE (right) == AOP_CRY)
{
emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
goto release;
}
/* we need to or */
toBoolean (right);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
goto release;
}
!IS_FLOAT (operandType (right)) &&
(lit < 256L))
{
+ while ((size) && (lit))
+ {
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
+ offset,
+ isOperandVolatile (result, FALSE));
+ lit >>= 8;
+ offset++;
+ size--;
+ }
emitcode ("clr", "a");
while (size--)
{
- if ((unsigned int) ((lit >> (size * 8)) & 0x0FFL) == 0)
- aopPut (AOP (result), "a", size, isOperandVolatile (result, FALSE));
- else
- aopPut (AOP (result),
- aopGet (AOP (right), size, FALSE, FALSE),
- size,
- isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ offset++;
}
}
else
{
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
offset++;
}
/*-----------------------------------------------------------------*/
-/* genJumpTab - genrates code for jump table */
+/* genJumpTab - generates code for jump table */
/*-----------------------------------------------------------------*/
static void
genJumpTab (iCode * ic)
if( count <= 16 )
{
- /* this algorithm needs 9 cycles and 7 + 3*n bytes
- if the switch argument is in an register.
- (8 cycles and 6+2*n bytes if peepholes can change ljmp to sjmp) */
+ /* this algorithm needs 9 cycles and 7 + 3*n bytes
+ if the switch argument is in a register.
+ (8 cycles and 6+2*n bytes if peepholes can change ljmp to sjmp) */
+ /* (MB) What if peephole converts ljmp to sjmp or ret ???
+ How will multiply by three be updated ???*/
aopOp (IC_JTCOND (ic), ic, FALSE);
/* get the condition into accumulator */
- l = aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE);
+ l = aopGet (IC_JTCOND (ic), 0, FALSE, FALSE);
MOVA (l);
/* multiply by three */
emitcode ("add", "a,acc");
- emitcode ("add", "a,%s", aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE));
+ emitcode ("add", "a,%s", aopGet (IC_JTCOND (ic), 0, FALSE, FALSE));
freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
jtab = newiTempLabel (NULL);
}
else
{
- /* this algorithm needs 14 cycles and 13 + 2*n bytes
- if the switch argument is in an register.
- For n>6 this algorithm may be more compact */
+ /* this algorithm needs 14 cycles and 13 + 2*n bytes
+ if the switch argument is in a register.
+ For n>6 this algorithm may be more compact */
jtablo = newiTempLabel (NULL);
jtabhi = newiTempLabel (NULL);
/* get the condition into accumulator.
- Using b as temporary storage, if register push/pop is needed */
+ Using b as temporary storage, if register push/pop is needed */
aopOp (IC_JTCOND (ic), ic, FALSE);
- l = aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE);
+ l = aopGet (IC_JTCOND (ic), 0, FALSE, FALSE);
if ((AOP_TYPE (IC_JTCOND (ic)) == AOP_R0 && _G.r0Pushed) ||
(AOP_TYPE (IC_JTCOND (ic)) == AOP_R1 && _G.r1Pushed))
{
+ // (MB) what if B is in use???
+ wassertl(!BINUSE, "B was in use");
emitcode ("mov", "b,%s", l);
l = "b";
}
- freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
- MOVA (l);
+ freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
+ MOVA (l);
if( count <= 112 )
{
emitcode ("add", "a,#(%05d$-3-.)", jtablo->key + 100);
emitcode ("movc", "a,@a+pc");
emitcode ("push", "acc");
}
- else
+ else
{
/* this scales up to n<=255, but needs two more bytes
and changes dptr */
for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab;
jtab = setNextItem (IC_JTLABELS (ic)))
emitcode (".db", "%05d$>>8", jtab->key + 100);
-
- }
-
+ }
}
/*-----------------------------------------------------------------*/
if (AOP_TYPE (right) == AOP_LIT)
{
if (((int) operandLitValue (right)))
- aopPut (AOP (result), one, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, one, 0, isOperandVolatile (result, FALSE));
else
- aopPut (AOP (result), zero, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, 0, isOperandVolatile (result, FALSE));
goto release;
}
if (AOP_TYPE (right) == AOP_CRY)
{
emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
goto release;
}
/* we need to or */
toBoolean (right);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
goto release;
}
offset = 0;
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
offset++;
offset = 0;
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
offset++;
exit(1);
}
- sprintf(gpValStr, "#0x%d", gpVal);
- aopPut (AOP (result), gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
+ sprintf(gpValStr, "#0x%x", gpVal);
+ aopPut (result, gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
}
goto release;
}
offset = 0;
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
offset++;
offset = 0;
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
offset,
isOperandVolatile (result, FALSE));
offset++;
if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE(right)==AOP_CRY)
{
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
}
else
{
/* we need to extend the sign :{ */
- char *l = aopGet (AOP (right), AOP_SIZE (right) - 1,
+ char *l = aopGet (right, AOP_SIZE (right) - 1,
FALSE, FALSE);
MOVA (l);
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
}
/* we are done hurray !!!! */
* the accumulator, we must explicitly write
* it back after the decrement.
*/
- char *rByte = aopGet(AOP(IC_RESULT(ic)), 0, FALSE, FALSE);
+ char *rByte = aopGet (IC_RESULT(ic), 0, FALSE, FALSE);
if (strcmp(rByte, "a"))
{
return 0;
}
emitcode ("dec", "%s", rByte);
- aopPut(AOP(IC_RESULT(ic)), rByte, 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), rByte, 0, isOperandVolatile (IC_RESULT (ic), FALSE));
emitcode ("jnz", "%05d$", lbl->key + 100);
}
else if (IS_AOP_PREG (IC_RESULT (ic)))
{
emitcode ("dec", "%s",
- aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
- MOVA (aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
+ aopGet (IC_RESULT (ic), 0, FALSE, FALSE));
+ MOVA (aopGet (IC_RESULT (ic), 0, FALSE, FALSE));
emitcode ("jnz", "%05d$", lbl->key + 100);
}
else
{
- emitcode ("djnz", "%s,%05d$", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE),
+ emitcode ("djnz", "%s,%05d$", aopGet (IC_RESULT (ic), 0, FALSE, FALSE),
lbl->key + 100);
}
emitcode ("sjmp", "%05d$", lbl1->key + 100);
{
int size = getSize (operandType (IC_RESULT (ic)));
int offset = 0;
+
D(emitcode ("; genReceive",""));
if (ic->argreg == 1) { /* first parameter */
_G.accInUse++;
aopOp (IC_RESULT (ic), ic, FALSE);
_G.accInUse--;
- aopPut (AOP (IC_RESULT (ic)), "a", offset,
+ aopPut (IC_RESULT (ic), "a", offset,
isOperandVolatile (IC_RESULT (ic), FALSE));
for (offset = 1; offset<size; offset++)
- aopPut (AOP (IC_RESULT (ic)), tempRegs[--roffset]->name, offset,
+ aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset,
isOperandVolatile (IC_RESULT (ic), FALSE));
goto release;
}
emitcode("mov","%s,%s", tempRegs[offset]->name, fReturn[offset]);
aopOp (IC_RESULT (ic), ic, FALSE);
for (offset = 0; offset<size; offset++)
- aopPut (AOP (IC_RESULT (ic)), tempRegs[offset]->name, offset,
+ aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset,
isOperandVolatile (IC_RESULT (ic), FALSE));
goto release;
}
offset = 0;
while (size--) {
emitcode ("pop", "acc");
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
} else {
_G.accInUse++;
aopOp (IC_RESULT (ic), ic, FALSE);
_G.accInUse--;
- assignResultValue (IC_RESULT (ic));
+ assignResultValue (IC_RESULT (ic), NULL);
}
} else { /* second receive onwards */
int rb1off ;
aopOp (IC_RESULT (ic), ic, FALSE);
rb1off = ic->argreg;
while (size--) {
- aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
}
offset = 0;
while (size--)
{
- MOVA (aopGet (AOP (op), offset, FALSE, FALSE));
+ MOVA (aopGet (op, offset, FALSE, FALSE));
offset++;
}
}
offset = 0;
while (size--)
{
- MOVA (aopGet (AOP (op), offset, FALSE, FALSE));
+ MOVA (aopGet (op, offset, FALSE, FALSE));
offset++;
}
}
D(emitcode("; genCritical",""));
if (IC_RESULT (ic))
- aopOp (IC_RESULT (ic), ic, TRUE);
-
- emitcode ("setb", "c");
- emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
- emitcode ("clr", "c");
- emitcode ("", "%05d$:", (tlbl->key + 100));
-
- if (IC_RESULT (ic))
- outBitC (IC_RESULT (ic)); /* save old ea in an operand */
+ {
+ aopOp (IC_RESULT (ic), ic, TRUE);
+ aopPut (IC_RESULT (ic), one, 0, 0);
+ emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
+ aopPut (IC_RESULT (ic), zero, 0, 0);
+ emitcode ("", "%05d$:", (tlbl->key + 100));
+ freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ }
else
- emitcode ("push", "psw"); /* save old ea via c in psw on top of stack*/
-
- if (IC_RESULT (ic))
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ {
+ emitcode ("setb", "c");
+ emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
+ emitcode ("clr", "c");
+ emitcode ("", "%05d$:", (tlbl->key + 100));
+ emitcode ("push", "psw"); /* save old ea via c in psw on top of stack*/
+ }
}
/*-----------------------------------------------------------------*/
}
else
{
- MOVA (aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
+ if (AOP_TYPE (IC_RIGHT (ic)) != AOP_DUMMY)
+ MOVA (aopGet (IC_RIGHT (ic), 0, FALSE, FALSE));
emitcode ("rrc", "a");
emitcode ("mov", "ea,c");
}
{
if (options.debug)
{
- debugFile->writeCLine(ic);
+ debugFile->writeCLine (ic);
}
if (!options.noCcodeInAsm) {
emitcode ("", ";%s:%d: %s", ic->filename, ic->lineno,
break;
case GET_VALUE_AT_ADDRESS:
- genPointerGet (ic, hasInc(IC_LEFT(ic),ic,getSize(operandType(IC_RESULT(ic)))));
+ genPointerGet (ic,
+ hasInc (IC_LEFT (ic), ic,
+ getSize (operandType (IC_RESULT (ic)))),
+ ifxForOp (IC_RESULT (ic), ic) );
break;
case '=':
projects / fw / sdcc / blobdiff