if (ic->op == IFX)
{
op = IC_COND (ic);
- if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse)
+ if (IS_OP_ACCUSE (op))
{
accuse = 1;
size = getSize (OP_SYMBOL (op)->type);
else if (ic->op == JUMPTABLE)
{
op = IC_JTCOND (ic);
- if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse)
+ if (IS_OP_ACCUSE (op))
{
accuse = 1;
size = getSize (OP_SYMBOL (op)->type);
else
{
op = IC_LEFT (ic);
- if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse)
+ if (IS_OP_ACCUSE (op))
{
accuse = 1;
size = getSize (OP_SYMBOL (op)->type);
accuseSize = size;
}
op = IC_RIGHT (ic);
- if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse)
+ if (IS_OP_ACCUSE (op))
{
accuse = 1;
size = getSize (OP_SYMBOL (op)->type);
}
/*-----------------------------------------------------------------*/
-/* aopForRemat - rematerialzes an object */
+/* aopForRemat - rematerializes an object */
/*-----------------------------------------------------------------*/
static asmop *
aopForRemat (symbol * sym)
val += (int) operandLitValue (IC_RIGHT (ic));
else if (ic->op == '-')
val -= (int) operandLitValue (IC_RIGHT (ic));
- else if (IS_CAST_ICODE(ic)) {
- 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 = pointerTypeToGPByte (DCL_TYPE(from_type), NULL, NULL);
- continue;
- } else break;
+ else if (IS_CAST_ICODE(ic))
+ {
+ 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 = pointerTypeToGPByte (DCL_TYPE(from_type), NULL, NULL);
+ continue;
+ }
+ else break;
ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
}
if (sym->remat)
{
sym->aop = op->aop = aop = aopForRemat (sym);
- aop->size = getSize (sym->type);
+ aop->size = operandSize (op);
return;
}
oldAsmOp = sym->usl.spillLoc->aop;
sym->usl.spillLoc->aop = NULL;
}
- sym->aop = op->aop = aop =
- aopForSym (ic, sym->usl.spillLoc, result);
+ 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 */
/*-----------------------------------------------------------------*/
/* freeAsmop - free up the asmop given to an operand */
-/*----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
static void
freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
{
bool bvolatile = isOperandVolatile (result, FALSE);
bool accuse = FALSE;
asmop * aop = AOP (result);
+ const char *d = NULL;
if (aop->size && offset > (aop->size - 1))
{
break;
case AOP_CRY:
- /* if result no bit variable */
- if (!aop->aopu.aop_dir)
- {
- assert (!strcmp (s, "c"));
- /* inefficient: move carry into A and use jz/jnz */
- emitcode ("clr", "a");
- emitcode ("rlc", "a");
- accuse = TRUE;
- }
- else if (s == zero)
- emitcode ("clr", "%s", aop->aopu.aop_dir);
- else if (s == one)
- emitcode ("setb", "%s", aop->aopu.aop_dir);
- else if (!strcmp (s, "c"))
- emitcode ("mov", "%s,c", aop->aopu.aop_dir);
- else if (strcmp (s, aop->aopu.aop_dir))
+ // destination is carry for return-use-only
+ d = (IS_OP_RUONLY (result)) ? "c" : aop->aopu.aop_dir;
+
+ // source is no literal and not in carry
+ if ((s != zero) && (s != one) && strcmp (s, "c"))
{
MOVA (s);
/* set C, if a >= 1 */
emitcode ("add", "a,#0xff");
- emitcode ("mov", "%s,c", aop->aopu.aop_dir);
+ s = "c";
+ }
+ // now source is zero, one or carry
+
+ /* if result no bit variable */
+ if (!d)
+ {
+ if (!strcmp (s, "c"))
+ {
+ /* inefficient: move carry into A and use jz/jnz */
+ emitcode ("clr", "a");
+ emitcode ("rlc", "a");
+ accuse = TRUE;
+ }
+ else
+ {
+ MOVA (s);
+ accuse = TRUE;
+ }
}
+ else if (s == zero)
+ emitcode ("clr", "%s", d);
+ else if (s == one)
+ emitcode ("setb", "%s", d);
+ else if (strcmp (s, d))
+ emitcode ("mov", "%s,c", d);
break;
case AOP_STR:
}
/*-----------------------------------------------------------------*/
-/* opIsGptr: returns non-zero if the passed operand is */
-/* a generic pointer type. */
+/* opIsGptr: returns non-zero if the passed operand is */
+/* a generic pointer type. */
/*-----------------------------------------------------------------*/
static int
opIsGptr (operand * op)
{
- sym_link *type = operandType (op);
-
- if ((AOP_SIZE (op) == GPTRSIZE) && IS_GENPTR (type))
+ if (op && IS_GENPTR (operandType (op)) && (AOP_SIZE (op) == GPTRSIZE))
{
return 1;
}
static int
getDataSize (operand * op)
{
- int size;
- size = AOP_SIZE (op);
+ int size = AOP_SIZE (op);
+
if (size == GPTRSIZE)
{
sym_link *type = operandType (op);
/* if the result is bit */
if (AOP_TYPE (result) == AOP_CRY)
{
- if (!OP_SYMBOL (result)->ruonly)
+ if (!IS_OP_RUONLY (result))
aopPut (result, "c", 0);
}
- else
+ else if (AOP_TYPE (result) != AOP_DUMMY)
{
emitcode ("clr", "a");
emitcode ("rlc", "a");
}
else
{
- emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
+ toCarry (IC_LEFT (ic));
emitcode ("cpl", "c");
outBitC (IC_RESULT (ic));
}
if (offset == 0)
SETC;
emitcode ("cpl", "a");
- emitcode ("addc", "a,#0");
+ emitcode ("addc", "a,#0x00");
}
else
{
}
emitcode ("mov", "r0,%s", spname);
MOVA ("r0");
- emitcode ("add", "a,#%d", count);
+ emitcode ("add", "a,#0x%02x", count);
emitcode ("mov", "%s,a", spname);
for (i = 0; i < mcs51_nRegs; i++)
{
/* pushSide - */
/*-----------------------------------------------------------------*/
static void
-pushSide (operand * oper, int size)
+pushSide (operand * oper, int size, iCode * ic)
{
int offset = 0;
+ int nPushed = _G.r0Pushed + _G.r1Pushed;
+
+ aopOp (oper, ic, FALSE);
+
+ if (nPushed != _G.r0Pushed + _G.r1Pushed)
+ {
+ while (offset < size)
+ {
+ char *l = aopGet (oper, offset, FALSE, TRUE);
+ emitcode ("mov", "%s,%s", fReturn[offset++], l);
+ }
+ freeAsmop (oper, NULL, ic, TRUE);
+ offset = 0;
+ while (offset < size)
+ {
+ emitcode ("push", "%s", fReturn[offset++]);
+ }
+ return;
+ }
+
while (size--)
{
char *l = aopGet (oper, offset++, FALSE, TRUE);
emitcode ("push", "%s", l);
}
}
+
+ freeAsmop (oper, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
// allocate space first
emitcode ("mov", "%s,%s", r->name, spname);
MOVA (r->name);
- emitcode ("add", "a,#%d", size);
+ emitcode ("add", "a,#0x%02x", size);
emitcode ("mov", "%s,a", spname);
while (size--)
freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
}
+/*-----------------------------------------------------------------*/
+/* popForBranch - recover the spilt registers for a branch */
+/*-----------------------------------------------------------------*/
+static void
+popForBranch (iCode * ic, bool markGenerated)
+{
+ while (ic && ic->op == IPOP)
+ {
+ genIpop (ic);
+ if (markGenerated)
+ ic->generated = 1; /* mark the icode as generated */
+ ic = ic->next;
+ }
+}
+
/*-----------------------------------------------------------------*/
/* saveRBank - saves an entire register bank on the stack */
/*-----------------------------------------------------------------*/
// allocate space first
emitcode ("mov", "%s,%s", r->name, spname);
MOVA (r->name);
- emitcode ("add", "a,#%d", count);
+ emitcode ("add", "a,#0x%02x", count);
emitcode ("mov", "%s,a", spname);
}
}
}
- if (bit_count)
+ if (options.useXstack || bit_count)
{
saveRegisters (setFirstItem (sendSet));
+ }
+
+ if (bit_count)
+ {
emitcode ("mov", "bits,b");
}
if (swapBanks)
{
- emitcode ("mov", "psw,#0x%02x",
- ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+ emitcode ("mov", "psw,#0x%02x", ((FUNC_REGBANK(dtype)) << 3) & 0xff);
}
/* make the call */
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);
+ /* now push the function address */
+ pushSide (IC_LEFT (ic), FPTRSIZE, ic);
- /* if send set is not empty the assign */
+ /* if send set is not empty then assign */
if (_G.sendSet)
{
genSend(reverseSet(_G.sendSet));
/* this function has a function call. We cannot
determine register usage so we will have to push the
entire bank */
- saveRBank (0, ic, FALSE);
- if (options.parms_in_bank1) {
- for (i=0; i < 8 ; i++ ) {
- emitcode ("push","%s",rb1regs[i]);
+ saveRBank (0, ic, FALSE);
+ if (options.parms_in_bank1)
+ {
+ for (i=0; i < 8 ; i++ )
+ {
+ emitcode ("push","%s",rb1regs[i]);
}
}
}
}
else
{
- if (options.parms_in_bank1) {
- for (i = 7 ; i >= 0 ; i-- ) {
+ if (options.parms_in_bank1)
+ {
+ for (i = 7 ; i >= 0 ; i-- )
+ {
emitcode ("pop","%s",rb1regs[i]);
- }
- }
+ }
+ }
/* this function has a function call. We cannot
determine register usage so we will have to pop the
entire bank */
unsaveRBank (0, ic, FALSE);
}
}
- else
+ else
{
/* This ISR uses a non-zero bank.
*
if (IS_BIT(_G.currentFunc->etype))
{
- if (!(IS_SYMOP (IC_LEFT (ic)) && OP_SYMBOL (IC_LEFT (ic))->ruonly))
+ if (!IS_OP_RUONLY (IC_LEFT (ic)))
toCarry (IC_LEFT (ic));
}
else
if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
return FALSE;
- icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+ icount = (unsigned int) ulFromVal (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 ||
+ if (( AOP_TYPE(IC_LEFT(ic)) == AOP_REG ||
AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ||
(IS_AOP_PREG (IC_LEFT(ic)) && !AOP_NEEDSACC (IC_LEFT(ic))) ) &&
sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
symbol *tlbl;
int emitTlbl;
int labelRange;
+ char *l;
/* If the next instruction is a goto and the goto target
* is < 10 instructions previous to this, we can generate
tlbl = newiTempLabel (NULL);
emitTlbl = 1;
}
- emitcode ("inc", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE));
+ l = aopGet (IC_RESULT (ic), LSB, FALSE, FALSE);
+ emitcode ("inc", "%s", l);
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$",
- aopGet (IC_RESULT (ic), LSB, FALSE, FALSE),
- tlbl->key + 100);
+ {
+ emitcode ("cjne", "%s,#0x00,%05d$", l, tlbl->key + 100);
+ }
else
{
emitcode ("clr", "a");
- emitcode ("cjne", "a,%s,%05d$",
- aopGet (IC_RESULT (ic), LSB, FALSE, FALSE),
- tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE));
+ l = aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE);
+ emitcode ("inc", "%s", l);
if (size > 2)
{
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
- IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$",
- aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE),
- tlbl->key + 100);
+ if (!strcmp(l, "acc"))
+ {
+ emitcode("jnz", "!tlabel", tlbl->key + 100);
+ }
+ else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
+ IS_AOP_PREG (IC_RESULT (ic)))
+ {
+ emitcode ("cjne", "%s,#0x00,%05d$", l, tlbl->key + 100);
+ }
else
- emitcode ("cjne", "a,%s,%05d$",
- aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE),
- tlbl->key + 100);
+ {
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
+ }
- emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE));
+ l = aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE);
+ emitcode ("inc", "%s", l);
}
if (size > 3)
{
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
- IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$",
- aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE),
- tlbl->key + 100);
+ if (!strcmp(l, "acc"))
+ {
+ emitcode("jnz", "!tlabel", tlbl->key + 100);
+ }
+ else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
+ IS_AOP_PREG (IC_RESULT (ic)))
+ {
+ emitcode ("cjne", "%s,#0x00,%05d$", l, tlbl->key + 100);
+ }
else
{
- emitcode ("cjne", "a,%s,%05d$",
- aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE),
- tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE));
+
+ l = aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE);
+ emitcode ("inc", "%s", l);
}
if (emitTlbl)
static void
adjustArithmeticResult (iCode * ic)
{
- if (opIsGptr (IC_RESULT (ic)) &&
- opIsGptr (IC_LEFT (ic)) &&
- !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
+ if (opIsGptr (IC_RESULT (ic)))
{
- aopPut (IC_RESULT (ic),
- aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE),
- GPTRSIZE - 1);
- }
+ char buffer[10];
- if (opIsGptr (IC_RESULT (ic)) &&
- opIsGptr (IC_RIGHT (ic)) &&
- !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
- {
- aopPut (IC_RESULT (ic),
- aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE),
- GPTRSIZE - 1);
- }
+ if (opIsGptr (IC_LEFT (ic)))
+ {
+ if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
+ {
+ aopPut (IC_RESULT (ic),
+ aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE),
+ GPTRSIZE - 1);
+ }
+ return;
+ }
- if (opIsGptr (IC_RESULT (ic)) &&
- AOP_SIZE (IC_LEFT (ic)) < GPTRSIZE &&
- AOP_SIZE (IC_RIGHT (ic)) < GPTRSIZE &&
- !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))) &&
- !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
- {
- char buffer[5];
- SNPRINTF (buffer, sizeof(buffer),
- "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
- aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1);
+ if (opIsGptr (IC_RIGHT (ic)))
+ {
+ if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
+ {
+ aopPut (IC_RESULT (ic),
+ aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE),
+ GPTRSIZE - 1);
+ }
+ return;
+ }
+
+ if (IC_LEFT (ic) && AOP_SIZE (IC_LEFT (ic)) < GPTRSIZE &&
+ IC_RIGHT (ic) && AOP_SIZE (IC_RIGHT (ic)) < GPTRSIZE &&
+ !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))) &&
+ !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "#0x%02x", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
+ aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1);
+ return;
+ }
+ if (IC_LEFT (ic) && AOP_SIZE (IC_LEFT (ic)) < GPTRSIZE &&
+ !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "#0x%02x", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
+ aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1);
+ return;
+ }
+ if (IC_RIGHT (ic) && AOP_SIZE (IC_RIGHT (ic)) < GPTRSIZE &&
+ !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "#0x%02x", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_RIGHT (ic)))), NULL, NULL));
+ aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1);
+ return;
+ }
}
}
#endif
/* if result in bit space */
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
- if ((unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) != 0L)
+ if (ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) != 0L)
emitcode ("cpl", "c");
outBitC (IC_RESULT (ic));
}
/* if the lower bytes of a literal are zero skip the addition */
if (AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT )
{
- while ((0 == ((unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) & (0xff << skip_bytes*8))) &&
+ while ((0 == ((unsigned int) ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) & (0xff << skip_bytes*8))) &&
(skip_bytes+1 < size))
{
skip_bytes++;
/* 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)
+ if ((icount = (unsigned int) ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
return FALSE;
D (emitcode (";", "genMinusDec"));
/* if decrement >=16 bits in register or direct space */
- if (( AOP_TYPE(IC_LEFT(ic)) == AOP_REG ||
+ if (( AOP_TYPE(IC_LEFT(ic)) == AOP_REG ||
AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ||
(IS_AOP_PREG (IC_LEFT(ic)) && !AOP_NEEDSACC (IC_LEFT(ic))) ) &&
sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
(icount == 1))
{
symbol *tlbl;
- int emitTlbl;
- int labelRange;
+ int emitTlbl;
+ int labelRange;
+ char *l;
/* If the next instruction is a goto and the goto target
* is <= 10 instructions previous to this, we can generate
emitTlbl = 1;
}
- emitcode ("dec", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE));
+ l = aopGet (IC_RESULT (ic), LSB, FALSE, FALSE);
+ emitcode ("dec", "%s", l);
+
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)
- ,tlbl->key + 100);
+ {
+ emitcode ("cjne", "%s,#0xff,%05d$", l, tlbl->key + 100);
+ }
else
{
emitcode ("mov", "a,#0xff");
- emitcode ("cjne", "a,%s,%05d$"
- ,aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE));
+ l = aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE);
+ emitcode ("dec", "%s", l);
if (size > 2)
{
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
- IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE)
- ,tlbl->key + 100);
+ if (!strcmp(l, "acc"))
+ {
+ emitcode("jnz", "!tlabel", tlbl->key + 100);
+ }
+ else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
+ IS_AOP_PREG (IC_RESULT (ic)))
+ {
+ emitcode ("cjne", "%s,#0xff,%05d$", l, tlbl->key + 100);
+ }
else
{
- emitcode ("cjne", "a,%s,%05d$"
- ,aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE));
+ l = aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE);
+ emitcode ("dec", "%s", l);
}
if (size > 3)
{
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
- IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0xff,%05d$"
- ,aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE)
- ,tlbl->key + 100);
+ if (!strcmp(l, "acc"))
+ {
+ emitcode("jnz", "!tlabel", tlbl->key + 100);
+ }
+ else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
+ IS_AOP_PREG (IC_RESULT (ic)))
+ {
+ emitcode ("cjne", "%s,#0xff,%05d$", l, tlbl->key + 100);
+ }
else
{
- emitcode ("cjne", "a,%s,%05d$"
- ,aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE));
+ l = aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE);
+ emitcode ("dec", "%s", l);
}
if (emitTlbl)
{
unsigned long lit = 0L;
bool useCarry = FALSE;
- lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+ lit = ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
lit = -(long) lit;
while (size--)
if (AOP_TYPE(left) == AOP_LIT)
{
/* signed literal */
- signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit);
if (val < 0)
compiletimeSign = TRUE;
}
if (AOP_TYPE(right) == AOP_LIT)
{
/* signed literal */
- signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (right)->aopu.aop_lit);
if (val < 0)
compiletimeSign ^= TRUE;
}
/* save the signs of the operands */
if (AOP_TYPE(right) == AOP_LIT)
{
- signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (right)->aopu.aop_lit);
if (!rUnsigned && val < 0)
emitcode ("mov", "b,#0x%02x", -val);
if (AOP_TYPE(left) == AOP_LIT)
{
- signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit);
if (!lUnsigned && val < 0)
emitcode ("mov", "a,#0x%02x", -val);
lbl = newiTempLabel (NULL);
emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
emitcode ("cpl", "F0"); /* complement sign flag */
- emitcode ("cpl", "a"); /* 2's complement */
+ emitcode ("cpl", "a"); /* 2's complement */
emitcode ("inc", "a");
emitLabel (lbl);
}
emitcode ("inc", "a"); /* inc doesn't set carry flag */
else
{
- emitcode ("add", "a,#1"); /* this sets carry flag */
+ emitcode ("add", "a,#0x01"); /* this sets carry flag */
emitcode ("xch", "a,b");
emitcode ("cpl", "a"); /* msb 2's complement */
- emitcode ("addc", "a,#0");
+ emitcode ("addc", "a,#0x00");
emitcode ("xch", "a,b");
}
emitLabel (lbl);
if (AOP_TYPE(left) == AOP_LIT)
{
/* signed literal */
- signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit);
if (val < 0)
compiletimeSign = TRUE;
}
if (AOP_TYPE(right) == AOP_LIT)
{
/* signed literal */
- signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (right)->aopu.aop_lit);
if (val < 0)
compiletimeSign ^= TRUE;
}
/* save the signs of the operands */
if (AOP_TYPE(right) == AOP_LIT)
{
- signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (right)->aopu.aop_lit);
if (!rUnsigned && val < 0)
emitcode ("mov", "b,#0x%02x", -val);
if (AOP_TYPE(left) == AOP_LIT)
{
- signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit);
if (!lUnsigned && val < 0)
emitcode ("mov", "a,#0x%02x", -val);
}
else /* compiletimeSign */
{
- if (aopPutUsesAcc (result, "#0xFF", offset))
+ if (aopPutUsesAcc (result, "#0xff", offset))
{
emitcode ("push", "acc");
pushedA = TRUE;
/* sign adjust left side */
if (AOP_TYPE(left) == AOP_LIT)
{
- signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+ signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit);
if (!lUnsigned && val < 0)
{
/* msb is 0x00 or 0xff depending on the sign */
if (runtimeSign)
{
- emitcode ("mov", "c,F0");
+ emitcode ("mov", "c,F0");
emitcode ("subb", "a,acc");
while (size--)
aopPut (result, "a", offset++);
/* genIfxJump :- will create a jump depending on the ifx */
/*-----------------------------------------------------------------*/
static void
-genIfxJump (iCode * ic, char *jval, operand *left, operand *right, operand *result)
+genIfxJump (iCode * ic, char *jval, operand *left, operand *right, operand *result, iCode *popIc)
{
symbol *jlbl;
symbol *tlbl = newiTempLabel (NULL);
char *inst;
+ /* if there is something to be popped then do it first */
+ popForBranch (popIc, TRUE);
+
D (emitcode (";", "genIfxJump"));
/* if true label then we jump if condition
{
if (AOP_TYPE (right) == AOP_LIT)
{
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
+ lit = ulFromVal (AOP (right)->aopu.aop_lit);
/* optimize if(x < 0) or if(x >= 0) */
if (lit == 0L)
{
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);
+ genIfxJump (ifx, "acc.7", left, right, result, ic->next);
freeAsmop (right, NULL, ic, TRUE);
freeAsmop (left, NULL, ic, TRUE);
code a little differently */
if (ifx)
{
- genIfxJump (ifx, "c", NULL, NULL, result);
+ genIfxJump (ifx, "c", NULL, NULL, result, ic->next);
}
else
{
/* if the left side is a literal or
if the right is in a pointer register and left
is not */
- if ((AOP_TYPE (left) == AOP_LIT) ||
+ if ((AOP_TYPE (left) == AOP_LIT) ||
(AOP_TYPE (left) == AOP_IMMD) ||
+ (AOP_TYPE (left) == AOP_DIR) ||
(IS_AOP_PREG (right) && !IS_AOP_PREG (left)))
{
operand *t = right;
}
if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
+ lit = ulFromVal (AOP (right)->aopu.aop_lit);
/* if the right side is a literal then anything goes */
if (AOP_TYPE (right) == AOP_LIT &&
/* gencjne - compare and jump if not equal */
/*-----------------------------------------------------------------*/
static void
-gencjne (operand * left, operand * right, symbol * lbl)
+gencjne (operand * left, operand * right, symbol * lbl, bool useCarry)
{
symbol *tlbl = newiTempLabel (NULL);
gencjneshort (left, right, lbl);
- emitcode ("mov", "a,%s", one);
+ if (useCarry)
+ SETC;
+ else
+ MOVA (one);
emitcode ("sjmp", "%05d$", tlbl->key + 100);
emitLabel (lbl);
- emitcode ("clr", "a");
+ if (useCarry)
+ CLRC;
+ else
+ MOVA (zero);
emitLabel (tlbl);
}
{
bool swappedLR = FALSE;
operand *left, *right, *result;
+ iCode * popIc = ic->next;
D (emitcode (";", "genCmpEq"));
{
if (AOP_TYPE (right) == AOP_LIT)
{
- unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+ unsigned long lit = ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
if (lit == 0L)
{
emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
freeForBranchAsmop (result);
freeForBranchAsmop (right);
freeForBranchAsmop (left);
+ popForBranch (popIc, FALSE);
emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
}
else
freeForBranchAsmop (result);
freeForBranchAsmop (right);
freeForBranchAsmop (left);
+ popForBranch (popIc, FALSE);
emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100);
}
emitLabel (tlbl);
freeForBranchAsmop (result);
freeForBranchAsmop (right);
freeForBranchAsmop (left);
+ popForBranch (popIc, FALSE);
emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
emitLabel (tlbl);
}
freeForBranchAsmop (result);
freeForBranchAsmop (right);
freeForBranchAsmop (left);
+ popForBranch (popIc, FALSE);
emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100);
emitLabel (lbl);
}
{
if (AOP_TYPE (right) == AOP_LIT)
{
- unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+ unsigned long lit = ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
if (lit == 0L)
{
emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
}
if (ifx)
{
- genIfxJump (ifx, "c", left, right, result);
+ genIfxJump (ifx, "c", left, right, result, popIc);
goto release;
}
/* if the result is used in an arithmetic operation
}
else
{
- gencjne (left, right, newiTempLabel (NULL));
if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
{
- aopPut (result, "a", 0);
+ gencjne (left, right, newiTempLabel (NULL), TRUE);
+ aopPut (result, "c", 0);
goto release;
}
+ gencjne (left, right, newiTempLabel (NULL), FALSE);
if (ifx)
{
- genIfxJump (ifx, "a", left, right, result);
+ genIfxJump (ifx, "a", left, right, result, popIc);
goto release;
}
/* if the result is used in an arithmetic operation
static iCode *
ifxForOp (operand * op, iCode * ic)
{
+ iCode *ifxIc;
+
/* if true symbol then needs to be assigned */
if (IS_TRUE_SYMOP (op))
return NULL;
/* if this has register type condition and
+ while skipping ipop's (see bug 1509084),
the next instruction is ifx with the same operand
and live to of the operand is upto the ifx only then */
- if (ic->next &&
- ic->next->op == IFX &&
- IC_COND (ic->next)->key == op->key &&
- OP_SYMBOL (op)->liveTo <= ic->next->seq)
- return ic->next;
+ for (ifxIc = ic->next; ifxIc && ifxIc->op == IPOP; ifxIc = ifxIc->next);
+ if (ifxIc && ifxIc->op == IFX &&
+ IC_COND (ifxIc)->key == op->key &&
+ OP_SYMBOL (op)->liveTo <= ifxIc->seq)
+ return ifxIc;
return NULL;
}
if (IS_AGGREGATE(type->next)) return NULL;
if (osize != (isize = getSize(type->next))) return NULL;
- while (lic) {
- /* if operand of the form op = op + <sizeof *op> */
- if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) &&
- isOperandEqual(IC_RESULT(lic),op) &&
- isOperandLiteral(IC_RIGHT(lic)) &&
- operandLitValue(IC_RIGHT(lic)) == isize) {
- return lic;
- }
- /* if the operand used or deffed */
- if (bitVectBitValue(OP_USES(op),lic->key) || lic->defKey == op->key) {
- return NULL;
+ while (lic)
+ {
+ /* if operand of the form op = op + <sizeof *op> */
+ if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) &&
+ isOperandEqual(IC_RESULT(lic),op) &&
+ isOperandLiteral(IC_RIGHT(lic)) &&
+ operandLitValue(IC_RIGHT(lic)) == isize)
+ {
+ return lic;
+ }
+ /* if the operand used or deffed */
+ if (bitVectBitValue(OP_USES(op),lic->key) || lic->defKey == op->key)
+ {
+ return NULL;
+ }
+ /* if GOTO or IFX */
+ if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break;
+ lic = lic->next;
}
- /* if GOTO or IFX */
- if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break;
- lic = lic->next;
- }
return NULL;
}
left = tmp;
}
if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
+ lit = ulFromVal (AOP (right)->aopu.aop_lit);
size = AOP_SIZE (result);
if (AOP_TYPE (right) == AOP_CRY)
{
// c = bit & bit;
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
+ if (IS_OP_ACCUSE (left))
+ {
+ emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
+ }
+ else
+ {
+ emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+ emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
+ }
}
else
{
outBitC (result);
// if(bit & ...)
else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- genIfxJump (ifx, "c", left, right, result);
+ genIfxJump (ifx, "c", left, right, result, ic->next);
goto release;
}
{
SNPRINTF (buffer, sizeof(buffer),
"acc.%d", posbit & 0x07);
- genIfxJump (ifx, buffer, left, right, result);
+ genIfxJump (ifx, buffer, left, right, result, ic->next);
}
else
{// what is this case? just found it in ds390/gen.c
{
MOVA (aopGet (left, offset, FALSE, FALSE));
emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
- }
+ }
else
{
MOVA (aopGet (right, offset, FALSE, FALSE));
left = tmp;
}
if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
+ lit = ulFromVal (AOP (right)->aopu.aop_lit);
size = AOP_SIZE (result);
if (AOP_TYPE (right) == AOP_CRY)
{
// c = bit | bit;
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- emitcode ("orl", "c,%s", AOP (left)->aopu.aop_dir);
+ if (IS_OP_ACCUSE (left))
+ {
+ emitcode ("orl", "c,%s", AOP (right)->aopu.aop_dir);
+ }
+ else
+ {
+ emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+ emitcode ("orl", "c,%s", AOP (left)->aopu.aop_dir);
+ }
}
else
{
// c = bit | val;
- symbol *tlbl = newiTempLabel (NULL);
- if (!((AOP_TYPE (result) == AOP_CRY) && ifx))
- emitcode ("setb", "c");
- emitcode ("jb", "%s,%05d$",
- AOP (left)->aopu.aop_dir, tlbl->key + 100);
- toBoolean (right);
- emitcode ("jnz", "%05d$", tlbl->key + 100);
if ((AOP_TYPE (result) == AOP_CRY) && ifx)
{
+ symbol *tlbl = newiTempLabel (NULL);
+ emitcode ("jb", "%s,%05d$",
+ AOP (left)->aopu.aop_dir, tlbl->key + 100);
+ toBoolean (right);
+ emitcode ("jnz", "%05d$", tlbl->key + 100);
jmpTrueOrFalse (ifx, tlbl, left, right, result);
goto release;
}
else
{
- CLRC;
- emitLabel (tlbl);
+ toCarry (right);
+ emitcode ("orl", "c,%s", AOP (left)->aopu.aop_dir);
}
}
}
outBitC (result);
// if(bit | ...)
else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- genIfxJump (ifx, "c", left, right, result);
+ genIfxJump (ifx, "c", left, right, result, ic->next);
goto release;
}
}
else
{
- genIfxJump (ifx, "a", left, right, result);
+ genIfxJump (ifx, "a", left, right, result, ic->next);
goto release;
}
}
}
else if (bytelit == 0x0FF)
{
- aopPut (result, "#0xFF", offset);
+ aopPut (result, "#0xff", offset);
}
else if (IS_AOP_PREG (left))
{
/* dummy read of volatile operand */
if (isOperandVolatile (left, FALSE))
MOVA (aopGet (left, offset, FALSE, FALSE));
- aopPut (result, "#0xFF", offset);
+ aopPut (result, "#0xff", offset);
continue;
}
}
}
if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
+ lit = ulFromVal (AOP (right)->aopu.aop_lit);
size = AOP_SIZE (result);
if (AOP_TYPE (right) == AOP_CRY)
{
// c = bit ^ bit;
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+ if (IS_OP_ACCUSE (left))
+ {// left already is in the carry
+ operand *tmp = right;
+ right = left;
+ left = tmp;
+ }
+ else
+ {
+ toCarry (right);
+ }
}
else
{
- int sizer = AOP_SIZE (right);
// c = bit ^ val
- // if val>>1 != 0, result = 1
- emitcode ("setb", "c");
- while (sizer)
- {
- MOVA (aopGet (right, sizer - 1, FALSE, FALSE));
- if (sizer == 1)
- // test the msb of the lsb
- emitcode ("anl", "a,#0xfe");
- emitcode ("jnz", "%05d$", tlbl->key + 100);
- sizer--;
- }
- // val = (0,1)
- emitcode ("rrc", "a");
+ toCarry (right);
}
emitcode ("jnb", "%s,%05d$", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
emitcode ("cpl", "c");
outBitC (result);
// if(bit ^ ...)
else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
- genIfxJump (ifx, "c", left, right, result);
+ genIfxJump (ifx, "c", left, right, result, ic->next);
goto release;
}
genInline (iCode * ic)
{
char *buffer, *bp, *bp1;
+ bool inComment = FALSE;
D (emitcode (";", "genInline"));
_G.inLine += (!options.asmpeep);
- buffer = bp = bp1 = Safe_strdup(IC_INLINE(ic));
+ buffer = bp = bp1 = Safe_strdup (IC_INLINE (ic));
/* emit each line as a code */
while (*bp)
{
- if (*bp == '\n')
+ switch (*bp)
{
+ case ';':
+ inComment = TRUE;
+ ++bp;
+ break;
+
+ case '\n':
+ inComment = FALSE;
*bp++ = '\0';
emitcode (bp1, "");
bp1 = bp;
- }
- else
- {
+ break;
+
+ default:
/* Add \n for labels, not dirs such as c:\mydir */
- if ( (*bp == ':') && (isspace((unsigned char)bp[1])) )
+ if (!inComment && (*bp == ':') && (isspace((unsigned char)bp[1])))
{
- bp++;
+ ++bp;
*bp = '\0';
- bp++;
+ ++bp;
emitcode (bp1, "");
bp1 = bp;
}
else
- bp++;
+ ++bp;
+ break;
}
}
if (bp1 != bp)
emitcode (bp1, "");
- /* emitcode("",buffer); */
+
+ Safe_free (buffer);
+
_G.inLine -= (!options.asmpeep);
}
genRRC (iCode * ic)
{
operand *left, *result;
- int size, offset;
- char *l;
+ int size, offset;
+ char *l;
D (emitcode (";", "genRRC"));
aopOp (right, ic, FALSE);
aopOp (result, ic, FALSE);
- shCount = (int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+ shCount = (int) ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
/* get the needed byte into a */
MOVA (aopGet (left, shCount / 8, FALSE, FALSE));
aopOp (right, ic, FALSE);
aopOp (result, ic, FALSE);
- offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
+ offset = (int) ulFromVal (AOP (right)->aopu.aop_lit) / 8;
aopPut (result,
aopGet (left, offset, FALSE, FALSE),
0);
aopOp (right, ic, FALSE);
aopOp (result, ic, FALSE);
- offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
+ offset = (int) ulFromVal (AOP (right)->aopu.aop_lit) / 8;
aopPut (result,
aopGet (left, offset, FALSE, FALSE),
0);
break;
case 3:
case 4:
- case 5: // AAAAABBB:CCCCCDDD
+ case 5: // AAAAABBB:CCCCCDDD
- AccRol (shCount); // BBBAAAAA:CCCCCDDD
+ AccRol (shCount); // BBBAAAAA:CCCCCDDD
emitcode ("anl", "a,#0x%02x",
SLMask[shCount]); // BBB00000:CCCCCDDD
emitcode ("xch", "a,%s", x); // CCCCCDDD:BBB00000
- AccRol (shCount); // DDDCCCCC:BBB00000
+ AccRol (shCount); // DDDCCCCC:BBB00000
emitcode ("xch", "a,%s", x); // BBB00000:DDDCCCCC
emitcode ("xrl", "a,%s", x); // BBBCCCCC:DDD00000
break;
- case 6: // AAAAAABB:CCCCCCDD
+ case 6: // AAAAAABB:CCCCCCDD
emitcode ("anl", "a,#0x%02x",
SRMask[shCount]); // 000000BB:CCCCCCDD
emitcode ("mov", "c,acc.0"); // c = B
emitcode ("xch", "a,%s", x); // CCCCCCDD:000000BB
#if 0 // REMOVE ME
- AccAXRrl1 (x); // BCCCCCCD:D000000B
- AccAXRrl1 (x); // BBCCCCCC:DD000000
+ AccAXRrl1 (x); // BCCCCCCD:D000000B
+ AccAXRrl1 (x); // BBCCCCCC:DD000000
#else
emitcode("rrc","a");
emitcode("xch","a,%s", x);
emitcode("xch","a,%s", x);
#endif
break;
- case 7: // a:x <<= 7
+ case 7: // a:x <<= 7
emitcode ("anl", "a,#0x%02x",
SRMask[shCount]); // 0000000B:CCCCCCCD
emitcode ("xch", "a,%s", x); // CCCCCCCD:0000000B
- AccAXRrl1 (x); // BCCCCCCC:D0000000
+ AccAXRrl1 (x); // BCCCCCCC:D0000000
break;
default:
break;
case 1:
CLRC;
- AccAXRrl1 (x); // 0->a:x
+ AccAXRrl1 (x); // 0->a:x
break;
case 2:
CLRC;
- AccAXRrl1 (x); // 0->a:x
+ AccAXRrl1 (x); // 0->a:x
CLRC;
- AccAXRrl1 (x); // 0->a:x
+ AccAXRrl1 (x); // 0->a:x
break;
case 3:
case 4:
- case 5: // AAAAABBB:CCCCCDDD = a:x
+ case 5: // AAAAABBB:CCCCCDDD = a:x
- AccRol (8 - shCount); // BBBAAAAA:DDDCCCCC
+ AccRol (8 - shCount); // BBBAAAAA:DDDCCCCC
emitcode ("xch", "a,%s", x); // CCCCCDDD:BBBAAAAA
- AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA
+ AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA
emitcode ("anl", "a,#0x%02x",
SRMask[shCount]); // 000CCCCC:BBBAAAAA
emitcode ("xch", "a,%s", x); // 000AAAAA:BBBCCCCC
break;
- case 6: // AABBBBBB:CCDDDDDD
+ case 6: // AABBBBBB:CCDDDDDD
emitcode ("mov", "c,acc.7");
- AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA
+ AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA
emitcode ("mov", "c,acc.7");
- AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA
+ AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA
emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC
SRMask[shCount]); // 000000AA:BBBBBBCC
break;
- case 7: // ABBBBBBB:CDDDDDDD
+ case 7: // ABBBBBBB:CDDDDDDD
emitcode ("mov", "c,acc.7"); // c = A
- AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA
+ AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA
emitcode ("xch", "a,%s", x); // DDDDDDDA:BBBBBBCC
break;
case 1:
emitcode ("mov", "c,acc.7");
- AccAXRrl1 (x); // s->a:x
+ AccAXRrl1 (x); // s->a:x
break;
case 2:
emitcode ("mov", "c,acc.7");
- AccAXRrl1 (x); // s->a:x
+ AccAXRrl1 (x); // s->a:x
emitcode ("mov", "c,acc.7");
- AccAXRrl1 (x); // s->a:x
+ AccAXRrl1 (x); // s->a:x
break;
case 3:
case 4:
- case 5: // AAAAABBB:CCCCCDDD = a:x
+ case 5: // AAAAABBB:CCCCCDDD = a:x
tlbl = newiTempLabel (NULL);
- AccRol (8 - shCount); // BBBAAAAA:CCCCCDDD
+ AccRol (8 - shCount); // BBBAAAAA:CCCCCDDD
emitcode ("xch", "a,%s", x); // CCCCCDDD:BBBAAAAA
- AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA
+ AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA
emitcode ("anl", "a,#0x%02x",
SRMask[shCount]); // 000CCCCC:BBBAAAAA
(unsigned char) ~SRMask[shCount]); // 111AAAAA:BBBCCCCC
emitLabel (tlbl);
- break; // SSSSAAAA:BBBCCCCC
+ break; // SSSSAAAA:BBBCCCCC
- case 6: // AABBBBBB:CCDDDDDD
+ case 6: // AABBBBBB:CCDDDDDD
tlbl = newiTempLabel (NULL);
emitcode ("mov", "c,acc.7");
- AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA
+ AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA
emitcode ("mov", "c,acc.7");
- AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA
+ AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA
emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC
emitLabel (tlbl);
break;
- case 7: // ABBBBBBB:CDDDDDDD
+ case 7: // ABBBBBBB:CDDDDDDD
tlbl = newiTempLabel (NULL);
emitcode ("mov", "c,acc.7"); // c = A
- AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA
+ AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA
emitcode ("xch", "a,%s", x); // DDDDDDDA:BBBBBBCC
if (size > 1)
{
if (shCount)
- shiftL1Left2Result (left, LSB, result, MSB16, shCount);
+ {
+ shiftL1Left2Result (left, LSB, result, MSB16, shCount);
+ }
else
- movLeft2Result (left, LSB, result, MSB16, 0);
+ {
+ movLeft2Result (left, LSB, result, MSB16, 0);
+ }
}
aopPut (result, zero, LSB);
}
operand * result,
iCode * ic)
{
- int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
+ int shCount = (int) ulFromVal (AOP (right)->aopu.aop_lit);
int size;
D (emitcode (";", "genLeftShiftLiteral"));
iCode * ic,
int sign)
{
- int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
+ int shCount = (int) ulFromVal (AOP (right)->aopu.aop_lit);
int size;
D (emitcode (";", "genRightShiftLiteral"));
while (size--)
movLeft2Result (left, size, result, size, 0);
}
-
else if (shCount >= (size * 8))
{
if (sign)
/*-----------------------------------------------------------------*/
/* genUnpackBits - generates code for unpacking bits */
/*-----------------------------------------------------------------*/
-static void
+static char*
genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx)
{
int offset = 0; /* result byte offset */
sym_link *etype; /* bitfield type information */
int blen; /* bitfield length */
int bstr; /* bitfield starting bit within byte */
- char buffer[10];
+ static char* const accBits[] = {"acc.0", "acc.1", "acc.2", "acc.3",
+ "acc.4", "acc.5", "acc.6", "acc.7"};
D(emitcode (";", "genUnpackBits"));
emitPtrByteGet (rname, ptype, FALSE);
if (blen == 1)
{
- SNPRINTF (buffer, sizeof(buffer),
- "acc.%d", bstr);
- genIfxJump (ifx, buffer, NULL, NULL, NULL);
+ return accBits[bstr];;
}
else
{
if (blen < 8)
emitcode ("anl", "a,#0x%02x",
(((unsigned char) -1) >> (8 - blen)) << bstr);
- genIfxJump (ifx, "a", NULL, NULL, NULL);
+ return "a";
}
- return;
}
wassert (!ifx);
while (rsize--)
aopPut (result, source, offset++);
}
+ return NULL;
}
asmop *aop = NULL;
regs *preg = NULL;
char *rname;
+ char *ifxCond = "a";
sym_link *rtype, *retype;
sym_link *ltype = operandType (left);
- char buffer[80];
D (emitcode (";", "genNearPointerGet"));
return;
}
+ //aopOp (result, ic, FALSE);
+ aopOp (result, ic, result?TRUE:FALSE);
+
/* if the value is already in a pointer register
then don't need anything more */
if (!AOP_INPREG (AOP (left)))
rname = aopGet (left, 0, FALSE, FALSE);
if (*rname != '@')
{
- fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
- __FILE__, __LINE__);
+ fprintf(stderr, "probable internal error: unexpected rname '%s' @ %s:%d\n",
+ rname, __FILE__, __LINE__);
}
else
{
else
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, ifx);
+ ifxCond = genUnpackBits (result, rname, POINTER, ifx);
else
{
/* we have can just get the values */
}
else
{
+ char buffer[80];
+
SNPRINTF (buffer, sizeof(buffer), "@%s", rname);
aopPut (result, buffer, offset);
}
}
/* now some housekeeping stuff */
- if (aop) /* we had to allocate for this iCode */
+ if (aop) /* we had to allocate for this iCode */
{
if (pi) { /* post increment present */
aopPut (left, rname, 0);
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
/* done */
asmop *aop = NULL;
regs *preg = NULL;
char *rname;
+ char *ifxCond = "a";
sym_link *rtype, *retype;
D (emitcode (";", "genPagedPointerGet"));
aopOp (left, ic, FALSE);
+ aopOp (result, ic, FALSE);
+
/* if the value is already in a pointer register
then don't need anything more */
if (!AOP_INPREG (AOP (left)))
else
rname = aopGet (left, 0, FALSE, FALSE);
- aopOp (result, ic, FALSE);
-
/* if bitfield then unpack the bits */
if (IS_BITFIELD (retype))
- genUnpackBits (result, rname, PPOINTER, ifx);
+ ifxCond = genUnpackBits (result, rname, PPOINTER, ifx);
else
{
/* we have can just get the values */
}
/* now some housekeeping stuff */
- if (aop) /* we had to allocate for this iCode */
+ if (aop) /* we had to allocate for this iCode */
{
if (pi)
aopPut (left, rname, 0);
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
/* done */
operand * result, iCode * ic, iCode * pi, iCode * ifx)
{
int size, offset;
+ char *ifxCond = "a";
sym_link *retype = getSpec (operandType (result));
D (emitcode (";", "genFarPointerGet"));
/* if bit then unpack */
if (IS_BITFIELD (retype))
- genUnpackBits (result, "dptr", FPOINTER, ifx);
+ ifxCond = genUnpackBits (result, "dptr", FPOINTER, ifx);
else
{
size = AOP_SIZE (result);
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
freeAsmop (result, NULL, ic, TRUE);
operand * result, iCode * ic, iCode *pi, iCode *ifx)
{
int size, offset;
+ char *ifxCond = "a";
sym_link *retype = getSpec (operandType (result));
D (emitcode (";", "genCodePointerGet"));
/* if bit then unpack */
if (IS_BITFIELD (retype))
- genUnpackBits (result, "dptr", CPOINTER, ifx);
+ ifxCond = genUnpackBits (result, "dptr", CPOINTER, ifx);
else
{
size = AOP_SIZE (result);
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
freeAsmop (result, NULL, ic, TRUE);
operand * result, iCode * ic, iCode *pi, iCode *ifx)
{
int size, offset;
+ char *ifxCond = "a";
sym_link *retype = getSpec (operandType (result));
D (emitcode (";", "genGenPointerGet"));
/* if bit then unpack */
if (IS_BITFIELD (retype))
{
- genUnpackBits (result, "dptr", GPOINTER, ifx);
+ ifxCond = genUnpackBits (result, "dptr", GPOINTER, ifx);
}
else
{
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
freeAsmop (result, NULL, ic, TRUE);
etype = getSpec (type);
/* if left is of type of pointer then it is simple */
if (IS_PTR (type) && !IS_FUNC (type->next))
- p_type = DCL_TYPE (type);
+ {
+ p_type = DCL_TYPE (type);
+ }
else
{
/* we have to go by the storage class */
{
/* Case with a bitfield length <8 and literal source
*/
- litval = (int) floatFromVal (AOP (right)->aopu.aop_lit);
+ litval = (int) ulFromVal (AOP (right)->aopu.aop_lit);
litval <<= bstr;
litval &= (~mask) & 0xff;
emitPtrByteGet (rname, p_type, FALSE);
{
/* Case with partial byte and literal source
*/
- litval = (int) floatFromVal (AOP (right)->aopu.aop_lit);
+ litval = (int) ulFromVal (AOP (right)->aopu.aop_lit);
litval >>= (blen-rlen);
litval &= (~mask) & 0xff;
emitPtrByteGet (rname, p_type, FALSE);
l = aopGet (result, 0, FALSE, TRUE);
l++; //remove #
- size = AOP_SIZE (right);
+ size = max (AOP_SIZE (right), AOP_SIZE (result));
while (size--)
{
if (offset)
aopGet (right, offset++, FALSE, FALSE));
}
- freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
-/* genNearPointerSet - emitcode for near pointer put */
+/* genNearPointerSet - emitcode for near pointer put */
/*-----------------------------------------------------------------*/
static void
genNearPointerSet (operand * right,
then don't need anything more */
if (!AOP_INPREG (AOP (result)))
{
- if (
- //AOP_TYPE (result) == AOP_STK
- IS_AOP_PREG(result)
- )
+ if (IS_AOP_PREG (result))
{
- // Aha, it is a pointer, just in disguise.
- rname = aopGet (result, 0, FALSE, FALSE);
- if (*rname != '@')
+ // Aha, it is a pointer, just in disguise.
+ rname = aopGet (result, 0, FALSE, FALSE);
+ if (*rname != '@')
{
- fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
- __FILE__, __LINE__);
+ fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
+ __FILE__, __LINE__);
}
- else
+ else
{
- // Expected case.
- emitcode ("mov", "a%s,%s", rname + 1, rname);
- rname++; // skip the '@'.
+ // Expected case.
+ emitcode ("mov", "a%s,%s", rname + 1, rname);
+ rname++; // skip the '@'.
}
}
- else
+ else
{
- /* otherwise get a free pointer register */
- aop = newAsmop (0);
- preg = getFreePtr (ic, &aop, FALSE);
- emitcode ("mov", "%s,%s",
- preg->name,
- aopGet (result, 0, FALSE, TRUE));
- rname = preg->name;
+ /* otherwise get a free pointer register */
+ aop = newAsmop (0);
+ preg = getFreePtr (ic, &aop, FALSE);
+ emitcode ("mov", "%s,%s",
+ preg->name,
+ aopGet (result, 0, FALSE, TRUE));
+ rname = preg->name;
}
}
- else
+ else
{
- rname = aopGet (result, 0, FALSE, FALSE);
+ rname = aopGet (result, 0, FALSE, FALSE);
}
aopOp (right, ic, FALSE);
}
/* now some housekeeping stuff */
- if (aop) /* we had to allocate for this iCode */
+ if (aop) /* we had to allocate for this iCode */
{
if (pi)
aopPut (result, rname, 0);
}
/* done */
- if (pi) pi->generated = 1;
- freeAsmop (result, NULL, ic, TRUE);
+ if (pi)
+ pi->generated = 1;
freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
then don't need anything more */
if (!AOP_INPREG (AOP (result)))
{
- /* otherwise get a free pointer register */
- aop = newAsmop (0);
- preg = getFreePtr (ic, &aop, FALSE);
- emitcode ("mov", "%s,%s",
- preg->name,
- aopGet (result, 0, FALSE, TRUE));
- rname = preg->name;
+ if (IS_AOP_PREG (result))
+ {
+ // Aha, it is a pointer, just in disguise.
+ rname = aopGet (result, 0, FALSE, FALSE);
+ if (*rname != '@')
+ {
+ fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
+ __FILE__, __LINE__);
+ }
+ else
+ {
+ // Expected case.
+ emitcode ("mov", "a%s,%s", rname + 1, rname);
+ rname++; // skip the '@'.
+ }
+ }
+ else
+ {
+ /* otherwise get a free pointer register */
+ aop = newAsmop (0);
+ preg = getFreePtr (ic, &aop, FALSE);
+ emitcode ("mov", "%s,%s",
+ preg->name,
+ aopGet (result, 0, FALSE, TRUE));
+ rname = preg->name;
+ }
}
else
- rname = aopGet (result, 0, FALSE, FALSE);
+ {
+ rname = aopGet (result, 0, FALSE, FALSE);
+ }
aopOp (right, ic, FALSE);
genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, rname, PPOINTER);
else
{
- /* we have can just get the values */
+ /* we can just get the values */
int size = AOP_SIZE (right);
int offset = 0;
l = aopGet (right, offset, FALSE, TRUE);
MOVA (l);
emitcode ("movx", "@%s,a", rname);
-
if (size || pi)
emitcode ("inc", "%s", rname);
-
offset++;
}
}
belongs */
if (AOP_SIZE (right) > 1 &&
!OP_SYMBOL (result)->remat &&
- (OP_SYMBOL (result)->liveTo > ic->seq ||
- ic->depth))
+ (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth) &&
+ !pi)
{
int size = AOP_SIZE (right) - 1;
while (size--)
}
/* done */
- if (pi) pi->generated = 1;
- freeAsmop (result, NULL, ic, TRUE);
+ if (pi)
+ pi->generated = 1;
freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
/* 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 && dup)
- genIfxJump(ic, dup, NULL, NULL, NULL);
+ genIfxJump(ic, dup, NULL, NULL, NULL, popIc);
else if (isbit && IS_ITEMP (cond) && SPIL_LOC (cond))
- genIfxJump (ic, SPIL_LOC (cond)->rname, NULL, NULL, NULL);
+ genIfxJump (ic, SPIL_LOC (cond)->rname, NULL, NULL, NULL, popIc);
else if (isbit && !IS_ITEMP (cond))
- genIfxJump (ic, OP_SYMBOL (cond)->rname, NULL, NULL, NULL);
+ genIfxJump (ic, OP_SYMBOL (cond)->rname, NULL, NULL, NULL, popIc);
else
- genIfxJump (ic, "a", NULL, NULL, NULL);
+ genIfxJump (ic, "a", NULL, NULL, NULL, popIc);
ic->generated = 1;
}
}
/* object not on stack then we need the name */
- size = AOP_SIZE (IC_RESULT (ic));
+ size = getDataSize (IC_RESULT (ic));
offset = 0;
while (size--)
{
char s[SDCC_NAME_MAX];
if (offset)
- sprintf (s, "#(%s >> %d)",
- sym->rname,
- offset * 8);
+ {
+ sprintf (s, "#(%s >> %d)",
+ sym->rname,
+ offset * 8);
+ }
else
- SNPRINTF (s, sizeof(s), "#%s", sym->rname);
+ {
+ SNPRINTF (s, sizeof(s), "#%s", sym->rname);
+ }
aopPut (IC_RESULT (ic), s, offset++);
}
+ if (opIsGptr (IC_RESULT (ic)))
+ {
+ char buffer[10];
+ SNPRINTF (buffer, sizeof(buffer),
+ "#0x%02x", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
+ aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1);
+ }
release:
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
/* bit variables done */
/* general case */
- size = AOP_SIZE (result);
+ size = getDataSize (result);
offset = 0;
if (AOP_TYPE (right) == AOP_LIT)
- lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
+ lit = ulFromVal (AOP (right)->aopu.aop_lit);
if ((size > 1) &&
(AOP_TYPE (result) != AOP_REG) &&
offset++;
}
}
+ adjustArithmeticResult (ic);
release:
freeAsmop (result, NULL, ic, TRUE);
/* multiply by three */
if (aopGetUsesAcc (IC_JTCOND (ic), 0))
{
- emitcode ("mov", "b,#3");
+ emitcode ("mov", "b,#0x03");
emitcode ("mul", "ab");
}
else
exit(1);
}
- sprintf(gpValStr, "#0x%x", gpVal);
+ sprintf(gpValStr, "#0x%02x", gpVal);
aopPut (result, gpValStr, GPTRSIZE - 1);
}
goto release;
}
else if (ic->argreg > 12)
{ /* bit parameters */
- if (OP_SYMBOL (IC_RESULT (ic))->regs[0]->rIdx != ic->argreg-5)
+ regs *reg = OP_SYMBOL (IC_RESULT (ic))->regs[0];
+
+ BitBankUsed = 1;
+ if (!reg || reg->rIdx != ic->argreg-5)
{
aopOp (IC_RESULT (ic), ic, FALSE);
emitcode ("mov", "c,%s", rb1regs[ic->argreg-5]);
if (options.iCodeInAsm) {
char regsInUse[80];
int i;
- char *iLine;
+ const char *iLine;
#if 0
for (i=0; i<8; i++) {
break;
case IPOP:
- /* IPOP happens only when trying to restore a
- spilt live range, if there is an ifx statement
- following this pop then the if statement might
- be using some of the registers being popped which
- would destory the contents of the register so
- we need to check for this condition and handle it */
- if (ic->next &&
- ic->next->op == IFX &&
- regsInCommon (IC_LEFT (ic), IC_COND (ic->next)))
- genIfx (ic->next, ic);
- else
- genIpop (ic);
+ {
+ iCode *ifxIc, *popIc;
+ bool CommonRegs = FALSE;
+
+ /* IPOP happens only when trying to restore a
+ spilt live range, if there is an ifx statement
+ following this pop (or several) then the if statement might
+ be using some of the registers being popped which
+ would destory the contents of the register so
+ we need to check for this condition and handle it */
+ for (ifxIc = ic->next; ifxIc && ifxIc->op == IPOP; ifxIc = ifxIc->next);
+ for (popIc = ic; popIc && popIc->op == IPOP; popIc = popIc->next)
+ CommonRegs |= (ifxIc && ifxIc->op == IFX && !ifxIc->generated &&
+ regsInCommon (IC_LEFT (popIc), IC_COND (ifxIc)));
+ if (CommonRegs)
+ genIfx (ifxIc, ic);
+ else
+ genIpop (ic);
+ }
break;
case CALL: