aopForRemat (symbol * sym)
{
iCode *ic = sym->rematiCode;
- asmop *aop = newAsmop (AOP_IMMD);
+ asmop *aop = NULL;
int ptr_type=0;
int val = 0;
ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
}
- if (val)
- sprintf (buffer, "(%s %c 0x%04x)",
- OP_SYMBOL (IC_LEFT (ic))->rname,
- val >= 0 ? '+' : '-',
- abs (val) & 0xffff);
- else
- strcpy (buffer, OP_SYMBOL (IC_LEFT (ic))->rname);
+ if (ic->op == ADDRESS_OF)
+ {
+ if (val)
+ sprintf (buffer, "(%s %c 0x%04x)",
+ OP_SYMBOL (IC_LEFT (ic))->rname,
+ val >= 0 ? '+' : '-',
+ abs (val) & 0xffff);
+ else
+ strcpy (buffer, OP_SYMBOL (IC_LEFT (ic))->rname);
- aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1);
- strcpy (aop->aopu.aop_immd.aop_immd1, buffer);
- /* set immd2 field if required */
- if (aop->aopu.aop_immd.from_cast_remat) {
+ aop = newAsmop (AOP_IMMD);
+ aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1);
+ strcpy (aop->aopu.aop_immd.aop_immd1, buffer);
+ /* set immd2 field if required */
+ if (aop->aopu.aop_immd.from_cast_remat)
+ {
sprintf(buffer,"#0x%02x",ptr_type);
aop->aopu.aop_immd.aop_immd2 = Safe_calloc (1, strlen (buffer) + 1);
strcpy (aop->aopu.aop_immd.aop_immd2, buffer);
- }
+ }
+ }
+ else if (ic->op == '=')
+ {
+ val += (int) operandLitValue (IC_RIGHT (ic));
+ val &= 0xffff;
+ sprintf (buffer, "0x%04x", val);
+ aop = newAsmop (AOP_LIT);
+ aop->aopu.aop_lit = constVal (buffer);
+ }
+ else
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "unexpected rematerialization");
+
+
return aop;
}
case AOP_LIT:
if (bit16)
- return aopLiteralLong (aop->aopu.aop_lit, loffset, 2);
+ return aopLiteralLong (aop->aopu.aop_lit, /*loffset*/ 0, 2);
else
return aopLiteral (aop->aopu.aop_lit, loffset);
emitcode ("rola", "");
hc08_dirtyReg (hc08_reg_a, FALSE);
storeRegToFullAop (hc08_reg_a, AOP (result), FALSE);
+ hc08_freeReg (hc08_reg_a);
+
+ freeAsmop (left, NULL, ic, TRUE);
+ freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSwap - generates code to swap nibbles or bytes */
+/*-----------------------------------------------------------------*/
+static void
+genSwap (iCode * ic)
+{
+ operand *left, *result;
+
+ D(emitcode ("; genSwap",""));
+
+ left = IC_LEFT (ic);
+ result = IC_RESULT (ic);
+ aopOp (left, ic, FALSE);
+ aopOp (result, ic, FALSE);
+ switch (AOP_SIZE (left))
+ {
+ case 1: /* swap nibbles in byte */
+ loadRegFromAop (hc08_reg_a, AOP (left), 0);
+ emitcode ("nsa", "");
+ hc08_dirtyReg (hc08_reg_a, FALSE);
+ storeRegToAop (hc08_reg_a, AOP (result), 0);
+ hc08_freeReg (hc08_reg_a);
+ break;
+ case 2: /* swap bytes in a word */
+ if (operandsEqu (left, result))
+ {
+ loadRegFromAop (hc08_reg_a, AOP (left), 0);
+ hc08_useReg (hc08_reg_a);
+ transferAopAop (AOP (left), 1, AOP (result), 0);
+ storeRegToAop (hc08_reg_a, AOP (result), 1);
+ hc08_freeReg (hc08_reg_a);
+ }
+ else
+ {
+ transferAopAop (AOP (left), 0, AOP (result), 1);
+ transferAopAop (AOP (left), 1, AOP (result), 0);
+ }
+ break;
+ default:
+ wassertl(FALSE, "unsupported SWAP operand size");
+ }
+
freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
}
** rola 1 1 bcde fgh0 0000 000a 0
** lslx 1 1 cdef gh00 0000 000a b
** rola 1 1 cdef gh00 0000 00ab 0
- ** clrx 1 1 0000 0000 0000 000a 0
+ ** clrx 1 1 0000 0000 0000 00ab 0
** total: 6 cycles, 6 bytes
*/
loadRegFromConst (hc08_reg_x, zero);
;
}
- /* lslx/rola is only 2 cycles and bytes, so an unrolled loop is often */
+ /* lsrx/rora is only 2 cycles and bytes, so an unrolled loop is often */
/* the fastest and shortest. */
for (i=0;i<shCount;i++)
{
- rmwWithReg ("lsl", hc08_reg_x);
- rmwWithReg ("rol", hc08_reg_a);
+ rmwWithReg ("lsr", hc08_reg_x);
+ rmwWithReg ("ror", hc08_reg_a);
}
}
}
/* special case when cast remat */
- if (p_type == GPOINTER && OP_SYMBOL(left)->remat &&
+ if (p_type == GPOINTER && IS_SYMOP(left) && OP_SYMBOL(left)->remat &&
IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) {
left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
type = operandType (left);
emitcode ("and", "#0x%02x", mask);
emitcode ("ora", "1,s");
emitcode ("sta", ",x");
+ pullReg (hc08_reg_a);
}
hc08_freeReg (hc08_reg_a);
if (operandLitValue (IC_RIGHT (ic)) != 1)
return 0;
+ /* dbnz doesn't support extended mode */
+ if (isOperandInFarSpace (IC_RESULT (ic)))
+ return 0;
+
/* if the size of this greater than one then no
saving */
// if (getSize (operandType (IC_RESULT (ic))) > 1)
static void
genDummyRead (iCode * ic)
{
- operand *right;
+ operand *op;
int size, offset;
D(emitcode("; genDummyRead",""));
- right = IC_RIGHT (ic);
+ op = IC_RIGHT (ic);
+ if (op && IS_SYMOP (op))
+ {
- aopOp (right, ic, FALSE);
+ aopOp (op, ic, FALSE);
- /* bit variables done */
- /* general case */
- size = AOP_SIZE (right);
- offset = 0;
+ size = AOP_SIZE (op);
+ offset = 0;
- while (size--)
+ while (size--)
+ {
+ loadRegFromAop (hc08_reg_a, AOP (op), offset);
+ hc08_freeReg (hc08_reg_a);
+ offset++;
+ }
+
+ freeAsmop (op, NULL, ic, TRUE);
+ }
+ op = IC_LEFT (ic);
+ if (op && IS_SYMOP (op))
{
- loadRegFromAop (hc08_reg_a, AOP (right), offset);
- hc08_freeReg (hc08_reg_a);
- offset++;
- }
- freeAsmop (right, NULL, ic, TRUE);
+ aopOp (op, ic, FALSE);
+
+ size = AOP_SIZE (op);
+ offset = 0;
+
+ while (size--)
+ {
+ loadRegFromAop (hc08_reg_a, AOP (op), offset);
+ hc08_freeReg (hc08_reg_a);
+ offset++;
+ }
+
+ freeAsmop (op, NULL, ic, TRUE);
+ }
}
/*-----------------------------------------------------------------*/
case ENDCRITICAL:
genEndCritical (ic);
break;
+
+ case SWAP:
+ genSwap (ic);
+ break;
default:
ic = ic;