#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"
(*aopp)->type = AOP_R1;
return mcs51_regWithIdx (R1_IDX);
}
-
endOfWorld:
- /* I said end of world but not quite end of world yet */
- /* if this is a result then we can push it on the stack */
- if (result)
- {
- (*aopp)->type = AOP_STK;
- return NULL;
+ /* 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)) {
+ (*aopp)->type = AOP_R0;
+ return mcs51_regWithIdx (R0_IDX);
+ }
+ if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R1_IDX)) {
+ (*aopp)->type = AOP_R1;
+ return mcs51_regWithIdx (R1_IDX);
}
+ }
- /* other wise this is true end of the world */
+ /* now this is REALLY the end of the world */
werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
"getFreePtr should never reach here");
exit (1);
if (offset > (aop->size - 1))
return FALSE;
- switch (aop->type)
+ 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 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");
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 size;
symbol *tlbl;
- D(emitcode (";", "genCpl"));
+ D(emitcode ("; genCpl",""));
/* assign asmOps to operand & result */
aopOp (IC_LEFT (ic), ic, FALSE);
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);
+ /* for this we just copy and then flip the bit */
- MOVA (l);
-
- 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)
// 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 */
// bool restoreBank=FALSE;
bool swapBanks = FALSE;
- D(emitcode(";", "genPCall"));
+ D(emitcode("; genPCall",""));
/* if caller saves & we have not saved then */
if (!ic->regsSaved)
}
}
}
- // jwk: this needs a closer look
+ // TODO: this needs a closer look
SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
}
}
}
else
{
- /* not callee-saves, we can clobber ar0 */
- emitcode ("mov", "ar0,a");
+ /* 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,ar0");
+ emitcode ("mov", "a,r0");
}
}
else
* 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;
{
int size, offset = 0, pushed = 0;
- D(emitcode (";", "genRet"));
+ D(emitcode ("; genRet",""));
/* if we have no return value then
just generate the "ret" */
if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
return FALSE;
- D(emitcode (";", "genPlusIncr"));
+ D(emitcode ("; genPlusIncr",""));
- /* if increment 16 bits in register */
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_REG &&
+ /* 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))
static void
genPlusBits (iCode * ic)
{
- D(emitcode (";", "genPlusBits"));
+ D(emitcode ("; genPlusBits",""));
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
/* special cases :- */
- D(emitcode (";", "genPlus"));
+ D(emitcode ("; genPlus",""));
aopOp (IC_LEFT (ic), ic, FALSE);
aopOp (IC_RIGHT (ic), ic, FALSE);
{
if (aopGetUsesAcc (leftOp, offset) && aopGetUsesAcc (rightOp, offset))
{
- emitcode("mov", "b,acc");
+ emitcode("mov", "b,a");
MOVA (aopGet (leftOp, offset, FALSE, TRUE));
emitcode("xch", "a,b");
MOVA (aopGet (rightOp, offset, FALSE, TRUE));
if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
return FALSE;
- D(emitcode (";", "genMinusDec"));
+ D(emitcode ("; genMinusDec",""));
- /* if decrement 16 bits in register */
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_REG &&
+ /* 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))
{
symbol *lbl = newiTempLabel (NULL);
- D(emitcode (";", "genMinusBits"));
+ D(emitcode ("; genMinusBits",""));
if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
{
{
int size, offset = 0;
- D(emitcode (";", "genMinus"));
+ D(emitcode ("; genMinus",""));
aopOp (IC_LEFT (ic), ic, FALSE);
aopOp (IC_RIGHT (ic), ic, FALSE);
if (aopGetUsesAcc(rightOp, offset)) {
wassertl(!aopGetUsesAcc(leftOp, offset), "accumulator clash");
MOVA (aopGet(rightOp, offset, FALSE, TRUE));
- if (offset > 0) {
- emitcode( "cpl", "c");
- } else {
+ if (offset == 0) {
emitcode( "setb", "c");
}
emitcode("subb", "a,%s", aopGet(leftOp, offset, 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);
symbol *lbl;
int size=AOP_SIZE(result);
- D(emitcode (";", "genMultOneByte"));
+ D(emitcode ("; genMultOneByte",""));
if (size<1 || size>2) {
// this should never happen
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
- D(emitcode (";", "genMult"));
+ D(emitcode ("; genMult",""));
/* assign the amsops */
aopOp (left, ic, FALSE);
char *l;
- D(emitcode (";", "genDivbits"));
+ D(emitcode ("; genDivbits",""));
/* the result must be bit */
emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
symbol *lbl;
int size, offset;
- D(emitcode (";", "genDivOneByte"));
+ D(emitcode ("; genDivOneByte",""));
size = AOP_SIZE (result) - 1;
offset = 1;
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
- D(emitcode (";", "genDiv"));
+ D(emitcode ("; genDiv",""));
/* assign the amsops */
aopOp (left, ic, FALSE);
char *l;
- D(emitcode (";", "genModbits"));
+ D(emitcode ("; genModbits",""));
/* the result must be bit */
emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
char *l;
symbol *lbl;
- D(emitcode (";", "genModOneByte"));
+ D(emitcode ("; genModOneByte",""));
/* signed or unsigned */
if (SPEC_USIGN (opetype))
operand *right = IC_RIGHT (ic);
operand *result = IC_RESULT (ic);
- D(emitcode (";", "genMod"));
+ D(emitcode ("; genMod",""));
/* assign the amsops */
aopOp (left, ic, FALSE);
symbol *tlbl = newiTempLabel (NULL);
char *inst;
- D(emitcode (";", "genIfxJump"));
+ D(emitcode ("; genIfxJump",""));
/* if true label then we jump if condition
supplied is true */
int size, offset = 0;
unsigned long lit = 0L;
- D(emitcode (";", "genCmp"));
+ 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"));
+ D(emitcode ("; genCmpGt",""));
left = IC_LEFT (ic);
right = IC_RIGHT (ic);
sym_link *letype, *retype;
int sign;
- D(emitcode (";", "genCmpLt"));
+ D(emitcode ("; genCmpLt",""));
left = IC_LEFT (ic);
right = IC_RIGHT (ic);
{
operand *left, *right, *result;
- D(emitcode (";", "genCmpEq"));
+ D(emitcode ("; genCmpEq",""));
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
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
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
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);
int size, offset = 0;
unsigned long lit = 0L;
- D(emitcode (";", "genOr"));
+ D(emitcode ("; genOr",""));
aopOp ((left = IC_LEFT (ic)), ic, FALSE);
aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
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);
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);
sym_link *type, *etype;
int p_type;
- D(emitcode (";", "genPointerGet"));
+ D(emitcode ("; genPointerGet",""));
left = IC_LEFT (ic);
result = IC_RESULT (ic);
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);
sym_link *type, *etype;
int p_type;
- D(emitcode (";", "genPointerSet"));
+ D(emitcode ("; genPointerSet",""));
right = IC_RIGHT (ic);
result = IC_RESULT (ic);
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);
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)))
if (!ifx)
return 0;
- D(emitcode (";", "genDjnz"));
+ D(emitcode ("; genDjnz",""));
/* if the if condition has a false label
then we cannot save */
{
int size = getSize (operandType (IC_RESULT (ic)));
int offset = 0;
- D(emitcode (";", "genReceive"));
+ D(emitcode ("; genReceive",""));
if (ic->argreg == 1) { /* first parameter */
if (isOperandInFarSpace (IC_RESULT (ic)) &&
lineHead = lineCurr = NULL;
/* print the allocation information */
- if (allocInfo)
+ if (allocInfo && currFunc)
printAllocInfo (currFunc, codeOutFile);
/* if debug information required */
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);
ic->level, ic->block);
_G.debugLine = 0;
}
- emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
- printCLine(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) {
+ char regsInUse[80];
+ int i;
+
+ for (i=0; i<8; i++) {
+ sprintf (®sInUse[i],
+ "%c", ic->riu & (1<<i) ? i+'0' : '-');
+ }
+ regsInUse[i]=0;
+ emitcode("", "; [%s] ic:%d: %s", regsInUse, ic->seq, printILine(ic));
+ }
/* if the result is marked as
spilt and rematerializable or code for
this has already been generated then
projects / fw / sdcc / blobdiff