/*-------------------------------------------------------------------------
- SDCCgen51.c - source file for code generation for 8051
+ gen.c - source file for code generation for 8051
Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
and - Jean-Louis VERN.jlvern@writeme.com (1999)
Made everything static
-------------------------------------------------------------------------*/
-//#define D(x)
-#define D(x) x
+#define D(x) do if (options.verboseAsm) {x;} while(0)
#include <stdio.h>
#include <stdlib.h>
#include "common.h"
#include "SDCCpeeph.h"
#include "ralloc.h"
+#include "rtrack.h"
#include "gen.h"
+#include "dbuf_string.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 REG_WITH_INDEX mcs51_regWithIdx
+
+#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] == REG_WITH_INDEX(R0_IDX) || \
+ x->aopu.aop_reg[0] == REG_WITH_INDEX(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
+#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
{
_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);
+extern struct dbuf_s *codeOutBuf;
#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 MOVB(x) movb(x)
+
#define CLRC emitcode("clr","c")
#define SETC emitcode("setb","c")
/*-----------------------------------------------------------------*/
/* emitcode - writes the code into a file : for now it is simple */
/*-----------------------------------------------------------------*/
-static void
-emitcode (char *inst, const char *fmt,...)
+void
+emitcode (const char *inst, const char *fmt,...)
{
va_list ap;
- char lb[INITIAL_INLINEASM];
- char *lbp = lb;
+ struct dbuf_s dbuf;
+ const char *lbp, *lb;
+
+ dbuf_init (&dbuf, INITIAL_INLINEASM);
va_start (ap, fmt);
if (inst && *inst)
{
+ dbuf_append_str (&dbuf, inst);
+
if (fmt && *fmt)
- SNPRINTF (lb, sizeof(lb), "%s\t", inst);
- else
- SNPRINTF (lb, sizeof(lb), "%s", inst);
- tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb), fmt, ap);
+ {
+ dbuf_append_char (&dbuf, '\t');
+ dbuf_tvprintf (&dbuf, fmt, ap);
+ }
}
else
- tvsprintf (lb, sizeof(lb), fmt, ap);
+ {
+ dbuf_tvprintf (&dbuf, fmt, ap);
+ }
- while (isspace (*lbp))
+ lbp = lb = dbuf_c_str(&dbuf);
+
+ while (isspace ((unsigned char)*lbp))
+ {
lbp++;
+ }
+
+ if (lbp)
+ {
+ rtrackUpdate (lbp);
- if (lbp && *lbp)
lineCurr = (lineCurr ?
connectLine (lineCurr, newLineNode (lb)) :
(lineHead = newLineNode (lb)));
- lineCurr->isInline = _G.inLine;
- lineCurr->isDebug = _G.debugLine;
- lineCurr->ic = _G.current_iCode;
- lineCurr->isComment = (*lbp==';');
+
+ lineCurr->isInline = _G.inLine;
+ lineCurr->isDebug = _G.debugLine;
+ lineCurr->ic = _G.current_iCode;
+ lineCurr->isComment = (*lbp==';');
+ }
+
va_end (ap);
+
+ dbuf_destroy(&dbuf);
+}
+
+static void
+emitLabel (symbol *tlbl)
+{
+ emitcode ("", "%05d$:", tlbl->key + 100);
+ lineCurr->isLabel = 1;
}
/*-----------------------------------------------------------------*/
if (!strncmp(x, "a", 2) || !strncmp(x, "acc", 4))
return;
- emitcode("mov","a,%s", x);
+ /* if it is a literal mov try to get it cheaper */
+ if (*x == '#' &&
+ rtrackMoveALit(x))
+ return;
+
+ emitcode("mov", "a,%s", x);
+}
+
+/*-----------------------------------------------------------------*/
+/* movb - moves specified value into register b */
+/*-----------------------------------------------------------------*/
+static void
+movb (const char *x)
+{
+ /* do some early peephole optimization */
+ if (!strncmp(x, "b", 2))
+ return;
+
+ /* if it is a literal mov try to get it cheaper */
+ if (*x == '#')
+ {
+ emitcode("mov","b,%s", rtrackGetLit(x));
+ return;
+ }
+
+ emitcode("mov","b,%s", x);
}
/*-----------------------------------------------------------------*/
}
}
+/*-----------------------------------------------------------------*/
+/* pushReg - saves register */
+/*-----------------------------------------------------------------*/
+static bool
+pushReg (int index, bool bits_pushed)
+{
+ regs * reg = REG_WITH_INDEX (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 = REG_WITH_INDEX (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 */
/*-----------------------------------------------------------------*/
ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX);
(*aopp)->type = AOP_R0;
- return (*aopp)->aopu.aop_ptr = mcs51_regWithIdx (R0_IDX);
+ return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R0_IDX);
}
/* if no usage of r1 then return it */
ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX);
(*aopp)->type = AOP_R1;
- return (*aopp)->aopu.aop_ptr = mcs51_regWithIdx (R1_IDX);
+ return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R1_IDX);
}
/* now we know they both have usage */
/* push it if not already pushed */
if (ic->op == IPUSH)
{
- emitcode ("mov", "b,%s",
- mcs51_regWithIdx (R0_IDX)->dname);
+ MOVB (REG_WITH_INDEX (R0_IDX)->dname);
R0INB++;
}
else if (!_G.r0Pushed)
{
emitcode ("push", "%s",
- mcs51_regWithIdx (R0_IDX)->dname);
+ REG_WITH_INDEX (R0_IDX)->dname);
_G.r0Pushed++;
}
ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX);
(*aopp)->type = AOP_R0;
- return (*aopp)->aopu.aop_ptr = mcs51_regWithIdx (R0_IDX);
+ return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R0_IDX);
}
/* if r1 not used then */
/* push it if not already pushed */
if (ic->op == IPUSH)
{
- emitcode ("mov", "b,%s",
- mcs51_regWithIdx (R1_IDX)->dname);
+ MOVB (REG_WITH_INDEX (R1_IDX)->dname);
R1INB++;
}
else if (!_G.r1Pushed)
{
emitcode ("push", "%s",
- mcs51_regWithIdx (R1_IDX)->dname);
+ REG_WITH_INDEX (R1_IDX)->dname);
_G.r1Pushed++;
}
ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX);
(*aopp)->type = AOP_R1;
- return mcs51_regWithIdx (R1_IDX);
+ return REG_WITH_INDEX (R1_IDX);
}
+
endOfWorld:
/* I said end of world, but not quite end of world yet */
- if (result) {
- /* we can push it on the stack */
- (*aopp)->type = AOP_STK;
- return NULL;
- } else {
- /* in the case that result AND left AND right needs a pointer reg
- we can safely use the result's */
- if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R0_IDX)) {
+ /* if this is a result then we can push it on the stack */
+ if (result)
+ {
+ (*aopp)->type = AOP_STK;
+ return NULL;
+ }
+ /* in the case that result AND left AND right needs a pointer reg
+ we can safely use the result's */
+ if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R0_IDX))
+ {
(*aopp)->type = AOP_R0;
- return mcs51_regWithIdx (R0_IDX);
+ return REG_WITH_INDEX (R0_IDX);
}
- if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R1_IDX)) {
+ if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R1_IDX))
+ {
(*aopp)->type = AOP_R1;
- return mcs51_regWithIdx (R1_IDX);
+ return REG_WITH_INDEX (R1_IDX);
}
- }
/* now this is REALLY the end of the world */
werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
for (i=0; i<freeRegs->size; i++)
{
if (bitVectBitValue(freeRegs,i))
- tempRegs[offset++] = mcs51_regWithIdx(i);
+ tempRegs[offset++] = REG_WITH_INDEX(i);
if (offset>=size)
{
freeBitVect(freeRegs);
}
freeBitVect(freeRegs);
- return 1;
+ return 0;
}
aop = Safe_calloc (1, sizeof (asmop));
aop->type = type;
+ aop->allocated = 1;
return aop;
}
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);
{
asmop *aop;
memmap *space;
+ bool accuse = leftRightUseAcc (ic) || _G.accInUse;
wassertl (ic != NULL, "Got a null iCode");
wassertl (sym != NULL, "Got a null symbol");
/* 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 */
the pointer register */
if (aop->type != AOP_STK)
{
-
if (sym->onStack)
{
- char offset = ((sym->stack < 0) ?
- ((char) (sym->stack - _G.nRegsSaved)) :
- ((char) sym->stack)) & 0xff;
- if (_G.accInUse || leftRightUseAcc (ic))
- emitcode ("push", "acc");
+ signed char offset = ((sym->stack < 0) ?
+ ((signed char) (sym->stack - _G.nRegsSaved)) :
+ ((signed char) sym->stack)) & 0xff;
- if ((offset >= -3) && (offset <= 3))
+ if ((abs(offset) <= 3) ||
+ (accuse && (abs(offset) <= 7)))
{
emitcode ("mov", "%s,%s",
aop->aopu.aop_ptr->name, SYM_BP (sym));
}
else
{
+ if (accuse)
+ 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);
+ emitcode ("add", "a,#0x%02x", offset & 0xff);
+ emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name);
+ if (accuse)
+ emitcode ("pop", "acc");
}
- if (_G.accInUse || leftRightUseAcc (ic))
- emitcode ("pop", "acc");
}
else
- emitcode ("mov", "%s,#%s",
- aop->aopu.aop_ptr->name,
- sym->rname);
+ {
+ emitcode ("mov", "%s,#%s",
+ aop->aopu.aop_ptr->name,
+ sym->rname);
+ }
aop->paged = space->paged;
}
else
if (IS_FUNC (sym->type))
{
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->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname);
+ aop->size = getSize (sym->type);
return aop;
}
}
/*-----------------------------------------------------------------*/
-/* 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 = DCL_TYPE(from_type);
- if (ptr_type == IPOINTER) {
- // bug #481053
- ptr_type = POINTER;
- }
- 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 (val)
- sprintf (buffer, "(%s %c 0x%04x)",
- OP_SYMBOL (IC_LEFT (ic))->rname,
- val >= 0 ? '+' : '-',
- abs (val) & 0xffff);
+ {
+ SNPRINTF (buffer, sizeof(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);
+ {
+ strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
+ }
- aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1);
- strcpy (aop->aopu.aop_immd.aop_immd1, buffer);
+ aop->aopu.aop_immd.aop_immd1 = Safe_strdup(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);
- }
+ if (aop->aopu.aop_immd.from_cast_remat)
+ {
+ SNPRINTF (buffer, sizeof(buffer), "#0x%02x", ptr_type);
+ aop->aopu.aop_immd.aop_immd2 = Safe_strdup(buffer);
+ }
return aop;
}
return TRUE;
/* if they have the same rname */
- if (sym1->rname[0] && sym2->rname[0]
- && strcmp (sym1->rname, sym2->rname) == 0)
+ 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 */
return FALSE;
}
+/*-----------------------------------------------------------------*/
+/* sameByte - two asmops have the same address at given offsets */
+/*-----------------------------------------------------------------*/
+static bool
+sameByte (asmop * aop1, int off1, asmop * aop2, int off2)
+{
+ if (aop1 == aop2 && off1 == off2)
+ return TRUE;
+
+ 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 */
/*-----------------------------------------------------------------*/
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)
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 the type is a conditional */
if (sym->regType == REG_CND)
{
- aop = op->aop = sym->aop = newAsmop (AOP_CRY);
- aop->size = 0;
+ sym->aop = op->aop = aop = newAsmop (AOP_CRY);
+ aop->size = sym->ruonly ? 1 : 0;
return;
}
/* rematerialize it NOW */
if (sym->remat)
{
- sym->aop = op->aop = aop =
- aopForRemat (sym);
- aop->size = getSize (sym->type);
+ sym->aop = op->aop = aop = aopForRemat (sym);
+ aop->size = operandSize (op);
return;
}
if (sym->accuse)
{
int i;
- aop = op->aop = sym->aop = newAsmop (AOP_ACC);
+ sym->aop = op->aop = aop = newAsmop (AOP_ACC);
aop->size = getSize (sym->type);
for (i = 0; i < 2; i++)
aop->aopu.aop_str[i] = accUse[i];
{
unsigned i;
- aop = op->aop = sym->aop = newAsmop (AOP_STR);
+ sym->aop = op->aop = aop = newAsmop (AOP_STR);
aop->size = getSize (sym->type);
for (i = 0; i < fReturnSizeMCS51; i++)
aop->aopu.aop_str[i] = fReturn[i];
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);
+ 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;
}
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;
/*-----------------------------------------------------------------*/
/* freeAsmop - free up the asmop given to an operand */
-/*----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
static void
freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
{
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:
emitcode ("mov", "r1,b");
R1INB--;
}
- if (_G.r1Pushed)
+ else if (_G.r1Pushed)
{
if (pop)
{
emitcode ("pop", "ar1");
_G.r1Pushed--;
}
-
if (_G.r0Pushed)
{
emitcode ("pop", "ar0");
_G.r0Pushed--;
}
}
+ break;
}
dealloc:
if (!aop)
return;
- if (aop->freed)
+ if (!aop->allocated)
return;
switch (aop->type)
/* 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;
}
}
-/*-----------------------------------------------------------------*/
-/* aopGet - for fetching value of the aop */
-/*-----------------------------------------------------------------*/
+/*-------------------------------------------------------------------*/
+/* 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 */
emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name);
return (dname ? "acc" : "a");
}
- sprintf (s, "@%s", aop->aopu.aop_ptr->name);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ SNPRINTF (buffer, sizeof(buffer), "@%s", aop->aopu.aop_ptr->name);
+ return Safe_strdup(buffer);
case AOP_DPTR:
if (aop->code && aop->coff==0 && offset>=1) {
}
return (dname ? "acc" : "a");
-
case AOP_IMMD:
- if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) {
- sprintf(s,"%s",aop->aopu.aop_immd.aop_immd2);
- } else if (bit16)
- sprintf (s, "#%s", aop->aopu.aop_immd.aop_immd1);
+ if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1)))
+ {
+ SNPRINTF(buffer, sizeof(buffer),
+ "%s",aop->aopu.aop_immd.aop_immd2);
+ }
+ else if (bit16)
+ {
+ SNPRINTF(buffer, sizeof(buffer),
+ "#%s", aop->aopu.aop_immd.aop_immd1);
+ }
else if (offset)
- sprintf (s, "#(%s >> %d)",
- aop->aopu.aop_immd.aop_immd1,
- offset * 8);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "#(%s >> %d)",
+ aop->aopu.aop_immd.aop_immd1,
+ offset * 8);
+ }
else
- sprintf (s, "#%s",
- aop->aopu.aop_immd.aop_immd1);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "#%s",
+ aop->aopu.aop_immd.aop_immd1);
+ }
+ return Safe_strdup(buffer);
case AOP_DIR:
- if (offset)
- sprintf (s, "(%s + %d)",
- aop->aopu.aop_dir,
- offset);
+ if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset)
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s >> %d)",
+ aop->aopu.aop_dir, offset * 8);
+ }
+ else if (offset)
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s + %d)",
+ aop->aopu.aop_dir,
+ offset);
+ }
else
- sprintf (s, "%s", aop->aopu.aop_dir);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "%s",
+ aop->aopu.aop_dir);
+ }
+
+ return Safe_strdup(buffer);
case AOP_REG:
if (dname)
return aop->aopu.aop_reg[offset]->name;
case AOP_CRY:
- emitcode ("clr", "a");
emitcode ("mov", "c,%s", aop->aopu.aop_dir);
+ emitcode ("clr", "a");
emitcode ("rlc", "a");
return (dname ? "acc" : "a");
"aopget got unsupported aop->type");
exit (1);
}
+
+/*-----------------------------------------------------------------*/
+/* aopPutUsesAcc - indicates ahead of time whether aopPut() will */
+/* clobber the accumulator */
+/*-----------------------------------------------------------------*/
+static bool
+aopPutUsesAcc (operand * oper, const char *s, int offset)
+{
+ asmop * aop = AOP (oper);
+
+ if (offset > (aop->size - 1))
+ return FALSE;
+
+ switch (aop->type)
+ {
+ case AOP_DUMMY:
+ return TRUE;
+ case AOP_DIR:
+ return FALSE;
+ case AOP_REG:
+ wassert(strcmp(aop->aopu.aop_reg[offset]->name, "a"));
+ return FALSE;
+ case AOP_DPTR:
+ return TRUE;
+ case AOP_R0:
+ case AOP_R1:
+ return ((aop->paged) || (*s == '@'));
+ case AOP_STK:
+ return (*s == '@');
+ case AOP_CRY:
+ return (!aop->aopu.aop_dir || strcmp(s, aop->aopu.aop_dir));
+ case AOP_STR:
+ return FALSE;
+ case AOP_IMMD:
+ return FALSE;
+ case AOP_ACC:
+ return FALSE;
+ default:
+ /* Error case --- will have been caught already */
+ wassert(0);
+ return FALSE;
+ }
+}
+
/*-----------------------------------------------------------------*/
/* aopPut - puts a string for a aop and indicates if acc is in use */
/*-----------------------------------------------------------------*/
static bool
-aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
+aopPut (operand * result, const char *s, int offset)
{
- char *d = buffer;
+ 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_DIR:
- if (offset)
- sprintf (d, "(%s + %d)",
- aop->aopu.aop_dir, offset);
+ if (SPEC_SCLS (getSpec (operandType (result))) == S_SFR && offset)
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s >> %d)",
+ aop->aopu.aop_dir, offset * 8);
+ }
+ else if (offset)
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s + %d)",
+ aop->aopu.aop_dir, offset);
+ }
else
- sprintf (d, "%s", aop->aopu.aop_dir);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "%s",
+ aop->aopu.aop_dir);
+ }
- if (strcmp (d, s) ||
- bvolatile)
- emitcode ("mov", "%s,%s", d, s);
- if (!strcmp (d, "acc"))
+ if (strcmp (buffer, s) || bvolatile)
+ {
+ emitcode ("mov", "%s,%s", buffer, s);
+ }
+ if (!strcmp (buffer, "acc"))
+ {
accuse = TRUE;
-
+ }
break;
case AOP_REG:
strcmp (s, "r5") == 0 ||
strcmp (s, "r6") == 0 ||
strcmp (s, "r7") == 0)
- emitcode ("mov", "%s,%s",
- aop->aopu.aop_reg[offset]->dname, s);
+ {
+ emitcode ("mov", "%s,%s",
+ aop->aopu.aop_reg[offset]->dname, s);
+ }
else
- emitcode ("mov", "%s,%s",
- aop->aopu.aop_reg[offset]->name, s);
+ {
+ emitcode ("mov", "%s,%s",
+ aop->aopu.aop_reg[offset]->name, s);
+ }
}
break;
{
MOVA (s);
emitcode ("movx", "@%s,a", aop->aopu.aop_ptr->name);
-
}
else if (*s == '@')
{
strcmp (s, "r7") == 0)
{
char buffer[10];
- sprintf (buffer, "a%s", s);
+ SNPRINTF (buffer, sizeof(buffer), "a%s", s);
emitcode ("mov", "@%s,%s",
aop->aopu.aop_ptr->name, buffer);
}
else
- emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
-
+ {
+ emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
+ }
break;
case AOP_STK:
if (strcmp (s, "a") == 0)
- emitcode ("push", "acc");
- else
- if (*s=='@') {
+ {
+ emitcode ("push", "acc");
+ }
+ else if (*s=='@')
+ {
MOVA(s);
emitcode ("push", "acc");
- } else {
+ }
+ else if (strcmp (s, "r0") == 0 ||
+ strcmp (s, "r1") == 0 ||
+ strcmp (s, "r2") == 0 ||
+ strcmp (s, "r3") == 0 ||
+ strcmp (s, "r4") == 0 ||
+ strcmp (s, "r5") == 0 ||
+ strcmp (s, "r6") == 0 ||
+ strcmp (s, "r7") == 0)
+ {
+ char buffer[10];
+ SNPRINTF (buffer, sizeof(buffer), "a%s", s);
+ emitcode ("push", buffer);
+ }
+ else
+ {
emitcode ("push", s);
}
break;
case AOP_CRY:
- /* if not bit variable */
- if (!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"))
{
- /* inefficient: move carry into A and use jz/jnz */
- emitcode ("clr", "a");
- emitcode ("rlc", "a");
- accuse = TRUE;
+ MOVA (s);
+ /* set C, if a >= 1 */
+ emitcode ("add", "a,#0xff");
+ s = "c";
}
- else
+ // now source is zero, one or carry
+
+ /* if result no bit variable */
+ if (!d)
{
- 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);
+ if (!strcmp (s, "c"))
+ {
+ /* inefficient: move carry into A and use jz/jnz */
+ emitcode ("clr", "a");
+ emitcode ("rlc", "a");
+ accuse = TRUE;
+ }
else
{
MOVA (s);
- /* set C, if a >= 1 */
- emitcode ("add", "a,#0xff");
- emitcode ("mov", "%s,c", aop->aopu.aop_dir);
+ 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:
aop->coff = offset;
- if (strcmp (aop->aopu.aop_str[offset], s) ||
- bvolatile)
+ if (strcmp (aop->aopu.aop_str[offset], s) || bvolatile)
emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
break;
case AOP_ACC:
accuse = TRUE;
aop->coff = offset;
- if (!offset && (strcmp (s, "acc") == 0) &&
- !bvolatile)
+ if (!offset && (strcmp (s, "acc") == 0) && !bvolatile)
break;
- if (strcmp (aop->aopu.aop_str[offset], s) &&
- !bvolatile)
+ if (strcmp (aop->aopu.aop_str[offset], s) && !bvolatile)
emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
break;
static void
reAdjustPreg (asmop * aop)
{
- if ((aop->coff==0) || aop->size <= 1)
+ if ((aop->coff==0) || (aop->size <= 1))
return;
switch (aop->type)
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. */
+/* 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);
size = getDataSize (result);
if (size)
{
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
size--;
offset = 1;
/* unsigned or positive */
while (size--)
{
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
}
}
}
{
/* if the result is bit */
if (AOP_TYPE (result) == AOP_CRY)
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
- else
+ {
+ if (!IS_OP_RUONLY (result))
+ aopPut (result, "c", 0);
+ }
+ else if (AOP_TYPE (result) != AOP_DUMMY)
{
emitcode ("clr", "a");
emitcode ("rlc", "a");
while (!AccUsed && size--)
{
- AccUsed |= aopGetUsesAcc(AOP (oper), offset++);
+ AccUsed |= aopGetUsesAcc(oper, offset++);
}
size = AOP_SIZE (oper) - 1;
offset = 1;
- MOVA (aopGet (AOP (oper), 0, FALSE, FALSE));
+ MOVA (aopGet (oper, 0, FALSE, FALSE));
if (size && AccUsed && (AOP (oper)->type != AOP_ACC))
{
pushedB = pushB ();
emitcode("mov", "b,a");
while (--size)
{
- MOVA (aopGet (AOP (oper), offset++, FALSE, FALSE));
+ MOVA (aopGet (oper, offset++, FALSE, FALSE));
emitcode ("orl", "b,a");
}
- MOVA (aopGet (AOP (oper), offset++, FALSE, FALSE));
+ MOVA (aopGet (oper, offset++, FALSE, FALSE));
emitcode ("orl", "a,b");
popB (pushedB);
}
{
while (size--)
{
- emitcode ("orl", "a,%s", aopGet (AOP (oper), offset++, FALSE, FALSE));
+ emitcode ("orl", "a,%s",
+ aopGet (oper, offset++, FALSE, FALSE));
}
}
}
+/*-----------------------------------------------------------------*/
+/* toCarry - make boolean and move into carry */
+/*-----------------------------------------------------------------*/
+static void
+toCarry (operand * oper)
+{
+ /* if the operand is a literal then
+ we know what the value is */
+ if (AOP_TYPE (oper) == AOP_LIT)
+ {
+ if ((int) operandLitValue (oper))
+ SETC;
+ else
+ CLRC;
+ }
+ else if (AOP_TYPE (oper) == AOP_CRY)
+ {
+ emitcode ("mov", "c,%s", oper->aop->aopu.aop_dir);
+ }
+ else
+ {
+ /* or the operand into a */
+ toBoolean (oper);
+ /* set C, if a >= 1 */
+ emitcode ("add", "a,#0xff");
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* assignBit - assign operand to bit operand */
+/*-----------------------------------------------------------------*/
+static void
+assignBit (operand * result, operand * right)
+{
+ /* if the right side is a literal then
+ we know what the value is */
+ if (AOP_TYPE (right) == AOP_LIT)
+ {
+ if ((int) operandLitValue (right))
+ aopPut (result, one, 0);
+ else
+ aopPut (result, zero, 0);
+ }
+ else
+ {
+ toCarry (right);
+ aopPut (result, "c", 0);
+ }
+}
+
+
+/*-------------------------------------------------------------------*/
+/* xch_a_aopGet - for exchanging acc with value of the aop */
+/*-------------------------------------------------------------------*/
+static char *
+xch_a_aopGet (operand * oper, int offset, bool bit16, bool dname)
+{
+ char * l;
+
+ if (aopGetUsesAcc (oper, offset))
+ {
+ emitcode("mov", "b,a");
+ MOVA (aopGet (oper, offset, bit16, dname));
+ emitcode("xch", "a,b");
+ aopPut (oper, "a", offset);
+ emitcode("xch", "a,b");
+ l = "b";
+ }
+ else
+ {
+ l = aopGet (oper, offset, bit16, dname);
+ emitcode("xch", "a,%s", l);
+ }
+ return l;
+}
+
/*-----------------------------------------------------------------*/
/* genNot - generate code for ! operation */
{
symbol *tlbl;
- D(emitcode ("; genNot",""));
+ D (emitcode (";", "genNot"));
/* assign asmOps to operand & result */
aopOp (IC_LEFT (ic), ic, FALSE);
/* if in bit space then a special case */
if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
{
- emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
- emitcode ("cpl", "c");
- outBitC (IC_RESULT (ic));
+ /* if left==result then cpl bit */
+ if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
+ {
+ emitcode ("cpl", "%s", IC_LEFT (ic)->aop->aopu.aop_dir);
+ }
+ else
+ {
+ toCarry (IC_LEFT (ic));
+ emitcode ("cpl", "c");
+ outBitC (IC_RESULT (ic));
+ }
goto release;
}
toBoolean (IC_LEFT (ic));
+ /* set C, if a == 0 */
tlbl = newiTempLabel (NULL);
emitcode ("cjne", "a,#0x01,%05d$", tlbl->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
outBitC (IC_RESULT (ic));
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));
}
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);
- l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, FALSE);
+ 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)))
MOVA (l);
emitcode ("cjne", "a,#0xFF,%05d$", tlbl->key + 100);
}
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
outBitC (IC_RESULT(ic));
goto release;
}
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++);
}
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));
}
/*-----------------------------------------------------------------*/
int size, offset = 0;
char *l;
- D(emitcode ("; genUminusFloat",""));
+ D (emitcode (";", "genUminusFloat"));
/* for this we just copy and then flip the bit */
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (op), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (op, offset, FALSE, FALSE),
+ offset);
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);
}
/*-----------------------------------------------------------------*/
genUminus (iCode * ic)
{
int offset, size;
- sym_link *optype, *rtype;
-
+ sym_link *optype;
- D(emitcode ("; genUminus",""));
+ D (emitcode (";", "genUminus"));
/* assign asmops */
aopOp (IC_LEFT (ic), ic, FALSE);
}
optype = operandType (IC_LEFT (ic));
- rtype = operandType (IC_RESULT (ic));
/* if float then do float stuff */
if (IS_FLOAT (optype))
/* otherwise subtract from zero */
size = AOP_SIZE (IC_LEFT (ic));
offset = 0;
- //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)
SETC;
emitcode ("cpl", "a");
- emitcode ("addc", "a,#0");
+ emitcode ("addc", "a,#0x00");
}
else
{
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++);
}
/* 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++);
}
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));
}
/*-----------------------------------------------------------------*/
if (ic->regsSaved)
return;
if (IS_SYMOP(IC_LEFT(ic)) &&
- (IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type) ||
- IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT (ic)))))
+ (IFFUNC_CALLEESAVES (OP_SYMBOL (IC_LEFT (ic))->type) ||
+ IFFUNC_ISNAKED (OP_SYM_TYPE (IC_LEFT (ic)))))
return;
/* save the registers in use at this time but skip the
ic->regsSaved = 1;
if (options.useXstack)
{
+ bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+ int nBits = bitVectnBitsOn (rsavebits);
int count = bitVectnBitsOn (rsave);
+ 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));
+ }
+ freeBitVect (rsavebits);
+
if (count == 1)
{
- i = bitVectFirstBit (rsave);
- emitcode ("mov", "a,%s", mcs51_regWithIdx (i)->name);
+ regs * reg = REG_WITH_INDEX (bitVectFirstBit (rsave));
+ if (reg->type == REG_BIT)
+ {
+ 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 ("push", "%s", mcs51_regWithIdx (R0_IDX)->dname);
+ emitcode ("push", "%s", REG_WITH_INDEX (R0_IDX)->dname);
}
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++)
{
if (bitVectBitValue (rsave, i))
{
+ regs * reg = REG_WITH_INDEX (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", mcs51_regWithIdx (i)->name);
+ emitcode ("mov", "a,%s", reg->name);
}
emitcode ("movx", "@r0,a");
if (--count)
}
if (bitVectBitValue (rsave, R0_IDX))
{
- emitcode ("pop", "%s", mcs51_regWithIdx (R0_IDX)->dname);
+ emitcode ("pop", "%s", REG_WITH_INDEX (R0_IDX)->dname);
}
}
}
else
- for (i = 0; i < mcs51_nRegs; i++)
- {
- if (bitVectBitValue (rsave, i))
- emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
- }
+ {
+ bool bits_pushed = FALSE;
+ for (i = 0; i < mcs51_nRegs; i++)
+ {
+ if (bitVectBitValue (rsave, i))
+ {
+ bits_pushed = pushReg (i, bits_pushed);
+ }
+ }
+ }
+ freeBitVect (rsave);
}
/*-----------------------------------------------------------------*/
if (options.useXstack)
{
+ bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+ int nBits = bitVectnBitsOn (rsavebits);
int count = bitVectnBitsOn (rsave);
+ 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));
+ }
+ freeBitVect (rsavebits);
+
if (count == 1)
{
+ regs * reg = REG_WITH_INDEX (bitVectFirstBit (rsave));
emitcode ("mov", "r0,%s", spname);
emitcode ("dec", "r0");
emitcode ("movx", "a,@r0");
- i = bitVectFirstBit (rsave);
- emitcode ("mov", "%s,a", mcs51_regWithIdx (i)->name);
+ if (reg->type == REG_BIT)
+ {
+ emitcode ("mov", "%s,a", reg->base);
+ }
+ else
+ {
+ emitcode ("mov", "%s,a", reg->name);
+ }
emitcode ("dec", "%s", spname);
}
else if (count != 0)
{
if (bitVectBitValue (rsave, i))
{
+ regs * reg = REG_WITH_INDEX (i);
emitcode ("dec", "r0");
emitcode ("movx", "a,@r0");
- if (i != R0_IDX)
- emitcode ("mov", "%s,a", mcs51_regWithIdx (i)->name);
+ if (i == R0_IDX)
+ {
+ emitcode ("push", "acc");
+ }
+ else if (reg->type == REG_BIT)
+ {
+ emitcode ("mov", "%s,a", reg->base);
+ }
else
- emitcode ("push", "acc");
+ {
+ emitcode ("mov", "%s,a", reg->name);
+ }
}
}
emitcode ("mov", "%s,r0", spname);
}
}
else
- for (i = mcs51_nRegs; i >= 0; i--)
- {
- if (bitVectBitValue (rsave, i))
- emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
- }
+ {
+ bool bits_popped = FALSE;
+ for (i = mcs51_nRegs; i >= 0; i--)
+ {
+ if (bitVectBitValue (rsave, i))
+ {
+ bits_popped = popReg (i, bits_popped);
+ }
+ }
+ }
+ freeBitVect (rsave);
}
/*-----------------------------------------------------------------*/
-/* pushSide - */
+/* 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 (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);
}
}
+ freeAsmop (oper, NULL, ic, TRUE);
+}
+
/*-----------------------------------------------------------------*/
/* assignResultValue - also indicates if acc is in use afterwards */
/*-----------------------------------------------------------------*/
static bool
-assignResultValue (operand * oper)
+assignResultValue (operand * oper, operand * func)
{
int offset = 0;
int size = AOP_SIZE (oper);
bool accuse = FALSE;
+ bool pushedA = FALSE;
+ if (func && IS_BIT (OP_SYM_ETYPE (func)))
+ {
+ outBitC (oper);
+ return FALSE;
+ }
+
+ if ((size > 3) && aopPutUsesAcc (oper, fReturn[offset], offset))
+ {
+ emitcode ("push", "acc");
+ pushedA = TRUE;
+ }
while (size--)
{
- accuse |= aopPut (AOP (oper), fReturn[offset], offset, isOperandVolatile (oper, FALSE));
+ if ((offset == 3) && pushedA)
+ emitcode ("pop", "acc");
+ accuse |= aopPut (oper, fReturn[offset], offset);
offset++;
}
return accuse;
regs *r;
int size, offset = 0;
- D(emitcode ("; genXpush",""));
+ D (emitcode (";", "genXpush"));
aopOp (IC_LEFT (ic), ic, FALSE);
r = getFreePtr (ic, &aop, FALSE);
if (size == 1)
{
- MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
+ 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);
// 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--)
{
- MOVA (aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, FALSE));
+ MOVA (aopGet (IC_LEFT (ic), offset++, FALSE, FALSE));
emitcode ("movx", "@%s,a", r->name);
emitcode ("inc", "%s", r->name);
}
{
int size, offset = 0;
char *l;
+ char *prev = "";
- D(emitcode ("; genIpush",""));
+ D (emitcode (";", "genIpush"));
/* if this is not a parm push : ie. it is spill push
and spill push is always done on the local stack */
/* 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);
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"))
+ AOP_TYPE (IC_LEFT (ic)) != AOP_DIR)
{
- MOVA (l);
+ if (strcmp (l, prev) || *l == '@')
+ MOVA (l);
emitcode ("push", "acc");
}
else
+ {
emitcode ("push", "%s", l);
+ }
+ prev = l;
}
freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
{
int size, offset;
- D(emitcode ("; genIpop",""));
+ D (emitcode (";", "genIpop"));
/* if the temp was not pushed then */
if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
size = AOP_SIZE (IC_LEFT (ic));
offset = (size - 1);
while (size--)
- emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--,
- FALSE, TRUE));
+ {
+ emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--,
+ FALSE, TRUE));
+ }
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 */
/*-----------------------------------------------------------------*/
saveRBank (int bank, iCode * ic, bool pushPsw)
{
int i;
- int count = mcs51_nRegs + (pushPsw ? 1 : 0);
+ int count = 8 + (pushPsw ? 1 : 0);
asmop *aop = NULL;
regs *r = NULL;
if (options.useXstack)
{
if (!ic)
- {
+ {
/* Assume r0 is available for use. */
- r = mcs51_regWithIdx (R0_IDX);;
- }
+ r = REG_WITH_INDEX (R0_IDX);
+ }
else
- {
+ {
aop = newAsmop (0);
r = getFreePtr (ic, &aop, FALSE);
- }
+ }
// 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);
}
- for (i = 0; i < mcs51_nRegs; i++)
+ for (i = 0; i < 8; i++)
{
if (options.useXstack)
{
{
emitcode ("mov", "a,psw");
emitcode ("movx", "@%s,a", r->name);
-
}
else
{
}
if (ic)
- {
- ic->bankSaved = 1;
- }
+ {
+ ic->bankSaved = 1;
+ }
}
/*-----------------------------------------------------------------*/
if (!ic)
{
/* Assume r0 is available for use. */
- r = mcs51_regWithIdx (R0_IDX);;
+ r = REG_WITH_INDEX (R0_IDX);;
}
else
{
}
}
- for (i = (mcs51_nRegs - 1); i >= 0; i--)
+ for (i = 7; i >= 0; i--)
{
if (options.useXstack)
{
/*-----------------------------------------------------------------*/
static void genSend(set *sendSet)
{
- iCode *sic;
- int rb1_count = 0 ;
+ iCode *sic;
+ int bit_count = 0;
+
+ /* first we do all bit parameters */
+ for (sic = setFirstItem (sendSet); sic;
+ sic = setNextItem (sendSet))
+ {
+ if (sic->argreg > 12)
+ {
+ int bit = sic->argreg-13;
+
+ aopOp (IC_LEFT (sic), sic, FALSE);
- for (sic = setFirstItem (sendSet); sic;
- sic = setNextItem (sendSet)) {
+ /* 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
+ {
+ /* we need to or */
+ toCarry (IC_LEFT (sic));
+ emitcode ("mov", "b[%d],c", bit);
+ }
+ bit_count++;
+ BitBankUsed = 1;
+
+ freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+ }
+ }
+
+ if (options.useXstack || bit_count)
+ {
+ saveRegisters (setFirstItem (sendSet));
+ }
+
+ if (bit_count)
+ {
+ emitcode ("mov", "bits,b");
+ }
+
+ /* then we do all other parameters */
+ for (sic = setFirstItem (sendSet); sic;
+ sic = setNextItem (sendSet))
+ {
+ if (sic->argreg <= 12)
+ {
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
+ {
+ 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);
+ }
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* selectRegBank - emit code to select the register bank */
+/*-----------------------------------------------------------------*/
+static void
+selectRegBank (short bank, bool keepFlags)
+{
+ /* if f.e. result is in carry */
+ if (keepFlags)
+ {
+ emitcode ("anl", "psw,#0xE7");
+ if (bank)
+ emitcode ("orl", "psw,#0x%02x", (bank << 3) & 0xff);
+ }
+ else
+ {
+ emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0xff);
}
}
genCall (iCode * ic)
{
sym_link *dtype;
+ sym_link *etype;
// bool restoreBank = FALSE;
bool swapBanks = FALSE;
bool accuse = FALSE;
bool accPushed = FALSE;
+ bool resultInF0 = FALSE;
+ bool assignResultGenerated = FALSE;
- D(emitcode("; genCall",""));
+ D (emitcode (";", "genCall"));
dtype = operandType (IC_LEFT (ic));
+ etype = getSpec(dtype);
/* if send set is not empty then assign */
if (_G.sendSet)
{
} else {
genSend(_G.sendSet);
}
-
_G.sendSet = NULL;
}
/* if we are calling a not _naked function that is not using
the same register bank then we need to save the
destination registers on the stack */
- dtype = operandType (IC_LEFT (ic));
if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
(FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
!IFFUNC_ISISR (dtype))
- {
+ {
swapBanks = TRUE;
- }
+ }
/* if caller saves & we have not saved then */
if (!ic->regsSaved)
saveRegisters (ic);
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 ("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);
- }
+ {
+ selectRegBank (FUNC_REGBANK(currFunc->type), IS_BIT (etype));
+ }
/* 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--;
- accuse = assignResultValue (IC_RESULT (ic));
+ accuse = assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
+ assignResultGenerated = TRUE;
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
}
emitcode ("push", "acc");
accPushed = TRUE;
}
+ if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) &&
+ IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) &&
+ !assignResultGenerated)
+ {
+ emitcode ("mov", "F0,c");
+ resultInF0 = TRUE;
+ }
emitcode ("mov", "a,%s", spname);
emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
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))
{
if (accuse && !accPushed && options.useXstack)
// if (restoreBank)
// unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
+ if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && !assignResultGenerated)
+ {
+ 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");
}
/*-----------------------------------------------------------------*/
-/* -10l - generates a call by pointer statement */
+/* genPcall - generates a call by pointer statement */
/*-----------------------------------------------------------------*/
static void
genPcall (iCode * ic)
{
sym_link *dtype;
+ sym_link *etype;
symbol *rlbl = newiTempLabel (NULL);
// bool restoreBank=FALSE;
bool swapBanks = FALSE;
+ bool resultInF0 = FALSE;
- D(emitcode("; genPCall",""));
+ D (emitcode (";", "genPcall"));
+ dtype = operandType (IC_LEFT (ic))->next;
+ etype = getSpec(dtype);
/* if caller saves & we have not saved then */
if (!ic->regsSaved)
saveRegisters (ic);
/* if we are calling a not _naked function that is not using
the same register bank then we need to save the
destination registers on the stack */
- dtype = operandType (IC_LEFT (ic))->next;
- if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
+ if (currFunc && dtype && !IFFUNC_ISNAKED (dtype) &&
(FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
!IFFUNC_ISISR (dtype))
- {
+ {
// saveRBank (FUNC_REGBANK (dtype), ic, TRUE);
// restoreBank=TRUE;
swapBanks = TRUE;
// 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");
+ if (IS_LITERAL (etype))
+ {
+ /* if send set is not empty then assign */
+ if (_G.sendSet)
+ {
+ genSend(reverseSet(_G.sendSet));
+ _G.sendSet = NULL;
+ }
- /* now push the calling address */
- aopOp (IC_LEFT (ic), ic, FALSE);
+ if (swapBanks)
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK (dtype)) << 3) & 0xff);
+ }
+
+ 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);
+
+ 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)
+ {
+ /* what if aopGet needs r0 or r1 ??? */
+ 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));
+ }
+
+ 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);
+ }
- pushSide (IC_LEFT (ic), FPTRSIZE);
+ /* make the call */
+ emitcode ("lcall", "__sdcc_banked_call");
+ }
+ }
+ else if (_G.sendSet)
+ {
+ /* 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 function address */
+ pushSide (IC_LEFT (ic), FPTRSIZE, ic);
+
+ /* if send set is not empty then assign */
+ if (_G.sendSet)
+ {
+ genSend(reverseSet(_G.sendSet));
+ _G.sendSet = NULL;
+ }
- freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+ if (swapBanks)
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK (dtype)) << 3) & 0xff);
+ }
- /* if send set is not empty the assign */
- if (_G.sendSet)
- {
- genSend(reverseSet(_G.sendSet));
- _G.sendSet = NULL;
- }
+ /* make the call */
+ emitcode ("ret", "");
+ emitLabel (rlbl);
+ }
+ else /* the send set is empty */
+ {
+ char *l;
+ /* now get the calling address into dptr */
+ aopOp (IC_LEFT (ic), ic, FALSE);
- if (swapBanks)
- {
- emitcode ("mov", "psw,#0x%02x",
- ((FUNC_REGBANK(dtype)) << 3) & 0xff);
- }
+ l = aopGet (IC_LEFT (ic), 0, FALSE, FALSE);
+ if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
+ {
+ emitcode ("mov", "r0,%s", l);
+ l = aopGet (IC_LEFT (ic), 1, FALSE, FALSE);
+ emitcode ("mov", "dph,%s", l);
+ emitcode ("mov", "dpl,r0");
+ }
+ else
+ {
+ emitcode ("mov", "dpl,%s", l);
+ l = aopGet (IC_LEFT (ic), 1, FALSE, FALSE);
+ emitcode ("mov", "dph,%s", l);
+ }
- /* make the call */
- emitcode ("ret", "");
- emitcode ("", "%05d$:", (rlbl->key + 100));
+ freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+ if (swapBanks)
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK (dtype)) << 3) & 0xff);
+ }
+ /* make the call */
+ emitcode ("lcall", "__sdcc_call_dptr");
+ }
+ }
if (swapBanks)
- {
- emitcode ("mov", "psw,#0x%02x",
- ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
- }
+ {
+ selectRegBank (FUNC_REGBANK (currFunc->type), IS_BIT (etype));
+ }
/* 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))->spildir)) ||
IS_TRUE_SYMOP (IC_RESULT (ic)))
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);
}
- /* adjust the stack for parameters if
- required */
+ /* adjust the stack for parameters if required */
if (ic->parmBytes)
{
int i;
if (ic->parmBytes > 3)
{
+ 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);
else
for (i = 0; i < ic->parmBytes; i++)
emitcode ("dec", "%s", spname);
-
}
// /* if register bank was saved then unsave them */
// if (restoreBank)
// unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
- /* if we hade saved some registers then
- unsave them */
- if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
+ /* if we had saved some registers then unsave them */
+ if (ic->regsSaved && !IFFUNC_CALLEESAVES (dtype))
unsaveRegisters (ic);
+
+ 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);
+ }
}
/*-----------------------------------------------------------------*/
return 0;
}
-#if defined(__BORLANDC__) || defined(_MSC_VER)
-#define STRCASECMP stricmp
-#else
-#define STRCASECMP strcasecmp
-#endif
-
/*-----------------------------------------------------------------*/
/* inExcludeList - return 1 if the string is in exclude Reg list */
/*-----------------------------------------------------------------*/
emitcode (";", "-----------------------------------------");
emitcode ("", "%s:", sym->rname);
+ lineCurr->isLabel = 1;
ftype = operandType (IC_LEFT (ic));
_G.currentFunc = sym;
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);
+ }
}
}
save acc, b, dpl, dph */
if (IFFUNC_ISISR (sym->type))
{
+ bitVect *rsavebits;
+
+ rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), sym->regsUsed);
+ if (IFFUNC_HASFCALL(sym->type) || !bitVectIsZero (rsavebits))
+ {
+ emitcode ("push", "bits");
+ BitBankUsed = 1;
+ }
+ freeBitVect (rsavebits);
if (!inExcludeList ("acc"))
emitcode ("push", "acc");
registers :-) */
if (!FUNC_REGBANK (sym->type))
{
+ int i;
/* if this function does not call any other
function then we can be economical and
save only those registers that are used */
if (!IFFUNC_HASFCALL(sym->type))
{
- int i;
-
/* if any registers used */
if (sym->regsUsed)
{
for (i = 0; i < sym->regsUsed->size; i++)
{
if (bitVectBitValue (sym->regsUsed, i))
- emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
+ pushReg (i, TRUE);
}
}
}
else
{
-
/* this function has a function call. We cannot
- determines register usage so we will have to push the
+ determine register usage so we will have to push the
entire bank */
- saveRBank (0, ic, FALSE);
- if (options.parms_in_bank1) {
- int i;
- 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
+ else
{
/* This ISR uses a non-zero bank.
*
/* 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 (fReentrant)
{
if (options.useXstack)
{
- 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");
- emitcode ("push", "_bp"); /* save the callers stack */
- emitcode ("mov", "_bp,sp");
+ 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 */
- emitcode ("mov", "_bp,sp");
+ if (sym->stack || FUNC_HASSTACKPARM(sym->type))
+ {
+ /* set up the stack */
+ emitcode ("push", "_bp"); /* save the callers stack */
+ emitcode ("mov", "_bp,sp");
+ }
}
}
int ofs;
_G.current_iCode = ric;
- D(emitcode ("; genReceive",""));
+ D(emitcode (";", "genReceive"));
for (ofs=0; ofs < sym->recvSize; ofs++)
{
if (!strcmp (fReturn[ofs], "a"))
int ofs;
_G.current_iCode = ric;
- D(emitcode ("; genReceive",""));
+ D(emitcode (";", "genReceive"));
for (ofs=0; ofs < sym->recvSize; ofs++)
{
emitcode ("mov", "%s,%s", rsym->regs[ofs]->name, fReturn[ofs]);
/* if it's a callee-saves function we need a saved register */
if (calleesaves_saved_register >= 0)
{
- emitcode ("mov", "%s,a", mcs51_regWithIdx (calleesaves_saved_register)->dname);
+ emitcode ("mov", "%s,a", REG_WITH_INDEX (calleesaves_saved_register)->dname);
emitcode ("mov", "a,sp");
emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
emitcode ("mov", "sp,a");
- emitcode ("mov", "a,%s", mcs51_regWithIdx (calleesaves_saved_register)->dname);
+ emitcode ("mov", "a,%s", REG_WITH_INDEX (calleesaves_saved_register)->dname);
}
else
/* do it the hard way */
if (i > 3 && accIsFree)
{
emitcode ("mov", "a,_spx");
- emitcode ("add", "a,#0x%02x", i);
+ emitcode ("add", "a,#0x%02x", i & 0xff);
emitcode ("mov", "_spx,a");
}
else if (i > 5)
{
emitcode ("push", "acc");
emitcode ("mov", "a,_spx");
- emitcode ("add", "a,#0x%02x", i);
+ emitcode ("add", "a,#0x%02x", i & 0xff);
emitcode ("mov", "_spx,a");
emitcode ("pop", "acc");
}
emitcode ("setb", "c");
emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
emitcode ("clr", "c");
- emitcode ("", "%05d$:", (tlbl->key + 100));
+ emitLabel (tlbl);
emitcode ("push", "psw"); /* save old ea via c in psw */
}
}
if (IFFUNC_ISCRITICAL (sym->type))
{
- emitcode ("pop", "psw"); /* restore ea via c in psw */
- emitcode ("mov", "ea,c");
+ 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))
{
- emitcode ("mov", "sp,_bp");
- emitcode ("pop", "_bp");
-
if (options.useXstack)
{
- 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)
+ 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 if (sym->stack || FUNC_HASSTACKPARM(sym->type))
+ {
+ if (sym->stack)
+ emitcode ("mov", "sp,_bp");
+ emitcode ("pop", "_bp");
}
}
/* 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
if (IFFUNC_ISISR (sym->type))
{
+ bitVect *rsavebits;
/* now we need to restore the registers */
/* if this isr has no bank i.e. is going to
registers :-) */
if (!FUNC_REGBANK (sym->type))
{
+ int i;
/* if this function does not call any other
function then we can be economical and
save only those registers that are used */
if (!IFFUNC_HASFCALL(sym->type))
{
- int i;
-
/* if any registers used */
if (sym->regsUsed)
{
for (i = sym->regsUsed->size; i >= 0; i--)
{
if (bitVectBitValue (sym->regsUsed, i))
- emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
+ popReg (i, TRUE);
}
}
}
else
{
- if (options.parms_in_bank1) {
- int i;
- 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 cannot
- determines register usage so we will have to pop the
+ }
+ }
+ /* 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 (!inExcludeList ("acc"))
emitcode ("pop", "acc");
+ rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), sym->regsUsed);
+ if (IFFUNC_HASFCALL(sym->type) || !bitVectIsZero (rsavebits))
+ emitcode ("pop", "bits");
+ freeBitVect (rsavebits);
+
/* if debug then send end of function */
if (options.debug && currFunc)
{
{
if (bitVectBitValue (sym->regsUsed, i) ||
(mcs51_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
- emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
+ emitcode ("pop", "%s", REG_WITH_INDEX (i)->dname);
}
}
else if (mcs51_ptrRegReq)
{
- emitcode ("pop", "%s", mcs51_regWithIdx (R1_IDX)->dname);
- emitcode ("pop", "%s", mcs51_regWithIdx (R0_IDX)->dname);
+ emitcode ("pop", "%s", REG_WITH_INDEX (R1_IDX)->dname);
+ emitcode ("pop", "%s", REG_WITH_INDEX (R0_IDX)->dname);
}
}
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)
for (idx = 0; idx < regsUnneeded->size; idx++)
if (bitVectBitValue (regsUnneeded, idx))
- emitcode ("", ";\teliminated unneeded push/pop %s", mcs51_regWithIdx (idx)->dname);
+ emitcode (";", "eliminated unneeded push/pop %s", REG_WITH_INDEX (idx)->dname);
freeBitVect (regsUnneeded);
freeBitVect (regsUsed);
{
int size, offset = 0, pushed = 0;
- D(emitcode ("; genRet",""));
+ D (emitcode (";", "genRet"));
/* if we have no return value then
just generate the "ret" */
aopOp (IC_LEFT (ic), ic, FALSE);
size = AOP_SIZE (IC_LEFT (ic));
- while (size--)
+ if (IS_BIT(_G.currentFunc->etype))
{
- char *l;
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
- {
- /* #NOCHANGE */
- l = aopGet (AOP (IC_LEFT (ic)), offset++,
- FALSE, TRUE);
- emitcode ("push", "%s", l);
- pushed++;
- }
- else
+ if (!IS_OP_RUONLY (IC_LEFT (ic)))
+ toCarry (IC_LEFT (ic));
+ }
+ else
+ {
+ while (size--)
{
- l = aopGet (AOP (IC_LEFT (ic)), offset,
- FALSE, FALSE);
- if (strcmp (fReturn[offset], l))
- emitcode ("mov", "%s,%s", fReturn[offset++], l);
+ char *l;
+ if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
+ {
+ /* #NOCHANGE */
+ l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE);
+ emitcode ("push", "%s", l);
+ pushed++;
+ }
+ else
+ {
+ l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
+ if (strcmp (fReturn[offset], l))
+ emitcode ("mov", "%s,%s", fReturn[offset++], l);
+ }
}
- }
- if (pushed)
- {
while (pushed)
{
pushed--;
if (IC_LABEL (ic) == entryLabel)
return;
- emitcode ("", "%05d$:", (IC_LABEL (ic)->key + 100));
+ emitLabel (IC_LABEL (ic));
}
/*-----------------------------------------------------------------*/
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) ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
- D(emitcode ("; genPlusIncr",""));
+ 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 ) &&
+ 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))) &&
+ !isOperandVolatile (IC_RESULT (ic), FALSE) &&
(size > 1) &&
(icount == 1))
{
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
&& (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0
&& labelRange <= 10)
{
- emitcode (";", "tail increment optimized");
+ D (emitcode (";", "tail increment optimized (range %d)", labelRange));
tlbl = IC_LABEL (ic->next);
emitTlbl = 0;
}
tlbl = newiTempLabel (NULL);
emitTlbl = 1;
}
- emitcode ("inc", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE),
- tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("inc", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
- tlbl->key + 100);
+ {
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
+ }
- emitcode ("inc", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
- tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
+
+ l = aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE);
+ emitcode ("inc", "%s", l);
}
if (emitTlbl)
{
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
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);
+ aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1);
+ 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)
same */
if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
{
-
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);
}
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 (icount == 1)
+ {
+ MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
+ emitcode ("inc", "a");
+ aopPut (IC_RESULT (ic), "a", 0);
+ return TRUE;
+ }
+
return FALSE;
}
/* if the result is a bit */
if (AOP_TYPE (result) == AOP_CRY)
{
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
}
else
{
emitcode ("jz", "%05d$", tlbl->key + 100);
emitcode ("mov", "a,%s", one);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
outAcc (result);
}
}
static void
genPlusBits (iCode * ic)
{
- D(emitcode ("; genPlusBits",""));
+ D (emitcode (";", "genPlusBits"));
+ emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
symbol *lbl = newiTempLabel (NULL);
- emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
emitcode ("jnb", "%s,%05d$", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
outBitC (IC_RESULT (ic));
}
else
{
emitcode ("clr", "a");
- emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
emitcode ("rlc", "a");
emitcode ("mov", "c,%s", AOP (IC_RIGHT (ic))->aopu.aop_dir);
- emitcode ("addc", "a,#0x00");
+ emitcode ("addc", "a,%s", zero);
outAcc (IC_RESULT (ic));
}
}
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),
- 2,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic),
+ aopGet (IC_LEFT (ic)), 2, FALSE, FALSE),
+ 2);
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),
- 2,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic),
+ aopGet (IC_RIGHT (ic)), 2, FALSE, FALSE),
+ 2);
if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
AOP_SIZE (IC_LEFT (ic)) < 3 &&
!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);
}
}
#else
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 (AOP (IC_RESULT (ic)),
- aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE),
- GPTRSIZE - 1,
- isOperandVolatile (IC_RESULT (ic), FALSE));
- }
+ char buffer[10];
- if (opIsGptr (IC_RESULT (ic)) &&
- 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),
- GPTRSIZE - 1,
- isOperandVolatile (IC_RESULT (ic), FALSE));
- }
+ 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];
- sprintf (buffer, "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
- aopPut (AOP (IC_RESULT (ic)), buffer, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+ 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
int size, offset = 0;
int skip_bytes = 0;
char *add = "add";
- asmop *leftOp, *rightOp;
+ bool swappedLR = FALSE;
+ operand *leftOp, *rightOp;
operand * op;
- /* special cases :- */
+ D (emitcode (";", "genPlus"));
- D(emitcode ("; genPlus",""));
+ /* special cases :- */
aopOp (IC_LEFT (ic), ic, FALSE);
aopOp (IC_RIGHT (ic), ic, FALSE);
operand *t = IC_RIGHT (ic);
IC_RIGHT (ic) = IC_LEFT (ic);
IC_LEFT (ic) = t;
+ swappedLR = TRUE;
}
/* if both left & right are in bit
/* 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));
}
size = getDataSize (IC_RESULT (ic));
while (size--)
{
- MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- emitcode ("addc", "a,#00");
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE));
+ emitcode ("addc", "a,%s", zero);
+ aopPut (IC_RESULT (ic), "a", offset++);
}
}
goto release;
goto release;
size = getDataSize (IC_RESULT (ic));
- leftOp = AOP(IC_LEFT(ic));
- rightOp = AOP(IC_RIGHT(ic));
- op=IC_LEFT(ic);
+ leftOp = IC_LEFT(ic);
+ rightOp = IC_RIGHT(ic);
+ op = IC_LEFT(ic);
/* if this is an add for an array access
at a 256 byte boundary */
&& (SPEC_ADDR (OP_SYM_ETYPE (op)) & 0xff) == 0
)
{
- D(emitcode ("; genPlus aligned array",""));
- aopPut (AOP (IC_RESULT (ic)),
+ D(emitcode (";", "genPlus aligned array"));
+ aopPut (IC_RESULT (ic),
aopGet (rightOp, 0, FALSE, FALSE),
- 0,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ 0);
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));
+ 1);
}
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);
}
goto release;
}
/* 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 (skip_bytes)
- D(emitcode ("; genPlus shortcut",""));
+ D(emitcode (";", "genPlus shortcut"));
}
while (size--)
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);
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));
+ offset);
}
}
offset++;
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));
+ }
}
/*-----------------------------------------------------------------*/
-/* genMinusDec :- does subtraction with deccrement if possible */
+/* genMinusDec :- does subtraction with decrement if possible */
/*-----------------------------------------------------------------*/
static bool
genMinusDec (iCode * ic)
/* 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",""));
+ D (emitcode (";", "genMinusDec"));
/* if decrement >=16 bits in register or direct space */
- if ((AOP_TYPE(IC_LEFT(ic)) == AOP_REG || AOP_TYPE(IC_LEFT(ic)) == AOP_DIR) &&
+ 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))) &&
(size > 1) &&
(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
&& (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0
&& labelRange <= 10)
{
- emitcode (";", "tail decrement optimized");
+ D (emitcode (";", "tail decrement optimized (range %d)", labelRange));
tlbl = IC_LABEL (ic->next);
emitTlbl = 0;
}
emitTlbl = 1;
}
- emitcode ("dec", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
}
- emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
+ l = aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE);
+ emitcode ("dec", "%s", l);
}
if (emitTlbl)
{
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
return TRUE;
}
same */
if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
{
+ char *l;
+
+ if (aopGetUsesAcc (IC_LEFT (ic), 0))
+ {
+ MOVA (aopGet (IC_RESULT (ic), 0, FALSE, FALSE));
+ l = "a";
+ }
+ else
+ {
+ l = aopGet (IC_RESULT (ic), 0, FALSE, FALSE);
+ }
while (icount--)
- emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
+ {
+ emitcode ("dec", "%s", l);
+ }
+
+ if (AOP_NEEDSACC (IC_RESULT (ic)))
+ aopPut (IC_RESULT (ic), "a", 0);
+
+ return TRUE;
+ }
+ if (icount == 1)
+ {
+ MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
+ emitcode ("dec", "a");
+ aopPut (IC_RESULT (ic), "a", 0);
return TRUE;
}
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ {
+ aopPut (result, "a", offset++);
+ }
}
else
- while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ {
+ while (size--)
+ {
+ aopPut (result, zero, offset++);
+ }
+ }
}
}
{
symbol *lbl = newiTempLabel (NULL);
- D(emitcode ("; genMinusBits",""));
+ D (emitcode (";", "genMinusBits"));
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
emitcode ("jnb", "%s,%05d$", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
outBitC (IC_RESULT (ic));
}
else
emitcode ("subb", "a,acc");
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));
+ emitLabel (lbl);
+ aopPut (IC_RESULT (ic), "a", 0);
addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
}
}
{
int size, offset = 0;
- D(emitcode ("; genMinus",""));
+ D (emitcode (";", "genMinus"));
aopOp (IC_LEFT (ic), ic, FALSE);
aopOp (IC_RIGHT (ic), ic, FALSE);
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 = ulFromVal (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) {
- emitcode ("dec", "a");
- } else {
- emitcode ("add", "a,#0x%02x",
- (unsigned int) (lit & 0x0FFL));
+ 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 if (!useCarry)
+ {
+ /* first add without previous c */
+ emitcode ("add", "a,#0x%02x",
+ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+ useCarry = TRUE;
+ }
+ else
+ {
+ emitcode ("addc", "a,#0x%02x",
+ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+ }
+ aopPut (IC_RESULT (ic), "a", offset++);
+ }
+ else
+ {
+ /* no need to add zeroes */
+ if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
+ {
+ aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), offset, FALSE, FALSE),
+ offset);
+ }
+ offset++;
}
- } else {
- emitcode ("addc", "a,#0x%02x",
- (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
- }
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
}
}
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--)
{
emitcode ("subb", "a,b");
popB (pushedB);
} else {
+ /* reverse subtraction with 2's complement */
+ if (offset == 0)
+ emitcode( "setb", "c");
+ else
+ emitcode( "cpl", "c");
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");
+ if (size) /* skip if last byte */
+ emitcode( "cpl", "c");
}
} else {
MOVA (aopGet (leftOp, offset, FALSE, FALSE));
aopGet(rightOp, offset, FALSE, TRUE));
}
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++);
}
}
-
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));
}
operand * right,
operand * result)
{
- D(emitcode ("; genMultbits",""));
+ D (emitcode (";", "genMultbits"));
emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
bool runtimeSign, compiletimeSign;
bool lUnsigned, rUnsigned, pushedB;
- D(emitcode ("; genMultOneByte",""));
+ D (emitcode (";", "genMultOneByte"));
if (size < 1 || size > 2)
{
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));
+ MOVB (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);
if (size == 2)
- aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 1);
popB (pushedB);
return;
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);
else /* ! literal */
{
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 */
emitcode ("cpl", "a"); /* 2's complement */
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
emitcode ("mov", "b,a");
}
}
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 /* ! literal */
{
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
if (!lUnsigned)
{
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");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ 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");
}
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
}
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
if (size == 2)
- aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 1);
popB (pushedB);
}
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
- D(emitcode ("; genMult",""));
+ D (emitcode (";", "genMult"));
- /* assign the amsops */
+ /* assign the asmops */
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
aopOp (result, ic, TRUE);
char *l;
bool pushedB;
- D(emitcode ("; genDivbits",""));
+ 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);
popB (pushedB);
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0);
}
/*-----------------------------------------------------------------*/
{
bool lUnsigned, rUnsigned, pushedB;
bool runtimeSign, compiletimeSign;
+ bool accuse = FALSE;
+ bool pushedA = FALSE;
symbol *lbl;
int size, offset;
- D(emitcode ("; genDivOneByte",""));
+ D(emitcode (";", "genDivOneByte"));
/* Why is it necessary that genDivOneByte() can return an int result?
Have a look at:
if (lUnsigned && rUnsigned)
{
/* unsigned is easy */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVB (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);
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
popB (pushedB);
return;
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);
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 */
emitcode ("cpl", "a"); /* 2's complement */
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
emitcode ("mov", "b,a");
}
}
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 /* ! literal */
{
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
if (!lUnsigned)
{
emitcode ("cpl", "F0"); /* complement sign flag */
emitcode ("cpl", "a"); /* 2's complement */
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
}
}
emitcode ("jnb", "F0,%05d$", (lbl->key + 100));
emitcode ("cpl", "a"); /* lsb 2's complement */
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ accuse = aopPut (result, "a", 0);
if (size > 0)
{
/* msb is 0x00 or 0xff depending on the sign */
if (runtimeSign)
{
+ if (accuse)
+ {
+ emitcode ("push", "acc");
+ pushedA = TRUE;
+ }
emitcode ("mov", "c,F0");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
else /* compiletimeSign */
- while (size--)
- aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+ {
+ if (aopPutUsesAcc (result, "#0xff", offset))
+ {
+ emitcode ("push", "acc");
+ pushedA = TRUE;
+ }
+ while (size--)
+ aopPut (result, "#0xff", offset++);
+ }
}
}
else
{
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
}
+ if (pushedA)
+ emitcode ("pop", "acc");
popB (pushedB);
}
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
- D(emitcode ("; genDiv",""));
+ D (emitcode (";", "genDiv"));
- /* assign the amsops */
+ /* assign the asmops */
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
aopOp (result, ic, 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);
}
/*-----------------------------------------------------------------*/
char *l;
bool pushedB;
- D(emitcode ("; genModbits",""));
+ 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);
popB (pushedB);
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0);
}
/*-----------------------------------------------------------------*/
symbol *lbl;
int size, offset;
- D(emitcode ("; genModOneByte",""));
+ D (emitcode (";", "genModOneByte"));
size = AOP_SIZE (result) - 1;
offset = 1;
/* because iCode should have been changed to genAnd */
/* see file "SDCCopt.c", function "convertToFcall()" */
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
emitcode ("mov", "c,acc.7");
emitcode ("anl", "a,#0x%02x", val - 1);
lbl = newiTempLabel (NULL);
int size2 = size;
int offs2 = offset;
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
while (size2--)
- aopPut (AOP (result), "#0xff", offs2++, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xff", offs2++);
lbl2 = newiTempLabel (NULL);
emitcode ("sjmp", "%05d$", (lbl2->key + 100));
}
- emitcode ("", "%05d$:", (lbl->key + 100));
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ emitLabel (lbl);
+ aopPut (result, "a", 0);
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
if (lbl2)
{
- emitcode ("", "%05d$:", (lbl2->key + 100));
+ emitLabel (lbl2);
}
return;
if (lUnsigned && rUnsigned)
{
/* unsigned is easy */
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVB (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);
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
popB (pushedB);
return;
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 */
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
emitcode ("mov", "b,a");
}
}
/* 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)
{
}
else /* ! literal */
{
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
if (!lUnsigned)
{
emitcode ("setb", "F0"); /* set sign flag */
emitcode ("cpl", "a"); /* 2's complement */
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
}
}
emitcode ("jnb", "F0,%05d$", (lbl->key + 100));
emitcode ("cpl", "a"); /* 2's complement */
emitcode ("inc", "a");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
if (size > 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 (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
else /* compiletimeSign */
while (size--)
- aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xff", offset++);
}
}
else
{
- aopPut (AOP (result), "b", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 0);
while (size--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
}
popB (pushedB);
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
- D(emitcode ("; genMod",""));
+ D (emitcode (";", "genMod"));
/* assign the asmops */
aopOp (left, ic, FALSE);
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);
}
/*-----------------------------------------------------------------*/
/* 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;
- D(emitcode ("; genIfxJump",""));
+ /* 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
supplied is true */
freeForBranchAsmop (right);
freeForBranchAsmop (left);
emitcode ("ljmp", "%05d$", jlbl->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
/* mark the icode as generated */
ic->generated = 1;
unsigned long lit = 0L;
bool rightInB;
- D(emitcode ("; genCmp",""));
+ D (emitcode (";", "genCmp"));
/* if left & right are bit variables */
if (AOP_TYPE (left) == AOP_CRY &&
{
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);
+ emitLabel (lbl);
}
else
{
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)
{
}
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);
+ genIfxJump (ifx, "acc.7", left, right, result, ic->next);
freeAsmop (right, NULL, ic, TRUE);
freeAsmop (left, NULL, ic, TRUE);
return;
}
else
- emitcode ("rlc", "a");
+ {
+ emitcode ("rlc", "a");
+ }
+ }
+ goto release;
+ }
+ else
+ {//nonzero literal
+ int bytelit = ((lit >> (offset * 8)) & 0x0FFL);
+ while (size && (bytelit == 0))
+ {
+ offset++;
+ bytelit = ((lit >> (offset * 8)) & 0x0FFL);
+ size--;
+ }
+ CLRC;
+ while (size--)
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ if (sign && size == 0)
+ {
+ emitcode ("xrl", "a,#0x80");
+ emitcode ("subb", "a,#0x%02x",
+ 0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+ }
+ else
+ {
+ emitcode ("subb", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
+ offset++;
}
goto release;
}
while (size--)
{
bool pushedB = FALSE;
- rightInB = aopGetUsesAcc(AOP (right), offset);
+ rightInB = aopGetUsesAcc(right, offset);
if (rightInB)
{
pushedB = pushB ();
- emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ emitcode ("mov", "b,%s", aopGet (right, offset, FALSE, FALSE));
}
- MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
if (sign && size == 0)
{
emitcode ("xrl", "a,#0x80");
- if (AOP_TYPE (right) == AOP_LIT)
+ if (!rightInB)
{
- unsigned long lit = (unsigned long)
- floatFromVal (AOP (right)->aopu.aop_lit);
- emitcode ("subb", "a,#0x%02x",
- 0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
- }
- else
- {
- if (!rightInB)
- {
- pushedB = pushB ();
- rightInB++;
- emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
- }
- emitcode ("xrl", "b,#0x80");
- emitcode ("subb", "a,b");
+ pushedB = pushB ();
+ rightInB++;
+ MOVB (aopGet (right, offset, FALSE, FALSE));
}
+ emitcode ("xrl", "b,#0x80");
+ emitcode ("subb", "a,b");
}
else
{
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);
ifx conditional branch then generate
code a little differently */
if (ifx)
- genIfxJump (ifx, "c", NULL, NULL, result);
+ {
+ genIfxJump (ifx, "c", NULL, NULL, result, ic->next);
+ }
else
- outBitC (result);
+ {
+ outBitC (result);
+ }
/* leave the result in acc */
}
}
sym_link *letype, *retype;
int sign;
- D(emitcode ("; genCmpGt",""));
+ D (emitcode (";", "genCmpGt"));
left = IC_LEFT (ic);
right = IC_RIGHT (ic);
retype = getSpec (operandType (right));
sign = !((SPEC_USIGN (letype) && !(IS_CHAR (letype) && IS_LITERAL (letype))) ||
(SPEC_USIGN (retype) && !(IS_CHAR (retype) && IS_LITERAL (retype))));
- /* assign the amsops */
+ /* assign the asmops */
+ aopOp (result, ic, TRUE);
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
genCmp (right, left, result, ifx, sign, ic);
sym_link *letype, *retype;
int sign;
- D(emitcode ("; genCmpLt",""));
+ D (emitcode (";", "genCmpLt"));
left = IC_LEFT (ic);
right = IC_RIGHT (ic);
retype = getSpec (operandType (right));
sign = !((SPEC_USIGN (letype) && !(IS_CHAR (letype) && IS_LITERAL (letype))) ||
(SPEC_USIGN (retype) && !(IS_CHAR (retype) && IS_LITERAL (retype))));
- /* assign the amsops */
+ /* assign the asmops */
+ aopOp (result, ic, TRUE);
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
- aopOp (result, ic, TRUE);
- genCmp (left, right, result, ifx, sign,ic);
+ genCmp (left, right, result, ifx, sign, ic);
freeAsmop (result, NULL, ic, TRUE);
}
int offset = 0;
unsigned long lit = 0L;
+ D (emitcode (";", "gencjneshort"));
+
/* 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 &&
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;
//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 (AOP (left), offset, FALSE, FALSE);
- if (strcmp (l, "b"))
- emitcode ("mov", "b,%s", l);
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("cjne", "a,b,%05d$", lbl->key + 100);
offset++;
}
/* 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);
+ D (emitcode (";", "gencjne"));
+
gencjneshort (left, right, lbl);
- emitcode ("mov", "a,%s", one);
+ if (useCarry)
+ SETC;
+ else
+ MOVA (one);
emitcode ("sjmp", "%05d$", tlbl->key + 100);
- emitcode ("", "%05d$:", lbl->key + 100);
- emitcode ("clr", "a");
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (lbl);
+ if (useCarry)
+ CLRC;
+ else
+ MOVA (zero);
+ emitLabel (tlbl);
}
/*-----------------------------------------------------------------*/
static void
genCmpEq (iCode * ic, iCode * ifx)
{
+ bool swappedLR = FALSE;
operand *left, *right, *result;
+ iCode * popIc = ic->next;
- D(emitcode ("; genCmpEq",""));
+ D (emitcode (";", "genCmpEq"));
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
operand *t = IC_RIGHT (ic);
IC_RIGHT (ic) = IC_LEFT (ic);
IC_LEFT (ic) = t;
+ swappedLR = TRUE;
}
if (ifx && !AOP_SIZE (result))
{
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);
emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
emitcode ("jb", "%s,%05d$", AOP (right)->aopu.aop_dir, (lbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
}
/* if true label then we jump if condition
supplied is true */
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);
}
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
else
{
freeForBranchAsmop (result);
freeForBranchAsmop (right);
freeForBranchAsmop (left);
+ popForBranch (popIc, FALSE);
emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
else
{
symbol *lbl = newiTempLabel (NULL);
emitcode ("sjmp", "%05d$", lbl->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
freeForBranchAsmop (result);
freeForBranchAsmop (right);
freeForBranchAsmop (left);
+ popForBranch (popIc, FALSE);
emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100);
- emitcode ("", "%05d$:", lbl->key + 100);
+ emitLabel (lbl);
}
}
/* mark the icode as generated */
{
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);
emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
emitcode ("jb", "%s,%05d$", AOP (right)->aopu.aop_dir, (lbl->key + 100));
emitcode ("cpl", "c");
- emitcode ("", "%05d$:", (lbl->key + 100));
+ emitLabel (lbl);
}
/* c = 1 if egal */
if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
}
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 (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ 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
}
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));
+ }
}
/*-----------------------------------------------------------------*/
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;
}
/* hasInc - operand is incremented before any other use */
/*-----------------------------------------------------------------*/
static iCode *
-hasInc (operand *op, iCode *ic,int osize)
+hasInc (operand *op, iCode *ic, int osize)
{
sym_link *type = operandType(op);
sym_link *retype = getSpec (type);
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;
}
operand *left, *right, *result;
symbol *tlbl;
- D(emitcode ("; genAndOp",""));
+ D (emitcode (";", "genAndOp"));
/* note here that && operations that are in an
if statement are taken away by backPatchLabels
toBoolean (left);
emitcode ("jz", "%05d$", tlbl->key + 100);
toBoolean (right);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
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);
}
operand *left, *right, *result;
symbol *tlbl;
- D(emitcode ("; genOrOp",""));
+ D (emitcode (";", "genOrOp"));
/* note here that || operations that are in an
if statement are taken away by backPatchLabels
toBoolean (left);
emitcode ("jnz", "%05d$", tlbl->key + 100);
toBoolean (right);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
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);
}
/*-----------------------------------------------------------------*/
{
symbol *nlbl = newiTempLabel (NULL);
emitcode ("sjmp", "%05d$", nlbl->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
freeForBranchAsmop (result);
freeForBranchAsmop (right);
freeForBranchAsmop (left);
emitcode ("ljmp", "%05d$", IC_TRUE (ic)->key + 100);
- emitcode ("", "%05d$:", nlbl->key + 100);
+ emitLabel (nlbl);
}
else
{
freeForBranchAsmop (right);
freeForBranchAsmop (left);
emitcode ("ljmp", "%05d$", IC_FALSE (ic)->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
ic->generated = 1;
}
int bytelit = 0;
char buffer[10];
- D(emitcode ("; genAnd",""));
+ D (emitcode (";", "genAnd"));
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
#ifdef DEBUG_TYPE
- emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
+ emitcode (";", "Type res[%d] = l[%d]&r[%d]",
AOP_TYPE (result),
AOP_TYPE (left), AOP_TYPE (right));
- emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
+ emitcode (";", "Size res[%d] = l[%d]&r[%d]",
AOP_SIZE (result),
AOP_SIZE (left), AOP_SIZE (right));
#endif
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
{
// 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);
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;
}
if (posbit)
{
posbit--;
- MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE));
+ MOVA (aopGet (left, posbit >> 3, FALSE, FALSE));
// bit = left & 2^n
if (size)
{
{
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
- emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07));
+ emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07));
}
goto release;
}
{
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);
}
}
if (size)
{
emitcode ("clr", "c");
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
// if(left & literal)
else
if (ifx)
jmpTrueOrFalse (ifx, tlbl, left, right, result);
else
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
goto release;
}
}
{
/* 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 == 0)
{
- aopPut (AOP (result), zero, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset);
}
else if (IS_AOP_PREG (result))
{
- MOVA (aopGet (AOP (left), offset, FALSE, TRUE));
- emitcode ("anl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
- 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);
}
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 && offset == 0)
+ if (AOP_TYPE (left) == AOP_ACC)
+ {
+ if (offset)
+ emitcode("mov", "a,b");
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
+ else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("anl", "a,b");
+ aopPut (result, "a", offset);
+ }
+ else if (aopGetUsesAcc (left, offset))
{
- emitcode ("anl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "a", offset);
}
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);
}
else
- emitcode ("anl", "%s,a",
- aopGet (AOP (left), offset, FALSE, TRUE));
+ emitcode ("anl", "%s,a", aopGet (left, offset, FALSE, TRUE));
}
}
}
{
if (offset)
emitcode("mov", "a,b");
- emitcode ("anl", "a,%s",
- aopGet (AOP (right), offset, FALSE, FALSE));
- } else {
- if (AOP_TYPE(left)==AOP_ACC)
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
+ else if (AOP_TYPE(left)==AOP_ACC)
+ {
+ if (!offset)
{
- if (!offset)
- {
- bool pushedB = pushB ();
- emitcode("mov", "b,a");
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode("anl", "a,b");
- popB (pushedB);
- }
- else
- {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode("anl", "a,b");
- }
- } else {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("anl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
+ 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 if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("anl", "a,b");
+ }
+ else if (aopGetUsesAcc (left, offset))
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
+ else
+ {
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE));
+ }
+
emitcode ("jnz", "%05d$", tlbl->key + 100);
offset++;
}
if (size)
{
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
outBitC (result);
}
else if (ifx)
jmpTrueOrFalse (ifx, tlbl, left, right, result);
else
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
else
{
bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
if (bytelit == 0x0FF)
{
- aopPut (AOP (result),
- aopGet (AOP (left), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (left, offset, FALSE, FALSE),
+ offset);
continue;
}
else if (bytelit == 0)
{
/* 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);
continue;
}
else if (AOP_TYPE (left) == AOP_ACC)
{
if (!offset)
{
- emitcode ("anl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "a", offset);
continue;
}
else
{
- emitcode ("anl", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
- aopPut (AOP (result), "b", offset, isOperandVolatile (result, FALSE));
+ emitcode ("anl", "b,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "b", offset);
continue;
}
}
}
// faster than result <- left, anl result,right
// and better if result is SFR
- if (AOP_TYPE (left) == AOP_ACC)
+ 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 (AOP (right), offset, FALSE, FALSE));
+ 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 if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("anl", "a,b");
+ }
+ else if (aopGetUsesAcc (left, offset))
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
}
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("anl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE));
}
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
}
}
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);
}
/*-----------------------------------------------------------------*/
unsigned long lit = 0L;
int bytelit = 0;
- D(emitcode ("; genOr",""));
+ D (emitcode (";", "genOr"));
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
#ifdef DEBUG_TYPE
- emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
+ emitcode (";", "Type res[%d] = l[%d]&r[%d]",
AOP_TYPE (result),
AOP_TYPE (left), AOP_TYPE (right));
- emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
+ emitcode (";", "Size res[%d] = l[%d]&r[%d]",
AOP_SIZE (result),
AOP_SIZE (left), AOP_SIZE (right));
#endif
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;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ 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;
}
symbol *tlbl = newiTempLabel (NULL);
emitcode ("jnz", "%05d$", tlbl->key + 100);
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
else
{
- genIfxJump (ifx, "a", left, right, result);
+ genIfxJump (ifx, "a", left, right, result, ic->next);
goto release;
}
}
{
/* 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);
}
else if (IS_AOP_PREG (left))
{
- MOVA (aopGet (AOP (left), offset, FALSE, TRUE));
- emitcode ("orl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
- 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);
}
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 (offset)
emitcode("mov", "a,b");
- emitcode ("orl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
+ else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("orl", "a,b");
+ aopPut (result, "a", offset);
+ }
+ else if (aopGetUsesAcc (left, offset))
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "a", offset);
}
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);
}
else
{
- emitcode ("orl", "%s,a",
- aopGet (AOP (left), offset, FALSE, TRUE));
+ emitcode ("orl", "%s,a", aopGet (left, offset, FALSE, TRUE));
}
}
}
emitcode ("setb", "c");
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));
- } else {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("orl", "a,%s",
- aopGet (AOP (left), 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 ("orl", "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("orl", "a,b");
+ popB (pushedB);
+ }
+ else
+ {
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode("orl", "a,b");
+ }
+ }
+ else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("orl", "a,b");
+ }
+ else if (aopGetUsesAcc (left, offset))
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
+ else
+ {
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, FALSE));
}
+
emitcode ("jnz", "%05d$", tlbl->key + 100);
offset++;
}
if (size)
{
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
outBitC (result);
}
else if (ifx)
jmpTrueOrFalse (ifx, tlbl, left, right, result);
else
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
else
{
bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
if (bytelit == 0)
{
- aopPut (AOP (result),
- aopGet (AOP (left), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (left, offset, FALSE, FALSE),
+ offset);
continue;
}
else if (bytelit == 0x0FF)
{
/* 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);
continue;
}
}
- // faster than result <- left, anl result,right
+ // faster than result <- left, orl result,right
// and better if result is SFR
- if (AOP_TYPE (left) == AOP_ACC)
+ 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 ("orl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ emitcode ("orl", "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("orl", "a,b");
+ popB (pushedB);
+ }
+ else
+ {
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode("orl", "a,b");
+ }
+ }
+ else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("orl", "a,b");
+ }
+ else if (aopGetUsesAcc (left, offset))
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
}
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("orl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, FALSE));
}
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
}
}
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);
}
/*-----------------------------------------------------------------*/
unsigned long lit = 0L;
int bytelit = 0;
- D(emitcode ("; genXor",""));
+ D (emitcode (";", "genXor"));
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
#ifdef DEBUG_TYPE
- emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
+ emitcode (";", "Type res[%d] = l[%d]&r[%d]",
AOP_TYPE (result),
AOP_TYPE (left), AOP_TYPE (right));
- emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
+ emitcode (";", "Size res[%d] = l[%d]&r[%d]",
AOP_SIZE (result),
AOP_SIZE (left), AOP_SIZE (right));
#endif
right = left;
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);
}
}
}
-
}
else
{
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 (AOP (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");
- emitcode ("", "%05d$:", (tlbl->key + 100));
+ emitLabel (tlbl);
}
// bit = c
// val = c
if (size)
outBitC (result);
- // if(bit | ...)
+ // 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;
}
{
/* 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 (IS_AOP_PREG (left))
{
- MOVA (aopGet (AOP (left), offset, FALSE, TRUE));
- emitcode ("xrl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
- 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);
}
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 (offset)
emitcode("mov", "a,b");
- emitcode ("xrl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ }
+ else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("xrl", "a,b");
+ aopPut (result, "a", offset);
+ }
+ else if (aopGetUsesAcc (left, offset))
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+ aopPut (result, "a", offset);
}
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);
}
else
- emitcode ("xrl", "%s,a",
- aopGet (AOP (left), offset, FALSE, TRUE));
+ emitcode ("xrl", "%s,a", aopGet (left, offset, FALSE, TRUE));
}
}
}
// if(!size && ifx), conditional oper: if(left ^ right)
symbol *tlbl = newiTempLabel (NULL);
int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
+
if (size)
emitcode ("setb", "c");
while (sizer--)
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 || IS_AOP_PREG(right) || AOP_TYPE(right)==AOP_DIR)
+ && AOP_TYPE(left)==AOP_ACC)
+ {
+ if (offset)
+ emitcode("mov", "a,b");
+ emitcode ("xrl", "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("xrl", "a,b");
+ popB (pushedB);
+ }
+ else
+ {
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode("xrl", "a,b");
+ }
+ }
+ else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("xrl", "a,b");
+ }
+ else if (aopGetUsesAcc (left, offset))
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("xrl", "a,%s", aopGet (right, 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));
- } else {
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("xrl", "a,%s",
- aopGet (AOP (left), offset, FALSE, FALSE));
- }
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
}
+
emitcode ("jnz", "%05d$", tlbl->key + 100);
offset++;
}
if (size)
{
CLRC;
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
outBitC (result);
}
else if (ifx)
for (; (size--); offset++)
{
// normal case
- // result = left & right
+ // result = left ^ right
if (AOP_TYPE (right) == AOP_LIT)
{
bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
if (bytelit == 0)
{
- aopPut (AOP (result),
- aopGet (AOP (left), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (left, offset, FALSE, FALSE),
+ offset);
continue;
}
}
- // faster than result <- left, anl result,right
+ // faster than result <- left, xrl result,right
// and better if result is SFR
- if (AOP_TYPE (left) == AOP_ACC)
+ 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 ("xrl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+ emitcode ("xrl", "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("xrl", "a,b");
+ popB (pushedB);
+ }
+ else
+ {
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode("xrl", "a,b");
+ }
+ }
+ else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+ {
+ MOVB (aopGet (left, offset, FALSE, FALSE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("xrl", "a,b");
+ }
+ else if (aopGetUsesAcc (left, offset))
+ {
+ MOVA (aopGet (left, offset, FALSE, FALSE));
+ emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
}
else
{
- MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
- emitcode ("xrl", "a,%s",
- aopGet (AOP (left), offset, FALSE, TRUE));
+ MOVA (aopGet (right, offset, FALSE, FALSE));
+ emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
}
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
}
}
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);
}
/*-----------------------------------------------------------------*/
genInline (iCode * ic)
{
char *buffer, *bp, *bp1;
+ bool inComment = FALSE;
- D(emitcode ("; genInline",""));
+ D (emitcode (";", "genInline"));
_G.inLine += (!options.asmpeep);
- buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
- strcpy (buffer, 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(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 = 0;
- char *l;
+ int size, offset;
+ char *l;
- D(emitcode ("; genRRC",""));
+ D (emitcode (";", "genRRC"));
/* rotate right with carry */
left = IC_LEFT (ic);
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;
/* 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--);
}
/* 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));
- freeAsmop (left, NULL, ic, TRUE);
+ aopPut (result, "a", AOP_SIZE (result) - 1);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
genRLC (iCode * ic)
{
operand *left, *result;
- int size, offset = 0;
+ int size, offset;
char *l;
- D(emitcode ("; genRLC",""));
+ D (emitcode (";", "genRLC"));
/* rotate right with carry */
left = IC_LEFT (ic);
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");
}
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++);
+ }
+
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++);
}
}
/* 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));
- freeAsmop (left, NULL, ic, TRUE);
+ aopPut (result, "a", 0);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
{
operand *left, *result;
- D(emitcode ("; genGetHbit",""));
+ D (emitcode (";", "genGetHbit"));
left = IC_LEFT (ic);
result = IC_RESULT (ic);
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");
outAcc (result);
}
+ freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genGetAbit - generates code get a single bit */
+/*-----------------------------------------------------------------*/
+static void
+genGetAbit (iCode * ic)
+{
+ operand *left, *right, *result;
+ int shCount;
+
+ D (emitcode (";", "genGetAbit"));
+
+ left = IC_LEFT (ic);
+ right = IC_RIGHT (ic);
+ result = IC_RESULT (ic);
+ aopOp (left, ic, FALSE);
+ aopOp (right, ic, FALSE);
+ aopOp (result, ic, FALSE);
+
+ shCount = (int) ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+
+ /* get the needed byte into a */
+ MOVA (aopGet (left, shCount / 8, FALSE, FALSE));
+ shCount %= 8;
+ if (AOP_TYPE (result) == AOP_CRY)
+ {
+ if ((shCount) == 7)
+ emitcode ("rlc", "a");
+ else if ((shCount) == 0)
+ emitcode ("rrc", "a");
+ else
+ emitcode ("mov", "c,acc[%d]", shCount);
+ outBitC (result);
+ }
+ else
+ {
+ switch (shCount)
+ {
+ case 2:
+ emitcode ("rr", "a");
+ //fallthrough
+ case 1:
+ emitcode ("rr", "a");
+ //fallthrough
+ case 0:
+ emitcode ("anl", "a,#0x01");
+ break;
+ case 3:
+ case 5:
+ emitcode ("mov", "c,acc[%d]", shCount);
+ emitcode ("clr", "a");
+ emitcode ("rlc", "a");
+ break;
+ case 4:
+ emitcode ("swap", "a");
+ emitcode ("anl", "a,#0x01");
+ break;
+ case 6:
+ emitcode ("rl", "a");
+ //fallthrough
+ case 7:
+ emitcode ("rl", "a");
+ emitcode ("anl", "a,#0x01");
+ break;
+ }
+ outAcc (result);
+ }
+
+ freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genGetByte - generates code get a single byte */
+/*-----------------------------------------------------------------*/
+static void
+genGetByte (iCode * ic)
+{
+ operand *left, *right, *result;
+ int offset;
+
+ D (emitcode (";", "genGetByte"));
+
+ left = IC_LEFT (ic);
+ right = IC_RIGHT (ic);
+ result = IC_RESULT (ic);
+ aopOp (left, ic, FALSE);
+ aopOp (right, ic, FALSE);
+ aopOp (result, ic, FALSE);
+
+ offset = (int) ulFromVal (AOP (right)->aopu.aop_lit) / 8;
+ aopPut (result,
+ aopGet (left, offset, FALSE, FALSE),
+ 0);
+ freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
freeAsmop (left, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genGetWord - generates code get two bytes */
+/*-----------------------------------------------------------------*/
+static void
+genGetWord (iCode * ic)
+{
+ operand *left, *right, *result;
+ int offset;
+
+ D (emitcode (";", "genGetWord"));
+
+ left = IC_LEFT (ic);
+ right = IC_RIGHT (ic);
+ result = IC_RESULT (ic);
+ aopOp (left, ic, FALSE);
+ aopOp (right, ic, FALSE);
+ aopOp (result, ic, FALSE);
+
+ offset = (int) ulFromVal (AOP (right)->aopu.aop_lit) / 8;
+ aopPut (result,
+ aopGet (left, offset, FALSE, FALSE),
+ 0);
+ aopPut (result,
+ aopGet (left, offset+1, FALSE, FALSE),
+ 1);
+
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
{
operand *left, *result;
- D(emitcode ("; genSwap",""));
+ D(emitcode (";", "genSwap"));
left = IC_LEFT (ic);
result = IC_RESULT (ic);
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);
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),
- 0, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), "a", 1, isOperandVolatile (result, FALSE));
+ MOVA (aopGet (left, 0, FALSE, FALSE));
+ aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+ aopPut (result, "a", 1);
}
else if (operandsEqu (left, result))
{
char * reg = "a";
bool pushedB = FALSE, leftInB = FALSE;
- MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
- if (aopGetUsesAcc(AOP (left), 1) || aopGetUsesAcc(AOP (result), 0))
+ 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),
- 0, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), reg, 1, isOperandVolatile (result, FALSE));
+ aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+ aopPut (result, reg, 1);
if (leftInB)
popB (pushedB);
}
else
{
- aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
- 0, isOperandVolatile (result, FALSE));
- aopPut (AOP (result), aopGet (AOP (left), 0, FALSE, FALSE),
- 1, isOperandVolatile (result, FALSE));
+ aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+ aopPut (result, aopGet (left, 0, FALSE, FALSE), 1);
}
break;
default:
wassertl(FALSE, "unsupported SWAP operand size");
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
-
/*-----------------------------------------------------------------*/
/* AccRol - rotate left accumulator by known count */
/*-----------------------------------------------------------------*/
emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
emitcode ("orl", "a,#0x%02x",
(unsigned char) ~SRMask[shCount]);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
}
}
}
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);
}
/*-----------------------------------------------------------------*/
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);
}
/*-----------------------------------------------------------------*/
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);
}
else
{
if (!sign)
- aopPut (AOP (result), l, offr, isOperandVolatile (result, FALSE));
+ {
+ aopPut (result, l, offr);
+ }
else
{
/* MSB sign in acc.7 ! */
if (getDataSize (left) == offl + 1)
{
- emitcode ("mov", "a,%s", l);
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ MOVA (l);
+ aopPut (result, "a", offr);
}
}
}
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
emitcode ("orl", "a,#0x%02x",
(unsigned char) ~SRMask[shCount]); // 111AAAAA:BBBCCCCC
- emitcode ("", "%05d$:", tlbl->key + 100);
- break; // SSSSAAAA:BBBCCCCC
+ emitLabel (tlbl);
+ 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
emitcode ("orl", "a,#0x%02x",
(unsigned char) ~SRMask[shCount]); // 111111AA:BBBBBBCC
- emitcode ("", "%05d$:", tlbl->key + 100);
+ 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
emitcode ("orl", "a,#0x%02x",
(unsigned char) ~SRMask[shCount]); // 1111111A:BBBBBBBC
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
break;
default:
break;
shiftL2Left2Result (operand * left, int offl,
operand * result, int offr, int shCount)
{
+ char * x;
+ bool pushedB = FALSE;
+ bool usedB = FALSE;
+
if (sameRegs (AOP (result), AOP (left)) &&
((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));
+ x = xch_a_aopGet (left, offl + MSB16, FALSE, FALSE);
+ usedB = !strncmp(x, "b", 1);
+ }
+ else if (aopGetUsesAcc (result, offr))
+ {
+ movLeft2Result (left, offl, result, offr, 0);
+ pushedB = pushB ();
+ usedB = TRUE;
+ emitcode ("mov", "b,%s", aopGet (left, offl + MSB16, FALSE, FALSE));
+ MOVA (aopGet (result, offr, FALSE, FALSE));
+ emitcode ("xch", "a,b");
+ x = "b";
}
else
{
movLeft2Result (left, offl, result, offr, 0);
- MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+ MOVA (aopGet (left, offl + MSB16, FALSE, FALSE));
+ x = aopGet (result, offr, 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 (x, shCount);
+ if (usedB)
+ {
+ emitcode ("xch", "a,b");
+ aopPut (result, "a", offr);
+ aopPut (result, "b", offr + MSB16);
+ popB (pushedB);
+ }
+ else
+ {
+ aopPut (result, "a", offr + MSB16);
+ }
}
operand * result, int offr,
int shCount, int sign)
{
+ char * x;
+ bool pushedB = FALSE;
+ bool usedB = FALSE;
+
if (sameRegs (AOP (result), AOP (left)) &&
((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));
+ x = xch_a_aopGet (left, offl + MSB16, FALSE, FALSE);
+ usedB = !strncmp(x, "b", 1);
+ }
+ else if (aopGetUsesAcc (result, offr))
+ {
+ movLeft2Result (left, offl, result, offr, 0);
+ pushedB = pushB ();
+ usedB = TRUE;
+ emitcode ("mov", "b,%s", aopGet (result, offr, FALSE, FALSE));
+ MOVA (aopGet (left, offl + MSB16, FALSE, FALSE));
+ x = "b";
}
else
{
movLeft2Result (left, offl, result, offr, 0);
- MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+ MOVA (aopGet (left, offl + MSB16, FALSE, FALSE));
+ x = aopGet (result, offr, FALSE, FALSE);
}
/* a:x >> shCount (x = lsb(result)) */
if (sign)
- AccAXRshS (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
+ AccAXRshS (x, shCount);
else
- AccAXRsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
+ AccAXRsh (x, shCount);
+ if (usedB)
+ {
+ emitcode ("xch", "a,b");
+ aopPut (result, "a", offr);
+ emitcode ("xch", "a,b");
+ popB (pushedB);
+ }
if (getDataSize (result) > 1)
- aopPut (AOP (result), "a", offr + MSB16, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr + MSB16);
}
/*-----------------------------------------------------------------*/
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));
+ if (aopGetUsesAcc (result, offr))
+ {
+ emitcode ("xch", "a,b");
+ MOVA (aopGet (result, offr, FALSE, FALSE));
+ emitcode ("orl", "a,b");
+ }
+ else
+ {
+ emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
+ }
/* back to result */
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
}
/*-----------------------------------------------------------------*/
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));
+ if (aopGetUsesAcc(result, offr))
+ {
+ emitcode ("xch", "a,b");
+ MOVA (aopGet (result, offr, FALSE, FALSE));
+ emitcode ("orl", "a,b");
+ }
+ else
+ {
+ emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
+ }
/* back to result */
- aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
}
/*-----------------------------------------------------------------*/
static void
genlshOne (operand * result, operand * left, int shCount)
{
- D(emitcode ("; genlshOne",""));
+ D (emitcode (";", "genlshOne"));
shiftL1Left2Result (left, LSB, result, LSB, shCount);
}
{
int size;
- D(emitcode ("; genlshTwo",""));
+ D (emitcode (";", "genlshTwo"));
size = getDataSize (result);
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 (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB);
}
/* 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));
+ xch_a_aopGet (left, LSB + offr, FALSE, FALSE);
else
- aopPut (AOP (result), "a", LSB + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", LSB + offr);
}
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));
+ xch_a_aopGet (left, MSB16 + offr, FALSE, FALSE);
else
- aopPut (AOP (result), "a", MSB16 + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB16 + offr);
}
if (size >= MSB24 + offr)
{
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));
+ xch_a_aopGet (left, MSB24 + offr, FALSE, FALSE);
else
- aopPut (AOP (result), "a", MSB24 + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB24 + offr);
}
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);
}
if (offr != LSB)
- aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB);
}
/*-----------------------------------------------------------------*/
{
int size;
- D(emitcode ("; genlshFour",""));
+ D (emitcode (";", "genlshFour"));
size = AOP_SIZE (result);
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);
+ aopPut (result, zero, MSB16);
+ aopPut (result, zero, MSB24);
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);
+ aopPut (result, zero, LSB);
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);
}
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);
}
}
}
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",""));
+ D (emitcode (";", "genLeftShiftLiteral"));
freeAsmop (right, NULL, ic, TRUE);
movLeft2Result (left, size, result, size, 0);
}
}
-
else if (shCount >= (size * 8))
- while (size--)
- aopPut (AOP (result), zero, size, isOperandVolatile (result, FALSE));
+ {
+ while (size--)
+ {
+ aopPut (result, zero, size);
+ }
+ }
else
{
switch (size)
break;
}
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
symbol *tlbl, *tlbl1;
bool pushedB;
- D(emitcode ("; genLeftShift",""));
+ D (emitcode (";", "genLeftShift"));
right = IC_RIGHT (ic);
left = IC_LEFT (ic);
largest size of an object can be only 32 bits ) */
pushedB = pushB ();
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVB (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);
}
else
- aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset);
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);
+ emitLabel (tlbl);
emitcode ("add", "a,acc");
- emitcode ("", "%05d$:", tlbl1->key + 100);
+ emitLabel (tlbl1);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
popB (pushedB);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
reAdjustPreg (AOP (result));
emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
- l = aopGet (AOP (result), offset, FALSE, FALSE);
+ emitLabel (tlbl);
+ l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("add", "a,acc");
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
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++);
}
reAdjustPreg (AOP (result));
- emitcode ("", "%05d$:", tlbl1->key + 100);
+ emitLabel (tlbl1);
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);
}
/*-----------------------------------------------------------------*/
genrshOne (operand * result, operand * left,
int shCount, int sign)
{
- D(emitcode ("; genrshOne",""));
+ D (emitcode (";", "genrshOne"));
shiftR1Left2Result (left, LSB, result, LSB, shCount, sign);
}
genrshTwo (operand * result, operand * left,
int shCount, int sign)
{
- D(emitcode ("; genrshTwo",""));
+ D (emitcode (";", "genrshTwo"));
/* if shCount >= 8 */
if (shCount >= 8)
{
shCount -= 8;
if (shCount)
- shiftR1Left2Result (left, MSB16, result, LSB,
- shCount, sign);
+ shiftR1Left2Result (left, MSB16, result, LSB, shCount, sign);
else
movLeft2Result (left, MSB16, result, LSB, sign);
addSign (result, MSB16, sign);
shiftRLong (operand * left, int offl,
operand * result, int sign)
{
- int isSameRegs=sameRegs(AOP(left),AOP(result));
+ bool overlapping = regsInCommon (left, result) || operandsEqu(left, result);
- if (isSameRegs && offl>1) {
- // we are in big trouble, but this shouldn't happen
- werror(E_INTERNAL_ERROR, __FILE__, __LINE__);
- }
+ if (overlapping && offl>1)
+ {
+ // we are in big trouble, but this shouldn't happen
+ 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
- if (sign) {
- emitcode ("rlc", "a");
- emitcode ("subb", "a,acc");
- if (isSameRegs)
- emitcode ("xch", "a,%s", aopGet(AOP(left), MSB32, FALSE, FALSE));
- else {
- aopPut (AOP (result), "a", MSB32, isOperandVolatile (result, FALSE));
- MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
- }
- } else {
- aopPut (AOP(result), zero, MSB32, isOperandVolatile (result, FALSE));
+ if (offl==MSB16)
+ {
+ // shift is > 8
+ if (sign)
+ {
+ emitcode ("rlc", "a");
+ emitcode ("subb", "a,acc");
+ if (overlapping && sameByte (AOP (left), MSB32, AOP (result), MSB32))
+ {
+ xch_a_aopGet (left, MSB32, FALSE, FALSE);
+ }
+ else
+ {
+ aopPut (result, "a", MSB32);
+ MOVA (aopGet (left, MSB32, FALSE, FALSE));
+ }
+ }
+ else
+ {
+ if (aopPutUsesAcc (result, zero, MSB32))
+ {
+ emitcode("xch", "a,b");
+ aopPut (result, zero, MSB32);
+ emitcode("xch", "a,b");
+ }
+ else
+ {
+ aopPut (result, zero, MSB32);
+ }
+ }
}
- }
- 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 (AOP (left), MSB24, FALSE, FALSE));
- } else {
- aopPut (AOP (result), "a", MSB32-offl, isOperandVolatile (result, FALSE));
- MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
- }
+ if (overlapping && offl==MSB16 &&
+ sameByte (AOP (left), MSB24, AOP (result), MSB32-offl))
+ {
+ xch_a_aopGet (left, MSB24, FALSE, FALSE);
+ }
+ else
+ {
+ aopPut (result, "a", MSB32 - offl);
+ MOVA (aopGet (left, MSB24, FALSE, FALSE));
+ }
emitcode ("rrc", "a");
- if (isSameRegs && offl==1) {
- emitcode ("xch", "a,%s",aopGet (AOP (left), MSB16, FALSE, FALSE));
- } else {
- aopPut (AOP (result), "a", MSB24-offl, isOperandVolatile (result, FALSE));
- MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
- }
- emitcode ("rrc", "a");
- aopPut (AOP (result), "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+ if (overlapping && offl==MSB16 &&
+ sameByte (AOP (left), MSB16, AOP (result), MSB24-offl))
+ {
+ xch_a_aopGet (left, MSB16, FALSE, FALSE);
+ }
+ else
+ {
+ aopPut (result, "a", MSB24 - offl);
+ MOVA (aopGet (left, MSB16, FALSE, FALSE));
+ }
- if (offl == LSB)
+ emitcode ("rrc", "a");
+ if (offl != LSB)
+ {
+ aopPut (result, "a", MSB16 - offl);
+ }
+ else
{
- MOVA (aopGet (AOP (left), LSB, FALSE, FALSE));
+ if (overlapping &&
+ sameByte (AOP (left), LSB, AOP (result), MSB16-offl))
+ {
+ xch_a_aopGet (left, LSB, FALSE, FALSE);
+ }
+ else
+ {
+ aopPut (result, "a", MSB16 - offl);
+ MOVA (aopGet (left, LSB, FALSE, FALSE));
+ }
emitcode ("rrc", "a");
- aopPut (AOP (result), "a", LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", LSB);
}
}
genrshFour (operand * result, operand * left,
int shCount, int sign)
{
- D(emitcode ("; genrshFour",""));
+ D (emitcode (";", "genrshFour"));
/* if shifting more that 3 bytes */
if (shCount >= 24)
{
shCount -= 8;
if (shCount == 1)
- shiftRLong (left, MSB16, result, sign);
+ {
+ shiftRLong (left, MSB16, result, sign);
+ }
else if (shCount == 0)
{
movLeft2Result (left, MSB16, result, LSB, 0);
}
}
else
- { /* 1 <= shCount <= 7 */
+ {
+ /* 1 <= shCount <= 7 */
if (shCount <= 2)
{
shiftRLong (left, LSB, result, sign);
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",""));
+ D (emitcode (";", "genRightShiftLiteral"));
freeAsmop (right, NULL, ic, TRUE);
while (size--)
movLeft2Result (left, size, result, size, 0);
}
-
else if (shCount >= (size * 8))
{
- if (sign) {
- /* get sign in acc.7 */
- MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE));
- }
+ if (sign)
+ {
+ /* get sign in acc.7 */
+ MOVA (aopGet (left, size - 1, FALSE, FALSE));
+ }
addSign (result, LSB, sign);
}
else
break;
}
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
symbol *tlbl, *tlbl1;
bool pushedB;
- D(emitcode ("; genSignedRightShift",""));
+ D (emitcode (";", "genSignedRightShift"));
/* we do it the hard way put the shift count in b
and loop thru preserving the sign */
largest size of an object can be only 32 bits ) */
pushedB = pushB ();
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVB (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);
}
else
- aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset);
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);
+ emitLabel (tlbl);
emitcode ("mov", "c,ov");
emitcode ("rrc", "a");
- emitcode ("", "%05d$:", tlbl1->key + 100);
+ emitLabel (tlbl1);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
popB (pushedB);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
reAdjustPreg (AOP (result));
emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
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--);
}
reAdjustPreg (AOP (result));
- emitcode ("", "%05d$:", tlbl1->key + 100);
+ emitLabel (tlbl1);
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);
}
/*-----------------------------------------------------------------*/
symbol *tlbl, *tlbl1;
bool pushedB;
- D(emitcode ("; genRightShift",""));
+ D (emitcode (";", "genRightShift"));
/* if signed then we do it the hard way preserve the
sign bit moving it inwards */
largest size of an object can be only 32 bits ) */
pushedB = pushB ();
- emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+ MOVB (aopGet (right, 0, FALSE, FALSE));
emitcode ("inc", "b");
freeAsmop (right, NULL, ic, TRUE);
aopOp (left, ic, FALSE);
if (!sameRegs (AOP (left), AOP (result)) &&
AOP_SIZE (result) > 1)
{
-
size = AOP_SIZE (result);
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);
}
else
- aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset);
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);
+ emitLabel (tlbl);
CLRC;
emitcode ("rrc", "a");
- emitcode ("", "%05d$:", tlbl1->key + 100);
+ emitLabel (tlbl1);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
popB (pushedB);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
reAdjustPreg (AOP (result));
emitcode ("sjmp", "%05d$", tlbl1->key + 100);
- emitcode ("", "%05d$:", tlbl->key + 100);
+ emitLabel (tlbl);
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--);
}
reAdjustPreg (AOP (result));
- emitcode ("", "%05d$:", tlbl1->key + 100);
+ emitLabel (tlbl1);
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);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
/* 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",""));
+ D(emitcode (";", "genUnpackBits"));
etype = getSpec (operandType (result));
rsize = getSize (operandType (result));
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);
if (blen < 8)
{
emitPtrByteGet (rname, ptype, FALSE);
- AccRsh (bstr);
+ AccRol (8 - bstr);
emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (8 - blen));
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ if (!SPEC_USIGN (etype))
+ {
+ /* signed bitfield */
+ symbol *tlbl = newiTempLabel (NULL);
+
+ emitcode ("jnb", "acc.%d,%05d$", blen - 1, tlbl->key + 100);
+ emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << blen));
+ emitLabel (tlbl);
+ }
+ aopPut (result, "a", offset++);
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++);
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));
+ if (!SPEC_USIGN (etype))
+ {
+ /* signed bitfield */
+ symbol *tlbl = newiTempLabel (NULL);
+
+ emitcode ("jnb", "acc.%d,%05d$", rlen - 1, tlbl->key + 100);
+ emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << rlen));
+ emitLabel (tlbl);
+ }
+ aopPut (result, "a", offset++);
}
finish:
if (offset < rsize)
{
+ char *source;
+
+ if (SPEC_USIGN (etype))
+ source = zero;
+ else
+ {
+ /* signed bitfield: sign extension with 0x00 or 0xff */
+ emitcode ("rlc", "a");
+ emitcode ("subb", "a,acc");
+
+ source = "a";
+ }
rsize -= offset;
while (rsize--)
- aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, source, offset++);
}
+ return NULL;
}
char buffer[256];
int size, offset = 0;
- D(emitcode ("; genDataPointerGet",""));
+ D (emitcode (";", "genDataPointerGet"));
aopOp (result, ic, TRUE);
/* get the string representation of the name */
- l = aopGet (AOP (left), 0, FALSE, TRUE);
+ l = aopGet (left, 0, FALSE, TRUE);
+ l++; // remove #
size = AOP_SIZE (result);
while (size--)
{
if (offset)
- sprintf (buffer, "(%s + %d)", l + 1, offset);
+ {
+ SNPRINTF (buffer, sizeof(buffer), "(%s + %d)", l, offset);
+ }
else
- sprintf (buffer, "%s", l + 1);
- aopPut (AOP (result), buffer, offset++, isOperandVolatile (result, FALSE));
+ {
+ SNPRINTF (buffer, sizeof(buffer), "%s", l);
+ }
+ aopPut (result, buffer, offset++);
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
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",""));
+ D (emitcode (";", "genNearPointerGet"));
rtype = operandType (result);
retype = getSpec (rtype);
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)))
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",
- __FILE__, __LINE__);
+ fprintf(stderr, "probable internal error: unexpected rname '%s' @ %s:%d\n",
+ rname, __FILE__, __LINE__);
}
else
{
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);
-
- //aopOp (result, ic, FALSE);
- aopOp (result, ic, result?TRUE:FALSE);
+ rname = aopGet (left, 0, FALSE, 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 */
emitcode ("mov", "a,@%s", rname);
if (!ifx)
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
{
- sprintf (buffer, "@%s", rname);
- aopPut (AOP (result), buffer, offset, isOperandVolatile (result, FALSE));
+ char buffer[80];
+
+ SNPRINTF (buffer, sizeof(buffer), "@%s", rname);
+ aopPut (result, buffer, offset);
}
offset++;
if (size || pi)
}
/* 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(AOP ( left ),rname,0, isOperandVolatile (left, FALSE));
+ aopPut (left, rname, 0);
}
freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
}
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",""));
+ D (emitcode (";", "genPagedPointerGet"));
rtype = operandType (result);
retype = getSpec (rtype);
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)))
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);
-
- aopOp (result, ic, FALSE);
+ rname = aopGet (left, 0, FALSE, 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 */
emitcode ("movx", "a,@%s", rname);
if (!ifx)
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
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) aopPut ( AOP (left), rname, 0, isOperandVolatile (left, FALSE));
+ if (pi)
+ aopPut (left, rname, 0);
freeAsmop (NULL, aop, ic, TRUE);
}
else
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
/* done */
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
if (pi) pi->generated = 1;
-
}
/*--------------------------------------------------------------------*/
/* 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");
- emitcode ("", "; mov b,???");
+ emitcode (";", "mov b,???");
/* genPointerGet and genPointerSet originally did different
** things for this case. Both seem wrong.
** 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));
}
}
}
/*-----------------------------------------------------------------*/
-/* genFarPointerGet - gget value from far space */
+/* genFarPointerGet - get value from far space */
/*-----------------------------------------------------------------*/
static void
genFarPointerGet (operand * left,
operand * result, iCode * ic, iCode * pi, iCode * ifx)
{
int size, offset;
+ char *ifxCond = "a";
sym_link *retype = getSpec (operandType (result));
- D(emitcode ("; genFarPointerGet",""));
+ D (emitcode (";", "genFarPointerGet"));
aopOp (left, ic, FALSE);
loadDptrFromOperand (left, FALSE);
/* if bit then unpack */
if (IS_BITFIELD (retype))
- genUnpackBits (result, "dptr", FPOINTER, ifx);
+ ifxCond = genUnpackBits (result, "dptr", FPOINTER, ifx);
else
{
size = AOP_SIZE (result);
{
emitcode ("movx", "a,@dptr");
if (!ifx)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
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));
- pi->generated = 1;
- }
+ aopPut (left, "dpl", 0);
+ aopPut (left, "dph", 1);
+ pi->generated = 1;
+ }
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
-/* genCodePointerGet - gget value from code space */
+/* genCodePointerGet - get value from code space */
/*-----------------------------------------------------------------*/
static void
genCodePointerGet (operand * left,
operand * result, iCode * ic, iCode *pi, iCode *ifx)
{
int size, offset;
+ char *ifxCond = "a";
sym_link *retype = getSpec (operandType (result));
- D(emitcode ("; genCodePointerGet",""));
+ D (emitcode (";", "genCodePointerGet"));
aopOp (left, ic, FALSE);
loadDptrFromOperand (left, FALSE);
/* if bit then unpack */
if (IS_BITFIELD (retype))
- genUnpackBits (result, "dptr", CPOINTER, ifx);
+ ifxCond = genUnpackBits (result, "dptr", CPOINTER, ifx);
else
{
size = AOP_SIZE (result);
while (size--)
{
- if (pi)
- {
- emitcode ("clr", "a");
- emitcode ("movc", "a,@a+dptr");
- if (!ifx)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
- emitcode ("inc", "dptr");
- }
- else
- {
- emitcode ("mov", "a,#0x%02x", offset);
- emitcode ("movc", "a,@a+dptr");
- if (!ifx)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
- }
+ emitcode ("clr", "a");
+ emitcode ("movc", "a,@a+dptr");
+ if (!ifx)
+ aopPut (result, "a", offset++);
+ 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));
- pi->generated = 1;
- }
+ aopPut (left, "dpl", 0);
+ aopPut (left, "dph", 1);
+ pi->generated = 1;
+ }
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
-/* genGenPointerGet - gget value from generic pointer space */
+/* genGenPointerGet - get value from generic pointer space */
/*-----------------------------------------------------------------*/
static void
genGenPointerGet (operand * left,
operand * result, iCode * ic, iCode *pi, iCode *ifx)
{
int size, offset;
+ char *ifxCond = "a";
sym_link *retype = getSpec (operandType (result));
- D(emitcode ("; genGenPointerGet",""));
+ D (emitcode (";", "genGenPointerGet"));
aopOp (left, ic, FALSE);
loadDptrFromOperand (left, TRUE);
- /* so dptr know contains the address */
+ /* so dptr now contains the address */
aopOp (result, ic, FALSE);
/* if bit then unpack */
if (IS_BITFIELD (retype))
- genUnpackBits (result, "dptr", GPOINTER, ifx);
+ {
+ ifxCond = genUnpackBits (result, "dptr", GPOINTER, ifx);
+ }
else
{
size = AOP_SIZE (result);
{
emitcode ("lcall", "__gptrget");
if (!ifx)
- aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
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));
- pi->generated = 1;
- }
+ aopPut (left, "dpl", 0);
+ aopPut (left, "dph", 1);
+ pi->generated = 1;
+ }
if (ifx && !ifx->generated)
{
- genIfxJump (ifx, "a", left, NULL, result);
+ genIfxJump (ifx, ifxCond, left, NULL, result, ic->next);
}
-
- freeAsmop (left, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (left, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
sym_link *type, *etype;
int p_type;
- D(emitcode ("; genPointerGet",""));
+ D (emitcode (";", "genPointerGet"));
left = IC_LEFT (ic);
result = IC_RESULT (ic);
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 */
/* special case when cast remat */
if (p_type == GPOINTER && OP_SYMBOL(left)->remat &&
- IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) {
- left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
- type = operandType (left);
- p_type = DCL_TYPE (type);
- }
+ IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode))
+ {
+ left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
+ type = operandType (left);
+ p_type = DCL_TYPE (type);
+ }
/* now that we have the pointer type we assign
the pointer values */
switch (p_type)
genGenPointerGet (left, result, ic, pi, ifx);
break;
}
-
}
-
/*-----------------------------------------------------------------*/
/* genPackBits - generates code for packed bit storage */
/*-----------------------------------------------------------------*/
int litval; /* source literal value (if AOP_LIT) */
unsigned char mask; /* bitmask within current byte */
- D(emitcode ("; genPackBits",""));
+ D(emitcode (";", "genPackBits"));
blen = SPEC_BLEN (etype);
bstr = SPEC_BSTR (etype);
{
/* 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);
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);
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);
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);
}
{
/* 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);
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 ();
}
emitPtrByteSet (rname, p_type, "a");
}
-
}
int size, offset = 0;
char *l, buffer[256];
- D(emitcode ("; genDataPointerSet",""));
+ D (emitcode (";", "genDataPointerSet"));
aopOp (right, ic, FALSE);
- l = aopGet (AOP (result), 0, FALSE, TRUE);
- size = AOP_SIZE (right);
+ l = aopGet (result, 0, FALSE, TRUE);
+ l++; //remove #
+ size = max (AOP_SIZE (right), AOP_SIZE (result));
while (size--)
{
if (offset)
- sprintf (buffer, "(%s + %d)", l + 1, offset);
+ SNPRINTF (buffer, sizeof(buffer), "(%s + %d)", l, offset);
else
- sprintf (buffer, "%s", l + 1);
+ SNPRINTF (buffer, sizeof(buffer), "%s", l);
emitcode ("mov", "%s,%s", buffer,
- aopGet (AOP (right), offset++, FALSE, FALSE));
+ aopGet (right, offset++, FALSE, FALSE));
}
freeAsmop (right, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
-/* genNearPointerSet - emitcode for near pointer put */
+/* genNearPointerSet - emitcode for near pointer put */
/*-----------------------------------------------------------------*/
static void
genNearPointerSet (operand * right,
sym_link *retype, *letype;
sym_link *ptype = operandType (result);
- D(emitcode ("; genNearPointerSet",""));
+ D (emitcode (";", "genNearPointerSet"));
retype = getSpec (operandType (right));
letype = getSpec (ptype);
+
aopOp (result, ic, FALSE);
/* if the result is rematerializable &
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 (AOP (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 (AOP (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 (AOP (result), 0, FALSE, FALSE);
+ rname = aopGet (result, 0, FALSE, FALSE);
}
aopOp (right, ic, FALSE);
genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, rname, POINTER);
else
{
- /* we have can just get the values */
+ /* we can just get the values */
int size = AOP_SIZE (right);
int offset = 0;
while (size--)
{
- l = aopGet (AOP (right), offset, FALSE, TRUE);
- if (*l == '@')
+ l = aopGet (right, offset, FALSE, TRUE);
+ if ((*l == '@') || (strcmp (l, "acc") == 0))
{
MOVA (l);
emitcode ("mov", "@%s,a", rname);
}
/* 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 (AOP (result), rname, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, rname, 0);
freeAsmop (NULL, aop, ic, TRUE);
}
else
}
/* 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);
}
/*-----------------------------------------------------------------*/
char *rname, *l;
sym_link *retype, *letype;
- D(emitcode ("; genPagedPointerSet",""));
+ D (emitcode (";", "genPagedPointerSet"));
retype = getSpec (operandType (right));
letype = getSpec (operandType (result));
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 (AOP (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 (AOP (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;
while (size--)
{
- l = aopGet (AOP (right), offset, FALSE, TRUE);
-
+ l = aopGet (right, offset, FALSE, TRUE);
MOVA (l);
emitcode ("movx", "@%s,a", rname);
-
if (size || pi)
emitcode ("inc", "%s", rname);
-
offset++;
}
}
if (aop) /* we had to allocate for this iCode */
{
if (pi)
- aopPut (AOP (result), rname, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, rname, 0);
freeAsmop (NULL, aop, ic, TRUE);
}
else
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);
}
/*-----------------------------------------------------------------*/
sym_link *retype = getSpec (operandType (right));
sym_link *letype = getSpec (operandType (result));
- D(emitcode ("; genFarPointerSet",""));
+ D(emitcode (";", "genFarPointerSet"));
aopOp (result, ic, FALSE);
loadDptrFromOperand (result, FALSE);
- /* so dptr know contains the address */
+ /* so dptr now contains the address */
aopOp (right, ic, FALSE);
/* if bit then unpack */
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);
+ aopPut (result, "dph", 1);
pi->generated=1;
}
freeAsmop (result, NULL, ic, TRUE);
sym_link *retype = getSpec (operandType (right));
sym_link *letype = getSpec (operandType (result));
- D(emitcode ("; genGenPointerSet",""));
+ D (emitcode (";", "genGenPointerSet"));
aopOp (result, ic, FALSE);
loadDptrFromOperand (result, TRUE);
- /* so dptr know contains the address */
+ /* so dptr now contains the address */
aopOp (right, ic, FALSE);
/* if bit then unpack */
if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
- genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, "dptr", GPOINTER);
+ {
+ genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, "dptr", GPOINTER);
+ }
else
{
size = AOP_SIZE (right);
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);
+ aopPut (result, "dph", 1);
pi->generated=1;
}
freeAsmop (result, NULL, ic, TRUE);
sym_link *type, *etype;
int p_type;
- D(emitcode ("; genPointerSet",""));
+ D (emitcode (";", "genPointerSet"));
right = IC_RIGHT (ic);
result = IC_RESULT (ic);
type = operandType (result);
p_type = DCL_TYPE (type);
}
+
/* now that we have the pointer type we assign
the pointer values */
switch (p_type)
werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
"genPointerSet: illegal pointer type");
}
-
}
/*-----------------------------------------------------------------*/
{
operand *cond = IC_COND (ic);
int isbit = 0;
+ char *dup = NULL;
- D(emitcode ("; genIfx",""));
+ D (emitcode (";", "genIfx"));
aopOp (cond, ic, FALSE);
/* get the value into acc */
if (AOP_TYPE (cond) != AOP_CRY)
- toBoolean (cond);
+ {
+ toBoolean (cond);
+ }
else
- isbit = 1;
- /* the result is now in the accumulator */
- freeAsmop (cond, NULL, ic, TRUE);
+ {
+ isbit = 1;
+ if (AOP(cond)->aopu.aop_dir)
+ dup = Safe_strdup(AOP(cond)->aopu.aop_dir);
+ }
- /* if there was something to be popped then do it */
- if (popIc)
- genIpop (popIc);
+ /* the result is now in the accumulator or a directly addressable bit */
+ freeAsmop (cond, NULL, ic, TRUE);
/* if the condition is a bit variable */
- if (isbit && IS_ITEMP (cond) && SPIL_LOC (cond))
- genIfxJump (ic, SPIL_LOC (cond)->rname, NULL, NULL, NULL);
+ if (isbit && dup)
+ 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, 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;
}
symbol *sym = OP_SYMBOL (IC_LEFT (ic));
int size, offset;
- D(emitcode ("; genAddrOf",""));
+ D (emitcode (";", "genAddrOf"));
aopOp (IC_RESULT (ic), ic, FALSE);
variable */
if (sym->onStack)
{
- /* if it has an offset then we need to compute
- it */
+ /* if it has an offset then we need to compute it */
if (sym->stack)
{
- 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));
+ int stack_offset = ((sym->stack < 0) ?
+ ((char) (sym->stack - _G.nRegsSaved)) :
+ ((char) sym->stack)) & 0xff;
+ if ((abs(stack_offset) == 1) &&
+ !AOP_NEEDSACC(IC_RESULT (ic)) &&
+ !isOperandVolatile (IC_RESULT (ic), FALSE))
+ {
+ aopPut (IC_RESULT (ic), SYM_BP (sym), 0);
+ if (stack_offset > 0)
+ emitcode ("inc", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE));
+ else
+ emitcode ("dec", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE));
+ }
+ else
+ {
+ emitcode ("mov", "a,%s", SYM_BP (sym));
+ emitcode ("add", "a,#0x%02x", stack_offset & 0xff);
+ aopPut (IC_RESULT (ic), "a", 0);
+ }
}
else
{
/* we can just move _bp */
- aopPut (AOP (IC_RESULT (ic)), SYM_BP (sym), 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), SYM_BP (sym), 0);
}
/* 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++);
}
-
goto release;
}
/* 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
- sprintf (s, "#%s", sym->rname);
- aopPut (AOP (IC_RESULT (ic)), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ {
+ 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:
int offset = 0;
char *l;
- D(emitcode ("; genFarFarAssign",""));
+ D (emitcode (";", "genFarFarAssign"));
/* 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);
}
freeAsmop (result, NULL, ic, FALSE);
-
}
/*-----------------------------------------------------------------*/
int size, offset;
unsigned long lit = 0L;
- D(emitcode("; genAssign",""));
+ D (emitcode (";", "genAssign"));
result = IC_RESULT (ic);
right = IC_RIGHT (ic);
IS_TRUE_SYMOP (result) &&
isOperandInFarSpace (result))
{
-
genFarFarAssign (result, right, ic);
return;
}
/* if the result is a bit */
if (AOP_TYPE (result) == AOP_CRY)
{
-
- /* if the right size is a literal then
- we know what the value is */
- if (AOP_TYPE (right) == AOP_LIT)
- {
- if (((int) operandLitValue (right)))
- aopPut (AOP (result), one, 0, isOperandVolatile (result, FALSE));
- else
- aopPut (AOP (result), zero, 0, isOperandVolatile (result, FALSE));
- goto release;
- }
-
- /* the right is also a bit variable */
- if (AOP_TYPE (right) == AOP_CRY)
- {
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
- goto release;
- }
-
- /* we need to or */
- toBoolean (right);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ assignBit (result, right);
goto release;
}
/* 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) &&
(AOP_TYPE (right) == AOP_LIT) &&
{
while ((size) && (lit))
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
+ offset);
lit >>= 8;
offset++;
size--;
}
- emitcode ("clr", "a");
+ /* And now fill the rest with zeros. */
+ if (size)
+ {
+ emitcode ("clr", "a");
+ }
while (size--)
{
- aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
offset++;
}
}
{
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
+ offset);
offset++;
}
}
+ adjustArithmeticResult (ic);
release:
- freeAsmop (right, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
+ freeAsmop (right, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
char *l;
unsigned int count;
- D(emitcode ("; genJumpTab",""));
+ D (emitcode (";", "genJumpTab"));
count = elementsInSet( IC_JTLABELS (ic) );
/* 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 (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));
+ if (aopGetUsesAcc (IC_JTCOND (ic), 0))
+ {
+ emitcode ("mov", "b,#0x03");
+ 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);
emitcode ("mov", "dptr,#%05d$", jtab->key + 100);
emitcode ("jmp", "@a+dptr");
- emitcode ("", "%05d$:", jtab->key + 100);
+ emitLabel (jtab);
/* now generate the jump labels */
for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab;
jtab = setNextItem (IC_JTLABELS (ic)))
/* get the condition into accumulator.
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))
{
emitcode ("ret", "");
/* now generate jump table, LSB */
- emitcode ("", "%05d$:", jtablo->key + 100);
+ emitLabel (jtablo);
for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab;
jtab = setNextItem (IC_JTLABELS (ic)))
emitcode (".db", "%05d$", jtab->key + 100);
/* now generate jump table, MSB */
- emitcode ("", "%05d$:", jtabhi->key + 100);
+ emitLabel (jtabhi);
for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab;
jtab = setNextItem (IC_JTLABELS (ic)))
emitcode (".db", "%05d$>>8", jtab->key + 100);
operand *right = IC_RIGHT (ic);
int size, offset;
- D(emitcode("; genCast",""));
+ D (emitcode (";", "genCast"));
/* if they are equivalent then do nothing */
if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
aopOp (result, ic, FALSE);
/* if the result is a bit (and not a bitfield) */
- // if (AOP_TYPE (result) == AOP_CRY)
- if (IS_BITVAR (OP_SYMBOL (result)->type)
- && !IS_BITFIELD (OP_SYMBOL (result)->type) )
+ if (IS_BIT (OP_SYMBOL (result)->type))
{
- /* if the right size is a literal then
- we know what the value is */
- if (AOP_TYPE (right) == AOP_LIT)
- {
- if (((int) operandLitValue (right)))
- aopPut (AOP (result), one, 0, isOperandVolatile (result, FALSE));
- else
- aopPut (AOP (result), zero, 0, isOperandVolatile (result, FALSE));
-
- goto release;
- }
-
- /* the right is also a bit variable */
- if (AOP_TYPE (right) == AOP_CRY)
- {
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
- goto release;
- }
-
- /* we need to or */
- toBoolean (right);
- aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+ assignBit (result, right);
goto release;
}
-
/* if they are the same size : or less */
if (AOP_SIZE (result) <= AOP_SIZE (right))
{
offset = 0;
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
+ offset);
offset++;
}
goto release;
}
-
/* if the result is of type pointer */
if (IS_PTR (ctype))
{
if (IS_GENPTR (ctype))
{
if (IS_PTR (type))
- p_type = DCL_TYPE (type);
+ {
+ p_type = DCL_TYPE (type);
+ }
else
{
if (SPEC_SCLS(etype)==S_REGISTER) {
offset = 0;
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
+ offset);
offset++;
}
/* the last byte depending on type */
exit(1);
}
- sprintf(gpValStr, "#0x%d", gpVal);
- aopPut (AOP (result), gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
+ sprintf(gpValStr, "#0x%02x", gpVal);
+ aopPut (result, gpValStr, GPTRSIZE - 1);
}
goto release;
}
offset = 0;
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
+ offset);
offset++;
}
goto release;
offset = 0;
while (size--)
{
- aopPut (AOP (result),
- aopGet (AOP (right), offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ aopPut (result,
+ aopGet (right, offset, FALSE, FALSE),
+ offset);
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++);
}
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++);
}
/* we are done hurray !!!! */
release:
- freeAsmop (right, NULL, ic, TRUE);
freeAsmop (result, NULL, ic, TRUE);
-
+ freeAsmop (right, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
if (!ifx)
return 0;
- D(emitcode ("; genDjnz",""));
-
/* if the if condition has a false label
then we cannot save */
if (IC_FALSE (ifx))
return 0;
- /* if the minus is not of the form
- a = a - 1 */
+ /* if the minus is not of the form a = a - 1 */
if (!isOperandEqual (IC_RESULT (ic), IC_LEFT (ic)) ||
!IS_OP_LITERAL (IC_RIGHT (ic)))
return 0;
return 0;
/* otherwise we can save BIG */
+
+ D (emitcode (";", "genDjnz"));
+
lbl = newiTempLabel (NULL);
lbl1 = newiTempLabel (NULL);
* 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);
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));
+ freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ ifx->generated = 1;
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);
- emitcode ("", "%05d$:", lbl->key + 100);
+ emitLabel (lbl);
emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
- emitcode ("", "%05d$:", lbl1->key + 100);
+ emitLabel (lbl1);
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+ if (!ifx->generated)
+ freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
ifx->generated = 1;
return 1;
}
static void
genReceive (iCode * ic)
{
- int size = getSize (operandType (IC_RESULT (ic)));
- int offset = 0;
- D(emitcode ("; genReceive",""));
+ int size = getSize (operandType (IC_RESULT (ic)));
+ int offset = 0;
- if (ic->argreg == 1) { /* first parameter */
- if (isOperandInFarSpace (IC_RESULT (ic)) &&
- (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
- IS_TRUE_SYMOP (IC_RESULT (ic)))) {
+ D (emitcode (";", "genReceive"));
+ if (ic->argreg == 1)
+ { /* first parameter */
+ if ((isOperandInFarSpace (IC_RESULT (ic)) ||
+ isOperandInPagedSpace (IC_RESULT (ic))) &&
+ (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
+ IS_TRUE_SYMOP (IC_RESULT (ic))))
+ {
regs *tempRegs[4];
int receivingA = 0;
int roffset = 0;
_G.accInUse++;
aopOp (IC_RESULT (ic), ic, FALSE);
_G.accInUse--;
- aopPut (AOP (IC_RESULT (ic)), "a", offset,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset);
for (offset = 1; offset<size; offset++)
- aopPut (AOP (IC_RESULT (ic)), tempRegs[--roffset]->name, offset,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset);
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,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset);
goto release;
}
}
offset = fReturnSizeMCS51 - size;
- while (size--) {
+ while (size--)
+ {
emitcode ("push", "%s", (strcmp (fReturn[fReturnSizeMCS51 - offset - 1], "a") ?
fReturn[fReturnSizeMCS51 - offset - 1] : "acc"));
offset++;
- }
+ }
aopOp (IC_RESULT (ic), ic, FALSE);
size = AOP_SIZE (IC_RESULT (ic));
offset = 0;
- while (size--) {
+ while (size--)
+ {
emitcode ("pop", "acc");
- aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
- }
-
- } else {
+ aopPut (IC_RESULT (ic), "a", offset++);
+ }
+ }
+ else
+ {
_G.accInUse++;
aopOp (IC_RESULT (ic), ic, FALSE);
_G.accInUse--;
- assignResultValue (IC_RESULT (ic));
- }
- } else { /* second receive onwards */
+ assignResultValue (IC_RESULT (ic), NULL);
+ }
+ }
+ else if (ic->argreg > 12)
+ { /* bit parameters */
+ 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]);
+ outBitC(IC_RESULT (ic));
+ }
+ }
+ else
+ { /* other parameters */
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));
- }
- }
+ while (size--)
+ {
+ aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++);
+ }
+ }
release:
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
operand *op;
int size, offset;
- D(emitcode("; genDummyRead",""));
+ D (emitcode(";", "genDummyRead"));
op = IC_RIGHT (ic);
if (op && IS_SYMOP (op))
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++;
}
}
{
symbol *tlbl = newiTempLabel (NULL);
- D(emitcode("; genCritical",""));
+ D (emitcode(";", "genCritical"));
if (IC_RESULT (ic))
{
aopOp (IC_RESULT (ic), ic, TRUE);
- aopPut (AOP (IC_RESULT (ic)), one, 0, 0);
+ aopPut (IC_RESULT (ic), one, 0); /* save old ea in an operand */
emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
- aopPut (AOP (IC_RESULT (ic)), zero, 0, 0);
- emitcode ("", "%05d$:", (tlbl->key + 100));
+ aopPut (IC_RESULT (ic), zero, 0);
+ emitLabel (tlbl);
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
}
else
emitcode ("setb", "c");
emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
emitcode ("clr", "c");
- emitcode ("", "%05d$:", (tlbl->key + 100));
+ emitLabel (tlbl);
emitcode ("push", "psw"); /* save old ea via c in psw on top of stack*/
}
}
static void
genEndCritical (iCode *ic)
{
- D(emitcode("; genEndCritical",""));
+ D(emitcode(";", "genEndCritical"));
if (IC_RIGHT (ic))
{
else
{
if (AOP_TYPE (IC_RIGHT (ic)) != AOP_DUMMY)
- MOVA (aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
+ MOVA (aopGet (IC_RIGHT (ic), 0, FALSE, FALSE));
emitcode ("rrc", "a");
emitcode ("mov", "ea,c");
}
/* print the allocation information */
if (allocInfo && currFunc)
- printAllocInfo (currFunc, codeOutFile);
+ printAllocInfo (currFunc, codeOutBuf);
/* if debug information required */
if (options.debug && currFunc)
{
debugFile->writeCLine (ic);
}
if (!options.noCcodeInAsm) {
- emitcode ("", ";%s:%d: %s", ic->filename, ic->lineno,
+ emitcode (";", "%s:%d: %s", ic->filename, ic->lineno,
printCLine(ic->filename, ic->lineno));
}
cln = ic->lineno;
#if 0
if (ic->seqPoint && ic->seqPoint != cseq)
{
- emitcode ("", "; sequence point %d", ic->seqPoint);
+ emitcode (";", "sequence point %d", ic->seqPoint);
cseq = ic->seqPoint;
}
#endif
if (options.iCodeInAsm) {
char regsInUse[80];
int i;
+ const char *iLine;
+ #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;
- emitcode("", "; [%s] ic:%d: %s", regsInUse, ic->seq, printILine(ic));
+ #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
+ }
+ iLine = printILine(ic);
+ emitcode(";", "[%s] ic:%d: %s", regsInUse, ic->seq, iLine);
+ dbuf_free(iLine);
}
/* if the result is marked as
spilt and rematerializable or code for
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:
case NE_OP:
/* note these two are xlated by algebraic equivalence
- during parsing SDCC.y */
+ in decorateType() in SDCCast.c */
werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
"got '>=' or '<=' shouldn't have come here");
break;
genGetHbit (ic);
break;
+ case GETABIT:
+ genGetAbit (ic);
+ break;
+
+ case GETBYTE:
+ genGetByte (ic);
+ break;
+
+ case GETWORD:
+ genGetWord (ic);
+ break;
+
case LEFT_OP:
genLeftShift (ic);
break;
case '=':
if (POINTER_SET (ic))
- genPointerSet (ic, hasInc (IC_RESULT(ic),ic,getSize(operandType(IC_RIGHT(ic)))));
+ genPointerSet (ic,
+ hasInc (IC_RESULT (ic), ic,
+ getSize (operandType (IC_RIGHT (ic)))));
else
genAssign (ic);
break;
peepHole (&lineHead);
/* now do the actual printing */
- printLine (lineHead, codeOutFile);
+ printLine (lineHead, codeOutBuf);
return;
}