aop = Safe_calloc (1, sizeof (asmop));
aop->type = type;
+ aop->allocated = 1;
return aop;
}
/* if already has one */
if (sym->aop)
- return sym->aop;
+ {
+ sym->aop->allocated++;
+ return sym->aop;
+ }
/* assign depending on the storage class */
/* if it is on the stack or indirectly addressable */
return FALSE;
}
+/*-----------------------------------------------------------------*/
+/* sameReg - two asmops have the same register at given offsets */
+/*-----------------------------------------------------------------*/
+static bool
+sameReg (asmop * aop1, int off1, asmop * aop2, int off2)
+{
+ if (aop1->type != AOP_REG && aop1->type != AOP_CRY)
+ return FALSE;
+
+ if (aop1->type != aop2->type)
+ return FALSE;
+
+ if (aop1->aopu.aop_reg[off1] != aop2->aopu.aop_reg[off2])
+ return FALSE;
+
+ return TRUE;
+}
+
/*-----------------------------------------------------------------*/
/* sameRegs - two asmops have the same registers */
/*-----------------------------------------------------------------*/
return FALSE;
for (i = 0; i < aop1->size; i++)
- if (aop1->aopu.aop_reg[i] !=
- aop2->aopu.aop_reg[i])
+ if (aop1->aopu.aop_reg[i] != aop2->aopu.aop_reg[i])
return FALSE;
return TRUE;
}
/* if already has a asmop then continue */
- if (op->aop )
- return;
+ if (op->aop)
+ {
+ op->aop->allocated++;
+ return;
+ }
/* if the underlying symbol has a aop */
if (IS_SYMOP (op) && OP_SYMBOL (op)->aop)
{
op->aop = OP_SYMBOL (op)->aop;
+ op->aop->allocated++;
return;
}
if (sym->usl.spillLoc)
{
+ asmop *oldAsmOp = NULL;
+
if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
{
/* force a new aop if sizes differ */
+ oldAsmOp = sym->usl.spillLoc->aop;
sym->usl.spillLoc->aop = NULL;
}
sym->aop = op->aop = aop =
aopForSym (ic, sym->usl.spillLoc, result);
+ if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
+ {
+ /* Don't reuse the new aop, go with the last one */
+ sym->usl.spillLoc->aop = oldAsmOp;
+ }
aop->size = getSize (sym->type);
return;
}
if (!aop)
return;
- if (aop->freed)
- goto dealloc;
+ aop->allocated--;
- aop->freed = 1;
+ if (aop->allocated)
+ goto dealloc;
- /* depending on the asmop type only three cases need work AOP_RO
- , AOP_R1 && AOP_STK */
+ /* depending on the asmop type only three cases need work
+ AOP_R0, AOP_R1 & AOP_STK */
switch (aop->type)
{
case AOP_R0:
if (!aop)
return;
- if (aop->freed)
+ if (!aop->allocated)
return;
switch (aop->type)
release:
/* release the aops */
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
}
release:
/* release the aops */
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
}
/*-----------------------------------------------------------------*/
release:
/* release the aops */
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
}
/*-----------------------------------------------------------------*/
for (sic = setFirstItem (sendSet); sic;
sic = setNextItem (sendSet))
{
- aopOp (IC_LEFT (sic), sic, FALSE);
-
if (sic->argreg > 12)
{
int bit = sic->argreg-13;
+ aopOp (IC_LEFT (sic), sic, FALSE);
+
/* if left is a literal then
we know what the value is */
if (AOP_TYPE (IC_LEFT (sic)) == AOP_LIT)
}
bit_count++;
BitBankUsed = 1;
+
+ freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
}
- freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
}
if (bit_count)
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)
+ if (sic->argreg <= 12)
{
- while (size--)
+ int size, offset = 0;
+ aopOp (IC_LEFT (sic), sic, FALSE);
+ size = AOP_SIZE (IC_LEFT (sic));
+
+ if (sic->argreg == 1)
{
- char *l = aopGet (IC_LEFT (sic), offset, FALSE, FALSE);
- if (strcmp (l, fReturn[offset]))
- emitcode ("mov", "%s,%s", fReturn[offset], l);
- offset++;
+ while (size--)
+ {
+ char *l = aopGet (IC_LEFT (sic), offset, FALSE, FALSE);
+ if (strcmp (l, fReturn[offset]))
+ emitcode ("mov", "%s,%s", fReturn[offset], l);
+ offset++;
+ }
}
- }
- else if (sic->argreg <= 12)
- {
- while (size--)
+ else
{
- emitcode ("mov","%s,%s", rb1regs[sic->argreg+offset-5],
- aopGet (IC_LEFT (sic), offset,FALSE, FALSE));
- offset++;
+ 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);
}
- freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
}
}
bool accuse = FALSE;
bool accPushed = FALSE;
bool resultInF0 = FALSE;
+ bool assignResultGenerated = FALSE;
D(emitcode("; genCall",""));
_G.accInUse--;
accuse = assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
+ assignResultGenerated = TRUE;
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
}
accPushed = TRUE;
}
if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) &&
- IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))))
+ IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) &&
+ !assignResultGenerated)
{
emitcode ("mov", "F0,c");
resultInF0 = TRUE;
// if (restoreBank)
// unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
- if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))))
+ if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && !assignResultGenerated)
{
if (resultInF0)
emitcode ("mov", "c,F0");
/* restore the register bank */
if ( /* FUNC_REGBANK (sym->type) || */ IFFUNC_ISISR (sym->type))
{
- if (/* !FUNC_REGBANK (sym->type) || */ !IFFUNC_ISISR (sym->type)
+ if (!FUNC_REGBANK (sym->type) || !IFFUNC_ISISR (sym->type)
|| !options.useXstack)
{
/* Special case of ISR using non-zero bank with useXstack
int size, offset = 0;
int skip_bytes = 0;
char *add = "add";
+ bool swappedLR = FALSE;
operand *leftOp, *rightOp;
operand * op;
operand *t = IC_RIGHT (ic);
IC_RIGHT (ic) = IC_LEFT (ic);
IC_LEFT (ic) = t;
+ swappedLR = TRUE;
}
/* if both left & right are in bit
size = getDataSize (IC_RESULT (ic));
leftOp = IC_LEFT(ic);
rightOp = IC_RIGHT(ic);
- op=IC_LEFT(ic);
+ op = IC_LEFT(ic);
/* if this is an add for an array access
at a 256 byte boundary */
adjustArithmeticResult (ic);
release:
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ if (!swappedLR)
+ {
+ freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ }
+ else
+ {
+ freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ }
}
/*-----------------------------------------------------------------*/
adjustArithmeticResult (ic);
release:
- freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
}
/* should have been converted to function call */
assert (0);
release:
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
assert (0);
release:
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
sign = !((SPEC_USIGN (letype) && !(IS_CHAR (letype) && IS_LITERAL (letype))) ||
(SPEC_USIGN (retype) && !(IS_CHAR (retype) && IS_LITERAL (retype))));
/* assign the amsops */
+ aopOp (result, ic, TRUE);
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
genCmp (right, left, result, ifx, sign, ic);
sign = !((SPEC_USIGN (letype) && !(IS_CHAR (letype) && IS_LITERAL (letype))) ||
(SPEC_USIGN (retype) && !(IS_CHAR (retype) && IS_LITERAL (retype))));
/* assign the amsops */
+ aopOp (result, ic, TRUE);
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
genCmp (left, right, result, ifx, sign, ic);
static void
genCmpEq (iCode * ic, iCode * ifx)
{
+ bool swappedLR = FALSE;
operand *left, *right, *result;
D(emitcode ("; genCmpEq",""));
operand *t = IC_RIGHT (ic);
IC_RIGHT (ic) = IC_LEFT (ic);
IC_LEFT (ic) = t;
+ swappedLR = TRUE;
}
if (ifx && !AOP_SIZE (result))
}
release:
- freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (result, NULL, ic, TRUE);
+ if (!swappedLR)
+ {
+ freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ }
+ else
+ {
+ freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+ }
}
/*-----------------------------------------------------------------*/
outBitAcc (result);
}
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
}
outBitAcc (result);
}
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
}
release:
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
}
release:
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
}
release:
+ freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
- freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
emitcode ("mov", "acc.7,c");
release:
aopPut (result, "a", AOP_SIZE (result) - 1, isOperandVolatile (result, FALSE));
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
emitcode ("mov", "acc.0,c");
release:
aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
outAcc (result);
}
-
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
outAcc (result);
}
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (right, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
0,
isOperandVolatile (result, FALSE));
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (right, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
1,
isOperandVolatile (result, FALSE));
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (right, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
wassertl(FALSE, "unsupported SWAP operand size");
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
break;
}
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
popB (pushedB);
release:
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
shiftRLong (operand * left, int offl,
operand * result, int sign)
{
- int isSameRegs = sameRegs (AOP (left), AOP (result));
+ bool useSameRegs = regsInCommon (left, result);
- if (isSameRegs && offl>1) {
- // we are in big trouble, but this shouldn't happen
- werror(E_INTERNAL_ERROR, __FILE__, __LINE__);
- }
+ if (useSameRegs && offl>1)
+ {
+ // we are in big trouble, but this shouldn't happen
+ werror(E_INTERNAL_ERROR, __FILE__, __LINE__);
+ }
MOVA (aopGet (left, MSB32, FALSE, FALSE));
- if (offl==MSB16) {
- // shift is > 8
- if (sign) {
- emitcode ("rlc", "a");
- emitcode ("subb", "a,acc");
- if (isSameRegs)
- emitcode ("xch", "a,%s", aopGet (left, MSB32, FALSE, FALSE));
- else {
- aopPut (result, "a", MSB32, isOperandVolatile (result, FALSE));
- MOVA (aopGet (left, MSB32, FALSE, FALSE));
- }
- } else {
- aopPut (result, zero, MSB32, isOperandVolatile (result, FALSE));
+ if (offl==MSB16)
+ {
+ // shift is > 8
+ if (sign)
+ {
+ emitcode ("rlc", "a");
+ emitcode ("subb", "a,acc");
+ if (useSameRegs && sameReg (AOP (left), MSB32, AOP (result), MSB32))
+ {
+ emitcode ("xch", "a,%s", aopGet (left, MSB32, FALSE, FALSE));
+ }
+ else
+ {
+ aopPut (result, "a", MSB32, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, MSB32, FALSE, FALSE));
+ }
+ }
+ else
+ {
+ aopPut (result, zero, MSB32, isOperandVolatile (result, FALSE));
+ }
}
- }
- if (!sign) {
- emitcode ("clr", "c");
- } else {
- emitcode ("mov", "c,acc.7");
- }
+ if (!sign)
+ {
+ emitcode ("clr", "c");
+ }
+ else
+ {
+ emitcode ("mov", "c,acc.7");
+ }
emitcode ("rrc", "a");
- if (isSameRegs && offl==MSB16) {
- emitcode ("xch", "a,%s",aopGet (left, MSB24, FALSE, FALSE));
- } else {
- aopPut (result, "a", MSB32-offl, isOperandVolatile (result, FALSE));
- MOVA (aopGet (left, MSB24, FALSE, FALSE));
- }
+ if (useSameRegs && offl==MSB16 &&
+ sameReg (AOP (left), MSB24, AOP (result), MSB32-offl))
+ {
+ emitcode ("xch", "a,%s",aopGet (left, MSB24, FALSE, FALSE));
+ }
+ else
+ {
+ 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 (left, MSB16, FALSE, FALSE));
- } else {
- aopPut (result, "a", MSB24-offl, isOperandVolatile (result, FALSE));
- MOVA (aopGet (left, MSB16, FALSE, FALSE));
- }
+ if (useSameRegs && offl==1 &&
+ sameReg (AOP (left), MSB16, AOP (result), MSB24-offl))
+ {
+ emitcode ("xch", "a,%s",aopGet (left, MSB16, FALSE, FALSE));
+ }
+ else
+ {
+ aopPut (result, "a", MSB24-offl, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, MSB16, FALSE, FALSE));
+ }
emitcode ("rrc", "a");
- aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
-
- if (offl == LSB)
+ if (offl != LSB)
{
- MOVA (aopGet (left, LSB, FALSE, FALSE));
+ aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+ }
+ else
+ {
+ if (useSameRegs &&
+ sameReg (AOP (left), LSB, AOP (result), MSB16-offl))
+ {
+ emitcode ("xch", "a,%s",aopGet (left, LSB, FALSE, FALSE));
+ }
+ else
+ {
+ aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, LSB, FALSE, FALSE));
+ }
emitcode ("rrc", "a");
aopPut (result, "a", LSB, isOperandVolatile (result, FALSE));
}
break;
}
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
popB (pushedB);
release:
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
popB (pushedB);
release:
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
aopPut (result, buffer, offset++, isOperandVolatile (result, FALSE));
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
}
/* done */
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
if (pi) pi->generated = 1;
-
}
/*--------------------------------------------------------------------*/
genIfxJump (ifx, "a", left, NULL, result);
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
while (size--)
{
- if (pi)
- {
- emitcode ("clr", "a");
- emitcode ("movc", "a,@a+dptr");
- if (!ifx)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
- emitcode ("inc", "dptr");
- }
- else
- {
- emitcode ("mov", "a,#0x%02x", offset);
- emitcode ("movc", "a,@a+dptr");
- if (!ifx)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
- }
+ emitcode ("clr", "a");
+ emitcode ("movc", "a,@a+dptr");
+ if (!ifx)
+ aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ if (size || pi)
+ emitcode ("inc", "dptr");
}
}
genIfxJump (ifx, "a", left, NULL, result);
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
genIfxJump (ifx, "a", left, NULL, result);
}
-
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
aopGet (right, offset++, FALSE, FALSE));
}
- freeAsmop (right, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
if (pi) pi->generated = 1;
freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
-
-
}
/*-----------------------------------------------------------------*/
aopPut (result, "a", --offset, isOperandVolatile (result, FALSE));
}
freeAsmop (result, NULL, ic, FALSE);
-
}
/*-----------------------------------------------------------------*/
}
release:
- freeAsmop (right, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
/* 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 ???*/
+ /* Peephole may not convert ljmp to sjmp or ret
+ labelIsReturnOnly & labelInRange must check
+ currPl->ic->op != JUMPTABLE */
aopOp (IC_JTCOND (ic), ic, FALSE);
/* get the condition into accumulator */
l = aopGet (IC_JTCOND (ic), 0, FALSE, FALSE);
MOVA (l);
/* multiply by three */
- emitcode ("add", "a,acc");
- emitcode ("add", "a,%s", aopGet (IC_JTCOND (ic), 0, FALSE, FALSE));
+ if (aopGetUsesAcc (IC_JTCOND (ic), 0))
+ {
+ emitcode ("mov", "b,#3");
+ emitcode ("mul", "ab");
+ }
+ else
+ {
+ emitcode ("add", "a,acc");
+ emitcode ("add", "a,%s", aopGet (IC_JTCOND (ic), 0, FALSE, FALSE));
+ }
freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
jtab = newiTempLabel (NULL);
/* we are done hurray !!!! */
release:
- freeAsmop (right, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
-
+ freeAsmop (right, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
char regsInUse[80];
int i;
+ #if 0
for (i=0; i<8; i++) {
sprintf (®sInUse[i],
- "%c", ic->riu & (1<<i) ? i+'0' : '-');
- }
+ "%c", ic->riu & (1<<i) ? i+'0' : '-'); /* show riu */
regsInUse[i]=0;
+ #else
+ strcpy (regsInUse, "--------");
+ for (i=0; i < 8; i++) {
+ if (bitVectBitValue (ic->rMask, i))
+ {
+ int offset = regs8051[i].offset;
+ regsInUse[offset] = offset + '0'; /* show rMask */
+ }
+ #endif
+ }
emitcode("", "; [%s] ic:%d: %s", regsInUse, ic->seq, printILine(ic));
}
/* if the result is marked as