#include "SDCCglobl.h"
#include "newalloc.h"
-#ifdef HAVE_SYS_ISA_DEFS_H
-#include <sys/isa_defs.h>
-#else
-#ifdef HAVE_MACHINE_ENDIAN_H
-#include <machine/endian.h>
-#else
-#ifdef HAVE_ENDIAN_H
-#include <endian.h>
-#else
-#if !defined(__BORLANDC__) && !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-#warning "Cannot determine ENDIANESS of this machine assuming LITTLE_ENDIAN"
-#warning "If you running sdcc on an INTEL 80x86 Platform you are okay"
-#endif
-#endif
-#endif
-#endif
-
#include "common.h"
#include "SDCCpeeph.h"
#include "ralloc.h"
}
_G;
+static char *rb1regs[] = {
+ "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7"
+};
+
extern int mcs51_ptrRegReq;
extern int mcs51_nRegs;
extern FILE *codeOutFile;
(IC_RESULT(x) && IC_RESULT(x)->aop && \
IC_RESULT(x)->aop->type == AOP_STK )
-#define MOVA(x) if (strcmp(x,"a") && strcmp(x,"acc")) emitcode("mov","a,%s",x);
+#define MOVA(x) mova(x) /* use function to avoid multiple eval */
#define CLRC emitcode("clr","c")
#define SETC emitcode("setb","c")
va_end (ap);
}
+/*-----------------------------------------------------------------*/
+/* mova - moves specified value into accumulator */
+/*-----------------------------------------------------------------*/
+static void
+mova (char *x)
+{
+ /* do some early peephole optimization */
+ if (!strcmp(x, "a") || !strcmp(x, "acc"))
+ return;
+
+ emitcode("mov","a,%s", x);
+}
+
/*-----------------------------------------------------------------*/
/* getFreePtr - returns r0 or r1 whichever is free or can be pushed */
/*-----------------------------------------------------------------*/
{
iCode *ic = sym->rematiCode;
asmop *aop = newAsmop (AOP_IMMD);
- int ptr_type ;
+ int ptr_type=0;
int val = 0;
for (;;)
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;
}
/* if already has a asmop then continue */
- if (op->aop)
+ if (op->aop )
return;
/* if the underlying symbol has a aop */
}
/* else spill location */
+ if (sym->usl.spillLoc && getSize(sym->type) != getSize(sym->usl.spillLoc->type)) {
+ /* force a new aop if sizes differ */
+ sym->usl.spillLoc->aop = NULL;
+ }
sym->aop = op->aop = aop =
aopForSym (ic, sym->usl.spillLoc, result);
aop->size = getSize (sym->type);
}
}
+/*-----------------------------------------------------------------*/
+/* aopGetUsesAcc - indicates ahead of time whether aopGet() will */
+/* clobber the accumulator */
+/*-----------------------------------------------------------------*/
+static bool
+aopGetUsesAcc (asmop *aop, int offset)
+{
+ if (offset > (aop->size - 1))
+ return FALSE;
+
+ switch (aop->type)
+ {
+
+ case AOP_R0:
+ case AOP_R1:
+ if (aop->paged)
+ return TRUE;
+ return FALSE;
+ case AOP_DPTR:
+ return TRUE;
+ case AOP_IMMD:
+ return FALSE;
+ case AOP_DIR:
+ return FALSE;
+ case AOP_REG:
+ wassert(strcmp(aop->aopu.aop_reg[offset]->name, "a"));
+ return FALSE;
+ case AOP_CRY:
+ return TRUE;
+ case AOP_ACC:
+ return TRUE;
+ case AOP_LIT:
+ return FALSE;
+ case AOP_STR:
+ if (strcmp (aop->aopu.aop_str[offset], "a") == 0)
+ return TRUE;
+ return FALSE;
+ default:
+ /* Error case --- will have been caught already */
+ wassert(0);
+ return FALSE;
+ }
+}
+
+
/*-----------------------------------------------------------------*/
/* aopGet - for fetching value of the aop */
/*-----------------------------------------------------------------*/
return rs;
case AOP_DPTR:
+ if (aop->code && aop->coff==0 && offset>=1) {
+ emitcode ("mov", "a,#0x%02x", offset);
+ emitcode ("movc", "a,@a+dptr");
+ return (dname ? "acc" : "a");
+ }
+
while (offset > aop->coff)
{
emitcode ("inc", "dptr");
if (strcmp (s, "a") == 0)
emitcode ("push", "acc");
else
- emitcode ("push", "%s", s);
+ if (*s=='@') {
+ MOVA(s);
+ emitcode ("push", "acc");
+ } else {
+ emitcode ("push", s);
+ }
break;
MOVA (s);
}
{
- symbol *lbl = newiTempLabel (NULL);
- emitcode ("clr", "c");
- emitcode ("jz", "%05d$", lbl->key + 100);
- emitcode ("cpl", "c");
- emitcode ("", "%05d$:", lbl->key + 100);
+ /* set C, if a >= 1 */
+ emitcode ("add", "a,#0xff");
emitcode ("mov", "%s,c", aop->aopu.aop_dir);
}
}
char *l;
symbol *tlbl;
- D(emitcode (";", "genNotFloat"));
+ D(emitcode ("; genNotFloat",""));
/* we will put 127 in the first byte of
the result */
symbol *tlbl;
sym_link *optype = operandType (IC_LEFT (ic));
- D(emitcode (";", "genNot"));
+ D(emitcode ("; genNot",""));
/* assign asmOps to operand & result */
aopOp (IC_LEFT (ic), ic, FALSE);
{
int offset = 0;
int size;
+ symbol *tlbl;
-
- D(emitcode (";", "genCpl"));
+ D(emitcode ("; genCpl",""));
/* assign asmOps to operand & result */
aopOp (IC_LEFT (ic), ic, FALSE);
aopOp (IC_RESULT (ic), ic, TRUE);
- /* if both are in bit space then
- a special case */
- if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY &&
- AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
- {
-
+ /* special case if in bit space */
+ if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY) {
+ if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY) {
emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
emitcode ("cpl", "c");
emitcode ("mov", "%s,c", IC_RESULT (ic)->aop->aopu.aop_dir);
goto release;
}
+ tlbl=newiTempLabel(NULL);
+ emitcode ("cjne", "%s,#0x01,%05d$",
+ aopGet(AOP(IC_LEFT(ic)), 0, FALSE,FALSE), tlbl->key+100);
+ emitcode ("", "%05d$:", tlbl->key+100);
+ outBitC (IC_RESULT(ic));
+ goto release;
+ }
size = AOP_SIZE (IC_RESULT (ic));
while (size--)
int size, offset = 0;
char *l;
- D(emitcode (";", "genUminusFloat"));
+ D(emitcode ("; genUminusFloat",""));
- /* for this we just need to flip the
- first it then copy the rest in place */
- size = AOP_SIZE (op) - 1;
- l = aopGet (AOP (op), 3, FALSE, FALSE);
-
- MOVA (l);
+ /* for this we just copy and then flip the bit */
- emitcode ("cpl", "acc.7");
- aopPut (AOP (result), "a", 3);
+ size = AOP_SIZE (op) - 1;
while (size--)
{
offset);
offset++;
}
+
+ l = aopGet (AOP (op), offset, FALSE, FALSE);
+
+ MOVA (l);
+
+ emitcode ("cpl", "acc.7");
+ aopPut (AOP (result), "a", offset);
}
/*-----------------------------------------------------------------*/
sym_link *optype, *rtype;
- D(emitcode (";", "genUminus"));
+ D(emitcode ("; genUminus",""));
/* assign asmops */
aopOp (IC_LEFT (ic), ic, FALSE);
/* if the registers have been saved already or don't need to be then
do nothing */
- if (ic->regsSaved || IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type) ||
- IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT (ic))))
+ 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)))))
+ return;
+
/* safe the registers in use at this time but skip the
ones for the result */
rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
regs *r;
int size, offset = 0;
- D(emitcode (";", "genXpush"));
+ D(emitcode ("; genXpush",""));
aopOp (IC_LEFT (ic), ic, FALSE);
r = getFreePtr (ic, &aop, FALSE);
int size, offset = 0;
char *l;
- 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 */
{
int size, offset;
- D(emitcode (";", "genIpop"));
+ D(emitcode ("; genIpop",""));
/* if the temp was not pushed then */
if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
}
}
+/*-----------------------------------------------------------------*/
+/* genSend - gen code for SEND */
+/*-----------------------------------------------------------------*/
+static void genSend(set *sendSet)
+{
+ iCode *sic;
+ int rb1_count = 0 ;
+
+ for (sic = setFirstItem (_G.sendSet); sic;
+ sic = setNextItem (_G.sendSet)) {
+ int size, offset = 0;
+ aopOp (IC_LEFT (sic), sic, FALSE);
+ size = AOP_SIZE (IC_LEFT (sic));
+
+ if (sic->argreg == 1) {
+ while (size--) {
+ char *l = aopGet (AOP (IC_LEFT (sic)), offset,
+ FALSE, FALSE);
+ if (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));
+ }
+ }
+ freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+ }
+}
+
/*-----------------------------------------------------------------*/
/* genCall - generates a call statement */
/*-----------------------------------------------------------------*/
genCall (iCode * ic)
{
sym_link *dtype;
- bool restoreBank = FALSE;
+// bool restoreBank = FALSE;
bool swapBanks = FALSE;
- D(emitcode(";", "genCall"));
+ D(emitcode("; genCall",""));
+ dtype = operandType (IC_LEFT (ic));
/* if send set is not empty the assign */
if (_G.sendSet)
{
- iCode *sic;
-
- for (sic = setFirstItem (_G.sendSet); sic;
- sic = setNextItem (_G.sendSet))
- {
- int size, offset = 0;
- aopOp (IC_LEFT (sic), sic, FALSE);
- size = AOP_SIZE (IC_LEFT (sic));
- while (size--)
- {
- char *l = aopGet (AOP (IC_LEFT (sic)), offset,
- FALSE, FALSE);
- if (strcmp (l, fReturn[offset]))
- emitcode ("mov", "%s,%s",
- fReturn[offset],
- l);
- offset++;
- }
- freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+ if (IFFUNC_ISREENT(dtype)) { /* need to reverse the send set */
+ genSend(reverseSet(_G.sendSet));
+ } else {
+ genSend(_G.sendSet);
}
+
_G.sendSet = NULL;
}
the same register bank then we need to save the
destination registers on the stack */
dtype = operandType (IC_LEFT (ic));
- if (dtype && !IFFUNC_ISNAKED(dtype) &&
+ if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
(FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
- IFFUNC_ISISR (currFunc->type))
+ !IFFUNC_ISISR (dtype))
{
- if (!ic->bankSaved)
- {
- /* This is unexpected; the bank should have been saved in
- * genFunction.
- */
- saveRBank (FUNC_REGBANK (dtype), ic, FALSE);
- restoreBank = TRUE;
- }
swapBanks = TRUE;
}
/* if we need assign a result value */
if ((IS_ITEMP (IC_RESULT (ic)) &&
(OP_SYMBOL (IC_RESULT (ic))->nRegs ||
+ OP_SYMBOL (IC_RESULT (ic))->accuse ||
OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
IS_TRUE_SYMOP (IC_RESULT (ic)))
{
if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
unsaveRegisters (ic);
- /* if register bank was saved then pop them */
- if (restoreBank)
- unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
+// /* if register bank was saved then pop them */
+// if (restoreBank)
+// unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
}
/*-----------------------------------------------------------------*/
-/* genPcall - generates a call by pointer statement */
+/* -10l - generates a call by pointer statement */
/*-----------------------------------------------------------------*/
static void
genPcall (iCode * ic)
{
sym_link *dtype;
symbol *rlbl = newiTempLabel (NULL);
- bool restoreBank=FALSE;
+// bool restoreBank=FALSE;
+ bool swapBanks = FALSE;
- D(emitcode(";", "genPCall"));
+ D(emitcode("; genPCall",""));
/* if caller saves & we have not saved then */
if (!ic->regsSaved)
saveRegisters (ic);
- /* if we are calling a function that is not using
+ /* 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 (dtype && !FUNC_ISNAKED(dtype) &&
- IFFUNC_ISISR (currFunc->type) &&
- (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype))) {
- saveRBank (FUNC_REGBANK (dtype), ic, TRUE);
- restoreBank=TRUE;
+ dtype = operandType (IC_LEFT (ic))->next;
+ 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 */
/* if send set is not empty the assign */
if (_G.sendSet)
{
- iCode *sic;
-
- for (sic = setFirstItem (_G.sendSet); sic;
- sic = setNextItem (_G.sendSet))
- {
- int size, offset = 0;
- aopOp (IC_LEFT (sic), sic, FALSE);
- size = AOP_SIZE (IC_LEFT (sic));
- while (size--)
- {
- char *l = aopGet (AOP (IC_LEFT (sic)), offset,
- FALSE, FALSE);
- if (strcmp (l, fReturn[offset]))
- emitcode ("mov", "%s,%s",
- fReturn[offset],
- l);
- offset++;
- }
- freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
- }
- _G.sendSet = NULL;
+ genSend(reverseSet(_G.sendSet));
+ _G.sendSet = NULL;
}
+ if (swapBanks)
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+ }
+
+ /* make the call */
emitcode ("ret", "");
emitcode ("", "%05d$:", (rlbl->key + 100));
+ if (swapBanks)
+ {
+ emitcode ("mov", "psw,#0x%02x",
+ ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
+ }
+
/* if we need assign a result value */
if ((IS_ITEMP (IC_RESULT (ic)) &&
(OP_SYMBOL (IC_RESULT (ic))->nRegs ||
}
- /* if register bank was saved then unsave them */
- if (restoreBank)
- unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
+// /* 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 */
symbol *sym;
sym_link *ftype;
bool switchedPSW = FALSE;
+ int calleesaves_saved_register = -1;
_G.nRegsSaved = 0;
/* create the function header */
}
else
{
+
/* this function has a function call cannot
determines register usage so we will have to push the
entire bank */
- saveRBank (0, ic, FALSE);
+ saveRBank (0, ic, FALSE);
+ if (options.parms_in_bank1) {
+ int i;
+ for (i=0; i < 8 ; i++ ) {
+ emitcode ("push","%s",rb1regs[i]);
+ }
+ }
}
}
else
}
}
}
- // jwk: this needs a closer look
+ // TODO: this needs a closer look
SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
}
}
if (bitVectBitValue (sym->regsUsed, i) ||
(mcs51_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
{
+ /* remember one saved register for later usage */
+ if (calleesaves_saved_register < 0)
+ calleesaves_saved_register = i;
emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
_G.nRegsSaved++;
}
}
/* set the register bank to the desired value */
- if ((FUNC_REGBANK (sym->type) || IFFUNC_ISISR (sym->type))
+ if (( /* FUNC_REGBANK (sym->type) || */ IFFUNC_ISISR (sym->type))
&& !switchedPSW)
{
emitcode ("push", "psw");
emitcode ("mov", "sp,a");
}
+ else if (i > 5)
+ {
+ if (IFFUNC_CALLEESAVES(sym->type))
+ {
+ /* 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", "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);
+ }
+ else
+ /* do it the hard way */
+ while (i--)
+ emitcode ("inc", "sp");
+ }
+ else
+ {
+ /* not callee-saves, we can clobber r0 */
+ emitcode ("mov", "r0,a");
+ emitcode ("mov", "a,sp");
+ emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
+ emitcode ("mov", "sp,a");
+ emitcode ("mov", "a,r0");
+ }
+ }
else
while (i--)
emitcode ("inc", "sp");
}
/* 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)
+ if (/* !FUNC_REGBANK (sym->type) || */ !IFFUNC_ISISR (sym->type)
|| !options.useXstack)
{
/* Special case of ISR using non-zero bank with useXstack
}
else
{
+ if (options.parms_in_bank1) {
+ int i;
+ 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
entire bank */
* Restore any register banks saved by genFunction
* in reverse order.
*/
- // jwk: this needs a closer look
unsigned savedBanks = SPEC_ISR_SAVED_BANKS(currFunc->etype);
int ix;
emitcode ("setb", "ea");
/* if debug then send end of function */
- /* if (options.debug && currFunc) */
if (options.debug && currFunc)
{
_G.debugLine = 1;
{
int size, offset = 0, pushed = 0;
+ D(emitcode ("; genRet",""));
+
/* if we have no return value then
just generate the "ret" */
if (!IC_LEFT (ic))
ic = ic->prev;
count++;
+ /* If we have any pushes or pops, we cannot predict the distance.
+ I don't like this at all, this should be dealt with in the
+ back-end */
+ if (ic->op == IPUSH || ic->op == IPOP) {
+ return 0;
+ }
+
if (ic->op == LABEL && IC_LABEL (ic)->key == key)
{
- /* printf("findLabelBackwards = %d\n", count); */
return count;
}
}
unsigned int icount;
unsigned int size = getDataSize (IC_RESULT (ic));
- D(emitcode (";", "genPlusIncr"));
-
/* will try to generate an increment */
/* if the right side is not a literal
we cannot */
if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
return FALSE;
- /* if increment 16 bits in register */
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
+ D(emitcode ("; genPlusIncr",""));
+
+ /* if increment >=16 bits in register or direct space */
+ if ((AOP_TYPE(IC_LEFT(ic)) == AOP_REG || AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) &&
+ sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
(size > 1) &&
(icount == 1))
{
emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "%s,#0x00,%05d$",
+ aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE),
+ tlbl->key + 100);
else
{
emitcode ("clr", "a");
- emitcode ("cjne", "a,%s,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "a,%s,%05d$",
+ aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE),
+ tlbl->key + 100);
}
emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE));
{
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "%s,#0x00,%05d$",
+ aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
+ 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$",
+ aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
+ tlbl->key + 100);
emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE));
}
{
if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
IS_AOP_PREG (IC_RESULT (ic)))
- emitcode ("cjne", "%s,#0x00,%05d$"
- ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE)
- ,tlbl->key + 100);
+ emitcode ("cjne", "%s,#0x00,%05d$",
+ aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
+ 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$",
+ aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
+ tlbl->key + 100);
}
emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
}
static void
genPlusBits (iCode * ic)
{
+ D(emitcode ("; genPlusBits",""));
+
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
symbol *lbl = newiTempLabel (NULL);
genPlus (iCode * ic)
{
int size, offset = 0;
+ char *add;
+ asmop *leftOp, *rightOp;
/* special cases :- */
- D(emitcode (";", "genPlus"));
+ D(emitcode ("; genPlus",""));
aopOp (IC_LEFT (ic), ic, FALSE);
aopOp (IC_RIGHT (ic), ic, FALSE);
size = getDataSize (IC_RESULT (ic));
+ leftOp = AOP(IC_LEFT(ic));
+ rightOp = AOP(IC_RIGHT(ic));
+ add = "add";
+
while (size--)
{
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC)
+ if (aopGetUsesAcc (leftOp, offset) && aopGetUsesAcc (rightOp, offset))
{
- MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- if (offset == 0)
- emitcode ("add", "a,%s",
- aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- else
- emitcode ("addc", "a,%s",
- aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
+ emitcode("mov", "b,a");
+ MOVA (aopGet (leftOp, offset, FALSE, TRUE));
+ emitcode("xch", "a,b");
+ MOVA (aopGet (rightOp, offset, FALSE, TRUE));
+ emitcode (add, "a,b");
+ }
+ else if (aopGetUsesAcc (leftOp, offset))
+ {
+ MOVA (aopGet (leftOp, offset, FALSE, TRUE));
+ emitcode (add, "a,%s", aopGet (rightOp, offset, FALSE, TRUE));
}
else
{
- MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- if (offset == 0)
- emitcode ("add", "a,%s",
- aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- else
- emitcode ("addc", "a,%s",
- aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
+ MOVA (aopGet (rightOp, offset, FALSE, TRUE));
+ emitcode (add, "a,%s", aopGet (leftOp, offset, FALSE, TRUE));
}
aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+ add = "addc"; /* further adds must propagate carry */
}
adjustArithmeticResult (ic);
unsigned int icount;
unsigned int size = getDataSize (IC_RESULT (ic));
- D(emitcode (";", "genMinusDec"));
-
/* will try to generate an increment */
/* if the right side is not a literal
we cannot */
if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
return FALSE;
- /* if decrement 16 bits in register */
- if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
+ 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) &&
+ sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
(size > 1) &&
(icount == 1))
{
genMinusBits (iCode * ic)
{
symbol *lbl = newiTempLabel (NULL);
+
+ D(emitcode ("; genMinusBits",""));
+
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
genMinus (iCode * ic)
{
int size, offset = 0;
- unsigned long lit = 0L;
+
+ D(emitcode ("; genMinus",""));
aopOp (IC_LEFT (ic), ic, FALSE);
aopOp (IC_RIGHT (ic), ic, FALSE);
size = getDataSize (IC_RESULT (ic));
- if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
- {
- CLRC;
- }
- else
+ /* if literal, add a,#-lit, else normal subb */
+ if (AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT)
{
+ unsigned long lit = 0L;
+
lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
lit = -(long) lit;
- }
- /* if literal, add a,#-lit, else normal subb */
- while (size--)
- {
- MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
- if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
- emitcode ("subb", "a,%s",
- aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
- else
+ while (size--)
{
+ MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
/* first add without previous c */
if (!offset) {
if (!size && lit==-1) {
emitcode ("addc", "a,#0x%02x",
(unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
}
+ aopPut (AOP (IC_RESULT (ic)), "a", offset++);
}
- aopPut (AOP (IC_RESULT (ic)), "a", offset++);
}
+ else
+ {
+ asmop *leftOp, *rightOp;
+
+ leftOp = AOP(IC_LEFT(ic));
+ rightOp = AOP(IC_RIGHT(ic));
+ while (size--)
+ {
+ if (aopGetUsesAcc(rightOp, offset)) {
+ wassertl(!aopGetUsesAcc(leftOp, offset), "accumulator clash");
+ MOVA (aopGet(rightOp, offset, FALSE, TRUE));
+ if (offset == 0) {
+ emitcode( "setb", "c");
+ }
+ emitcode("subb", "a,%s", aopGet(leftOp, offset, FALSE, TRUE));
+ emitcode("cpl", "a");
+ } else {
+ MOVA (aopGet (leftOp, offset, FALSE, FALSE));
+ if (offset == 0)
+ CLRC;
+ emitcode ("subb", "a,%s",
+ aopGet(rightOp, offset, FALSE, TRUE));
+ }
+
+ aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+ }
+ }
+
+
adjustArithmeticResult (ic);
release:
operand * right,
operand * result)
{
+ D(emitcode ("; genMultbits",""));
+
emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
outBitC (result);
symbol *lbl;
int size=AOP_SIZE(result);
+ D(emitcode ("; genMultOneByte",""));
+
if (size<1 || size>2) {
// this should never happen
fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n",
SPEC_USIGN(operandType(right)))) {
// just an unsigned 8*8=8/16 multiply
//emitcode (";","unsigned");
+ // TODO: check for accumulator clash between left & right aops?
emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
emitcode ("mul", "ab");
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
+ D(emitcode ("; genMult",""));
+
/* assign the amsops */
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
char *l;
+ D(emitcode ("; genDivbits",""));
+
/* the result must be bit */
emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
l = aopGet (AOP (left), 0, FALSE, FALSE);
symbol *lbl;
int size, offset;
+ D(emitcode ("; genDivOneByte",""));
+
size = AOP_SIZE (result) - 1;
offset = 1;
/* signed or unsigned */
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
+ D(emitcode ("; genDiv",""));
+
/* assign the amsops */
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
char *l;
+ D(emitcode ("; genModbits",""));
+
/* the result must be bit */
emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
l = aopGet (AOP (left), 0, FALSE, FALSE);
char *l;
symbol *lbl;
+ D(emitcode ("; genModOneByte",""));
+
/* signed or unsigned */
if (SPEC_USIGN (opetype))
{
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
+ D(emitcode ("; genMod",""));
+
/* assign the amsops */
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
symbol *tlbl = newiTempLabel (NULL);
char *inst;
+ D(emitcode ("; genIfxJump",""));
+
/* if true label then we jump if condition
supplied is true */
if (IC_TRUE (ic))
int size, offset = 0;
unsigned long lit = 0L;
+ D(emitcode ("; genCmp",""));
+
/* if left & right are bit variables */
if (AOP_TYPE (left) == AOP_CRY &&
AOP_TYPE (right) == AOP_CRY)
{
emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- emitcode ("anl", "c,/%s", AOP (left)->aopu.aop_dir);
+ emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
}
else
{
sym_link *letype, *retype;
int sign;
+ D(emitcode ("; genCmpGt",""));
+
left = IC_LEFT (ic);
right = IC_RIGHT (ic);
result = IC_RESULT (ic);
sym_link *letype, *retype;
int sign;
+ D(emitcode ("; genCmpLt",""));
+
left = IC_LEFT (ic);
right = IC_RIGHT (ic);
result = IC_RESULT (ic);
{
operand *left, *right, *result;
+ D(emitcode ("; genCmpEq",""));
+
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
/* hasInc - operand is incremented before any other use */
/*-----------------------------------------------------------------*/
static iCode *
-hasInc (operand *op, iCode *ic)
+hasInc (operand *op, iCode *ic,int osize)
{
sym_link *type = operandType(op);
sym_link *retype = getSpec (type);
if (!IS_SYMOP(op)) return NULL;
if (IS_BITVAR(retype)||!IS_PTR(type)) return NULL;
- isize = getSize(type->next);
+ 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) &&
if (bitVectBitValue(OP_USES(op),lic->key) || (unsigned) lic->defKey == op->key) {
return NULL;
}
+ /* 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",""));
+
/* note here that && operations that are in an
if statement are taken away by backPatchLabels
only those used in arthmetic operations remain */
operand *left, *right, *result;
symbol *tlbl;
+ D(emitcode ("; genOrOp",""));
+
/* note here that || operations that are in an
if statement are taken away by backPatchLabels
only those used in arthmetic operations remain */
int bytelit = 0;
char buffer[10];
+ D(emitcode ("; genAnd",""));
+
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
int size, offset = 0;
unsigned long lit = 0L;
+ D(emitcode ("; genOr",""));
+
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
{
if (AOP_TYPE (right) == AOP_LIT)
{
- // c = bit & literal;
+ // c = bit | literal;
if (lit)
{
// lit != 0 => result = 1
int size, offset = 0;
unsigned long lit = 0L;
- D(emitcode (";", "genXor"));
+ D(emitcode ("; genXor",""));
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
{
char *buffer, *bp, *bp1;
- D(emitcode (";", "genInline"));
+ D(emitcode ("; genInline",""));
_G.inLine += (!options.asmpeep);
int size, offset = 0;
char *l;
- D(emitcode (";", "genRRC"));
+ D(emitcode ("; genRRC",""));
/* rotate right with carry */
left = IC_LEFT (ic);
int size, offset = 0;
char *l;
- D(emitcode (";", "genRLC"));
+ D(emitcode ("; genRLC",""));
/* rotate right with carry */
left = IC_LEFT (ic);
{
operand *left, *result;
- D(emitcode (";", "genGetHbit"));
+ D(emitcode ("; genGetHbit",""));
left = IC_LEFT (ic);
result = IC_RESULT (ic);
emitcode ("mov", "c,acc.7");
AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA
+ emitcode ("mov", "c,acc.7");
AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA
emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC
emitcode ("mov", "c,acc.7");
AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA
+ emitcode ("mov", "c,acc.7");
AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA
emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC
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);
{
int size;
- D(emitcode (";", "genlshFour"));
+ D(emitcode ("; genlshFour",""));
size = AOP_SIZE (result);
int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
int size;
- D(emitcode (";", "genLeftShiftLiteral"));
+ D(emitcode ("; genLeftShiftLiteral",""));
freeAsmop (right, NULL, ic, TRUE);
genlshFour (result, left, shCount);
break;
default:
- fprintf(stderr, "*** ack! mystery literal shift!\n");
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "*** ack! mystery literal shift!\n");
break;
}
}
char *l;
symbol *tlbl, *tlbl1;
- D(emitcode (";", "genLeftShift"));
+ D(emitcode ("; genLeftShift",""));
right = IC_RIGHT (ic);
left = IC_LEFT (ic);
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)
if (sign) {
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
- emitcode ("xch", "a,%s", aopGet(AOP(left), MSB32, FALSE, FALSE));
+ if (isSameRegs)
+ emitcode ("xch", "a,%s", aopGet(AOP(left), MSB32, FALSE, FALSE));
+ else {
+ aopPut (AOP (result), "a", MSB32);
+ MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
+ }
} else {
aopPut (AOP(result), zero, MSB32);
}
if (isSameRegs && offl==MSB16) {
emitcode ("xch", "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE));
} else {
- aopPut (AOP (result), "a", MSB32);
+ aopPut (AOP (result), "a", MSB32-offl);
MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
}
if (isSameRegs && offl==1) {
emitcode ("xch", "a,%s",aopGet (AOP (left), MSB16, FALSE, FALSE));
} else {
- aopPut (AOP (result), "a", MSB24);
+ aopPut (AOP (result), "a", MSB24-offl);
MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
}
emitcode ("rrc", "a");
genrshFour (operand * result, operand * left,
int shCount, int sign)
{
- D(emitcode (";", "genrshFour"));
+ D(emitcode ("; genrshFour",""));
/* if shifting more that 3 bytes */
if (shCount >= 24)
int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
int size;
- D(emitcode (";", "genRightShiftLiteral"));
+ D(emitcode ("; genRightShiftLiteral",""));
freeAsmop (right, NULL, ic, TRUE);
else if (shCount >= (size * 8))
{
- if (sign)
+ if (sign) {
/* get sign in acc.7 */
MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE));
+ }
addSign (result, LSB, sign);
}
else
default:
break;
}
-
- freeAsmop (left, NULL, ic, TRUE);
- freeAsmop (result, NULL, ic, TRUE);
}
+ freeAsmop (left, NULL, ic, TRUE);
+ freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
char *l;
symbol *tlbl, *tlbl1;
- D(emitcode (";", "genSignedRightShift"));
+ D(emitcode ("; genSignedRightShift",""));
/* we do it the hard way put the shift count in b
and loop thru preserving the sign */
char *l;
symbol *tlbl, *tlbl1;
- D(emitcode (";", "genRightShift"));
+ D(emitcode ("; genRightShift",""));
/* if signed then we do it the hard way preserve the
sign bit moving it inwards */
int offset = 0;
int rsize;
- D(emitcode (";", "genUnpackBits"));
+ D(emitcode ("; genUnpackBits",""));
etype = getSpec (operandType (result));
rsize = getSize (operandType (result));
char buffer[256];
int size, offset = 0;
- D(emitcode (";", "genDataPointerGet"));
+ D(emitcode ("; genDataPointerGet",""));
aopOp (result, ic, TRUE);
sym_link *ltype = operandType (left);
char buffer[80];
- D(emitcode (";", "genNearPointerGet"));
+ D(emitcode ("; genNearPointerGet",""));
rtype = operandType (result);
retype = getSpec (rtype);
char *rname;
sym_link *rtype, *retype;
- D(emitcode (";", "genPagedPointerGet"));
+ D(emitcode ("; genPagedPointerGet",""));
rtype = operandType (result);
retype = getSpec (rtype);
int size, offset;
sym_link *retype = getSpec (operandType (result));
- D(emitcode (";", "genFarPointerGet"));
+ D(emitcode ("; genFarPointerGet",""));
aopOp (left, ic, FALSE);
int size, offset;
sym_link *retype = getSpec (operandType (result));
- D(emitcode (";", "genCodePointerGet"));
+ D(emitcode ("; genCodePointerGet",""));
aopOp (left, ic, FALSE);
while (size--)
{
- emitcode ("clr", "a");
- emitcode ("movc", "a,@a+dptr");
- aopPut (AOP (result), "a", offset++);
- if (size || pi)
- emitcode ("inc", "dptr");
+ if (pi)
+ {
+ emitcode ("clr", "a");
+ emitcode ("movc", "a,@a+dptr");
+ aopPut (AOP (result), "a", offset++);
+ emitcode ("inc", "dptr");
+ }
+ else
+ {
+ emitcode ("mov", "a,#0x%02x", offset);
+ emitcode ("movc", "a,@a+dptr");
+ aopPut (AOP (result), "a", offset++);
+ }
}
}
int size, offset;
sym_link *retype = getSpec (operandType (result));
- D(emitcode (";", "genGenPointerGet"));
+ D(emitcode ("; genGenPointerGet",""));
aopOp (left, ic, FALSE);
if (AOP_TYPE (left) == AOP_IMMD)
{
emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE));
- emitcode ("mov", "b,#%d", pointerCode (retype));
+ if (AOP(left)->aopu.aop_immd.from_cast_remat)
+ emitcode ("mov", "b,%s",aopGet(AOP (left), AOP_SIZE(left)-1, FALSE, FALSE));
+ else
+ emitcode ("mov", "b,#%d", pointerCode (retype));
}
else
{ /* we need to get it byte by byte */
if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR) {
aopPut ( AOP (left), "dpl", 0);
aopPut ( AOP (left), "dph", 1);
+ aopPut ( AOP (left), "b", 2);
pi->generated = 1;
}
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);
p_type = PTR_TYPE (SPEC_OCLS (etype));
}
+ /* 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);
+ }
/* now that we have the pointer type we assign
the pointer values */
switch (p_type)
int blen, bstr;
char *l;
- D(emitcode (";", "genPackBits"));
+ D(emitcode ("; genPackBits",""));
blen = SPEC_BLEN (etype);
bstr = SPEC_BSTR (etype);
int size, offset = 0;
char *l, buffer[256];
- D(emitcode (";", "genDataPointerSet"));
+ D(emitcode ("; genDataPointerSet",""));
aopOp (right, ic, FALSE);
sym_link *retype, *letype;
sym_link *ptype = operandType (result);
- D(emitcode (";", "genNearPointerSet"));
+ D(emitcode ("; genNearPointerSet",""));
retype = getSpec (operandType (right));
letype = getSpec (ptype);
char *rname, *l;
sym_link *retype, *letype;
- D(emitcode (";", "genPagedPointerSet"));
+ D(emitcode ("; genPagedPointerSet",""));
retype = getSpec (operandType (right));
letype = getSpec (operandType (result));
sym_link *retype = getSpec (operandType (right));
sym_link *letype = getSpec (operandType (result));
- D(emitcode (";", "genFarPointerSet"));
+ D(emitcode ("; genFarPointerSet",""));
aopOp (result, ic, FALSE);
sym_link *retype = getSpec (operandType (right));
sym_link *letype = getSpec (operandType (result));
- D(emitcode (";", "genGenPointerSet"));
+ D(emitcode ("; genGenPointerSet",""));
aopOp (result, ic, FALSE);
if (AOP_TYPE (result) == AOP_IMMD)
{
emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE));
- emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE));
+ if (AOP(result)->aopu.aop_immd.from_cast_remat)
+ emitcode ("mov", "b,%s",aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE));
+ else
+ emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE));
}
else
{ /* we need to get it byte by byte */
if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
aopPut (AOP(result),"dpl",0);
aopPut (AOP(result),"dph",1);
+ aopPut (AOP(result),"b",2);
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);
p_type = PTR_TYPE (SPEC_OCLS (etype));
}
+ /* special case when cast remat */
+ if (p_type == GPOINTER && OP_SYMBOL(result)->remat &&
+ IS_CAST_ICODE(OP_SYMBOL(result)->rematiCode)) {
+ result = IC_RIGHT(OP_SYMBOL(result)->rematiCode);
+ type = operandType (result);
+ p_type = DCL_TYPE (type);
+ }
/* now that we have the pointer type we assign
the pointer values */
switch (p_type)
case GPOINTER:
genGenPointerSet (right, result, ic, pi);
break;
+
+ default:
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "genPointerSet: illegal pointer type");
}
}
operand *cond = IC_COND (ic);
int isbit = 0;
- D(emitcode (";", "genIfx"));
+ D(emitcode ("; genIfx",""));
aopOp (cond, ic, FALSE);
symbol *sym = OP_SYMBOL (IC_LEFT (ic));
int size, offset;
- D(emitcode (";", "genAddrOf"));
+ D(emitcode ("; genAddrOf",""));
aopOp (IC_RESULT (ic), ic, FALSE);
if (sym->stack)
{
emitcode ("mov", "a,_bp");
- emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
+ emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ?
+ ((char) (sym->stack - _G.nRegsSaved)) :
+ ((char) sym->stack)) & 0xff);
aopPut (AOP (IC_RESULT (ic)), "a", 0);
}
else
int offset = 0;
char *l;
- D(emitcode (";", "genFarFarAssign"));
+ D(emitcode ("; genFarFarAssign",""));
/* first push the right side on to the stack */
while (size--)
int size, offset;
unsigned long lit = 0L;
- D(emitcode(";","genAssign"));
+ D(emitcode("; genAssign",""));
result = IC_RESULT (ic);
right = IC_RIGHT (ic);
/* if they are the same */
- if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
+ if (operandsEqu (result, right)) {
return;
+ }
aopOp (right, ic, FALSE);
symbol *jtab;
char *l;
- D(emitcode (";", "genJumpTab"));
+ D(emitcode ("; genJumpTab",""));
aopOp (IC_JTCOND (ic), ic, FALSE);
/* get the condition into accumulator */
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 */
- // if (AOP_TYPE (result) == AOP_CRY /* works only for true symbols */
if (IS_BITVAR(OP_SYMBOL(result)->type))
{
/* if the right size is a literal then
/* pointer to generic pointer */
if (IS_GENPTR (ctype))
{
- char *l = zero;
-
if (IS_PTR (type))
p_type = DCL_TYPE (type);
else
offset++;
}
/* the last byte depending on type */
- switch (p_type)
{
- case IPOINTER:
- case POINTER:
- l = zero;
- break;
- case FPOINTER:
- l = one;
- break;
- case CPOINTER:
- l = "#0x02";
- break;
- case GPOINTER:
- l = "0x03";
- break;
- case PPOINTER: // what the fck is this?
- l = "#0x03";
- break;
-
- default:
- /* this should never happen */
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "got unknown pointer type");
- exit (1);
- }
- aopPut (AOP (result), l, GPTRSIZE - 1);
+ int gpVal = pointerTypeToGPByte(p_type, NULL, NULL);
+ char gpValStr[10];
+
+ if (gpVal == -1)
+ {
+ // pointerTypeToGPByte will have bitched.
+ exit(1);
+ }
+
+ sprintf(gpValStr, "#0x%d", gpVal);
+ aopPut (AOP (result), gpValStr, GPTRSIZE - 1);
+ }
goto release;
}
/* now depending on the sign of the source && destination */
size = AOP_SIZE (result) - AOP_SIZE (right);
/* if unsigned or not an integral type */
- if (SPEC_USIGN (rtype) || !IS_SPEC (rtype) || AOP_TYPE(right)==AOP_CRY)
+ if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE(right)==AOP_CRY)
{
while (size--)
aopPut (AOP (result), zero, offset++);
if (!ifx)
return 0;
- D(emitcode (";", "genDjnz"));
+ D(emitcode ("; genDjnz",""));
/* if the if condition has a false label
then we cannot save */
static void
genReceive (iCode * ic)
{
- D(emitcode (";", "genReceive"));
-
- if (isOperandInFarSpace (IC_RESULT (ic)) &&
- (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
- IS_TRUE_SYMOP (IC_RESULT (ic))))
- {
-
- int size = getSize (operandType (IC_RESULT (ic)));
- int offset = fReturnSizeMCS51 - 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--)
- {
- emitcode ("pop", "acc");
- aopPut (AOP (IC_RESULT (ic)), "a", offset++);
- }
+ int size = getSize (operandType (IC_RESULT (ic)));
+ int offset = 0;
+ D(emitcode ("; genReceive",""));
- }
- else
- {
- _G.accInUse++;
+ if (ic->argreg == 1) { /* first parameter */
+ if (isOperandInFarSpace (IC_RESULT (ic)) &&
+ (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
+ IS_TRUE_SYMOP (IC_RESULT (ic)))) {
+
+ offset = fReturnSizeMCS51 - 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--) {
+ emitcode ("pop", "acc");
+ aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+ }
+
+ } else {
+ _G.accInUse++;
+ aopOp (IC_RESULT (ic), ic, FALSE);
+ _G.accInUse--;
+ assignResultValue (IC_RESULT (ic));
+ }
+ } else { /* second receive onwards */
+ int rb1off ;
aopOp (IC_RESULT (ic), ic, FALSE);
- _G.accInUse--;
- assignResultValue (IC_RESULT (ic));
- }
-
- freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* gen51AggregateAssign - copy complete array's or structures */
-/*-----------------------------------------------------------------*/
-void gen51AggregateAssign(iCode *ic) {
- operand *left=IC_LEFT(ic);
- operand *right=IC_RIGHT(ic);
- char *fromName=OP_SYMBOL(right)->rname;
- char *toName=OP_SYMBOL(left)->rname;
- int fromSize=getSize(OP_SYMBOL(right)->type);
- int toSize=getSize(OP_SYMBOL(left)->type);
- int count=toSize;
-
- D(emitcode (";", "gen51AggregateAssign"));
-
- if (SPEC_OCLS(OP_SYMBOL(left)->etype)!=xdata ||
- SPEC_OCLS(OP_SYMBOL(right)->etype)!=code) {
- // well, this code isn't used yet from anywhere else as for initialising
- fprintf (stderr, "*** error: %s:%d can only assign aggregates from cseg to xseg for now\n", ic->filename, ic->lineno);
- exit (457);
- }
-
- if (fromSize!=toSize) {
- fprintf (stderr, "*** error: %s:%d aggregates have different size\n",
- ic->filename, ic->lineno);
- exit (821);
+ rb1off = ic->argreg;
+ while (size--) {
+ aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++);
+ }
}
-
-#if 1
- // use the generic memcpy() for now
- emitcode (";", "initialize %s", OP_SYMBOL(IC_LEFT(ic))->name);
- emitcode ("mov", "dptr,#_memcpy_PARM_2");
- emitcode ("mov", "a,#%s", fromName);
- emitcode ("movx", "@dptr,a");
- emitcode ("inc", "dptr");
- emitcode ("mov", "a,#(%s>>8)", fromName);
- emitcode ("movx", "@dptr,a");
- emitcode ("inc", "dptr");
- emitcode ("mov", "a,#%02x; only from cseg for now", 2);
- emitcode ("movx", "@dptr,a");
- emitcode ("mov", "dptr,#_memcpy_PARM_3");
- emitcode ("mov", "a,#(%d>>0); number of bytes", count);
- emitcode ("movx", "@dptr,a");
- emitcode ("inc", "dptr");
- emitcode ("mov", "a,#(%d>>8)", count);
- emitcode ("movx", "@dptr,a");
- emitcode ("mov", "dptr,#%s", toName);
- emitcode ("mov", "b,#%02x; only to xseg for now", 1);
- emitcode ("lcall", "_memcpy");
-#else
- // more efficient, but will require the native_memcpy_cs2xs
- emitcode ("mov", "r0,#%s", fromName);
- emitcode ("mov", "r1,#(%s>>8)", fromName);
- emitcode ("mov", "r2,#%s", toName);
- emitcode ("mov", "r3,#(%s>>8)", toName);
- emitcode ("mov", "r4,#%d", count);
- emitcode ("mov", "r5,#(%d>>8)", count);
- emitcode ("lcall", "_native_memcpy_cs2xs");
-#endif
+ freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
if (allocInfo)
printAllocInfo (currFunc, codeOutFile);
/* if debug information required */
- /* if (options.debug && currFunc) { */
if (options.debug && currFunc)
{
- cdbSymbol (currFunc, cdbFile, FALSE, TRUE);
+ debugFile->writeFunction(currFunc);
_G.debugLine = 1;
if (IS_STATIC (currFunc->etype))
emitcode ("", "F%s$%s$0$0 ==.", moduleName, currFunc->name);
for (ic = lic; ic; ic = ic->next)
{
- if (cln != ic->lineno)
+ if (ic->lineno && cln != ic->lineno)
{
if (options.debug)
{
ic->level, ic->block);
_G.debugLine = 0;
}
- emitcode (";", "%s %d", ic->filename, ic->lineno);
+ if (!options.noCcodeInAsm) {
+ emitcode ("", ";%s:%d: %s", ic->filename, ic->lineno,
+ printCLine(ic->filename, ic->lineno));
+ }
cln = ic->lineno;
}
+ if (options.iCodeInAsm) {
+ emitcode("", ";ic:%d: %s", ic->key, printILine(ic));
+ }
/* if the result is marked as
spilt and rematerializable or code for
this has already been generated then
break;
case GET_VALUE_AT_ADDRESS:
- genPointerGet (ic, hasInc(IC_LEFT(ic),ic));
+ genPointerGet (ic, hasInc(IC_LEFT(ic),ic,getSize(operandType(IC_RESULT(ic)))));
break;
case '=':
if (POINTER_SET (ic))
- genPointerSet (ic, hasInc (IC_RESULT(ic),ic));
+ genPointerSet (ic, hasInc (IC_RESULT(ic),ic,getSize(operandType(IC_RIGHT(ic)))));
else
genAssign (ic);
break;
addSet (&_G.sendSet, ic);
break;
- case ARRAYINIT:
- gen51AggregateAssign(ic);
- break;
-
default:
ic = ic;
}
projects / fw / sdcc / blobdiff