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>
};
extern struct dbuf_s *codeOutBuf;
-static void saveRBank (int, iCode *, bool);
#define RESULTONSTACK(x) \
(IC_RESULT(x) && IC_RESULT(x)->aop && \
lbp++;
}
- if (lbp && *lbp)
+ if (lbp)
{
rtrackUpdate (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);
emitcode("mov","b,%s", x);
}
-/*-----------------------------------------------------------------*/
-/* movc - moves specified value into the carry */
-/*-----------------------------------------------------------------*/
-static void
-movc (const char *s)
-{
- if (!strcmp (s, zero))
- CLRC;
- else if (!strcmp (s, one))
- SETC;
- else if (strcmp (s, "c"))
- {/* it's not in carry already */
- MOVA (s);
- /* set C, if a >= 1 */
- emitcode ("add", "a,#0xff");
- }
-}
-
/*-----------------------------------------------------------------*/
/* pushB - saves register B if necessary */
/*-----------------------------------------------------------------*/
/* 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;
}
if (sym->remat)
{
sym->aop = op->aop = aop = aopForRemat (sym);
- aop->size = getSize (sym->type);
+ 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];
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");
bool bvolatile = isOperandVolatile (result, FALSE);
bool accuse = FALSE;
asmop * aop = AOP (result);
+ const char *d = NULL;
if (aop->size && offset > (aop->size - 1))
{
break;
case AOP_CRY:
- /* if 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);
- else if (strcmp (s, 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:
/* if the result is bit */
if (AOP_TYPE (result) == AOP_CRY)
{
- aopPut (result, "c", 0);
+ if (!IS_OP_RUONLY (result))
+ aopPut (result, "c", 0);
}
else
{
}
}
+/*-----------------------------------------------------------------*/
+/* 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 */
}
else
{
- emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
+ toCarry (IC_LEFT (ic));
emitcode ("cpl", "c");
outBitC (IC_RESULT (ic));
}
rsave = bitVectCplAnd (rsave, rsavebits);
rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
}
+ freeBitVect (rsavebits);
if (count == 1)
{
}
}
}
+ freeBitVect (rsave);
}
/*-----------------------------------------------------------------*/
rsave = bitVectCplAnd (rsave, rsavebits);
rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
}
+ freeBitVect (rsavebits);
if (count == 1)
{
}
}
}
+ freeBitVect (rsave);
}
saveRBank (int bank, iCode * ic, bool pushPsw)
{
int i;
- int count = 8 + ((mcs51_nRegs > 8) ? 1 : 0) + (pushPsw ? 1 : 0);
+ int count = 8 + (pushPsw ? 1 : 0);
asmop *aop = NULL;
regs *r = NULL;
if (!ic)
{
/* Assume r0 is available for use. */
- r = REG_WITH_INDEX (R0_IDX);;
+ r = REG_WITH_INDEX (R0_IDX);
}
else
{
regs8051[i].base, 8 * bank + regs8051[i].offset);
}
- if (mcs51_nRegs > 8)
- {
- if (options.useXstack)
- {
- emitcode ("mov", "a,bits");
- emitcode ("movx", "@%s,a", r->name);
- if (--count)
- emitcode ("inc", "%s", r->name);
- }
- else
- {
- emitcode ("push", "bits");
- }
- BitBankUsed = 1;
- }
-
if (pushPsw)
{
if (options.useXstack)
}
if (ic)
- {
- ic->bankSaved = 1;
- }
+ {
+ ic->bankSaved = 1;
+ }
}
/*-----------------------------------------------------------------*/
}
}
- if (mcs51_nRegs > 8)
- {
- if (options.useXstack)
- {
- emitcode ("dec", "%s", r->name);
- emitcode ("movx", "a,@%s", r->name);
- emitcode ("mov", "bits,a");
- }
- else
- {
- emitcode ("pop", "bits");
- }
- }
-
for (i = 7; i >= 0; i--)
{
if (options.useXstack)
else
emitcode ("clr", "b[%d]", bit);
}
- else if (AOP_TYPE (IC_LEFT (sic)) == AOP_CRY)
- {
- char *l = AOP (IC_LEFT (sic))->aopu.aop_dir;
- if (strcmp (l, "c"))
- emitcode ("mov", "c,%s", l);
- emitcode ("mov", "b[%d],c", bit);
- }
else
{
/* we need to or */
- toBoolean (IC_LEFT (sic));
- /* set C, if a >= 1 */
- emitcode ("add", "a,#0xff");
+ toCarry (IC_LEFT (sic));
emitcode ("mov", "b[%d],c", bit);
}
bit_count++;
/* 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 */
- if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
+ if (currFunc && dtype && !IFFUNC_ISNAKED (dtype) &&
(FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
!IFFUNC_ISISR (dtype))
{
// need caution message to user here
}
- if (IS_LITERAL(etype))
+ if (IS_LITERAL (etype))
{
/* if send set is not empty then assign */
if (_G.sendSet)
if (swapBanks)
{
emitcode ("mov", "psw,#0x%02x",
- ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+ ((FUNC_REGBANK (dtype)) << 3) & 0xff);
}
- if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT(getSpec(dtype)))
+ if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT (getSpec(dtype)))
{
- if (IFFUNC_CALLEESAVES(dtype))
+ if (IFFUNC_CALLEESAVES (dtype))
{
werror (E_BANKED_WITH_CALLEESAVES);
}
}
else
{
- if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT(getSpec(dtype)))
+ if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT (getSpec(dtype)))
{
- if (IFFUNC_CALLEESAVES(dtype))
+ if (IFFUNC_CALLEESAVES (dtype))
{
werror (E_BANKED_WITH_CALLEESAVES);
}
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));
if (swapBanks)
{
emitcode ("mov", "psw,#0x%02x",
- ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+ ((FUNC_REGBANK (dtype)) << 3) & 0xff);
}
/* make the call */
emitcode ("lcall", "__sdcc_banked_call");
}
}
- else
+ else if (_G.sendSet)
{
/* push the return address on to the stack */
emitcode ("mov", "a,#%05d$", (rlbl->key + 100));
if (swapBanks)
{
emitcode ("mov", "psw,#0x%02x",
- ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+ ((FUNC_REGBANK (dtype)) << 3) & 0xff);
}
/* 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);
+
+ 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);
+ }
+
+ 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)
{
- selectRegBank (FUNC_REGBANK(currFunc->type), IS_BIT (etype));
+ selectRegBank (FUNC_REGBANK (currFunc->type), IS_BIT (etype));
}
/* if we need assign a result value */
// unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
/* if we had saved some registers then unsave them */
- if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
+ if (ic->regsSaved && !IFFUNC_CALLEESAVES (dtype))
unsaveRegisters (ic);
if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))))
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");
if (!inExcludeList ("b"))
/* if any registers used */
if (sym->regsUsed)
{
- bool bits_pushed = FALSE;
/* save the registers used */
for (i = 0; i < sym->regsUsed->size; i++)
{
if (bitVectBitValue (sym->regsUsed, i))
- bits_pushed = pushReg (i, bits_pushed);
+ pushReg (i, TRUE);
}
}
}
}
}
}
- else
+ else
{
/* This ISR uses a non-zero bank.
*
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 (IFFUNC_ISISR (sym->type))
{
+ bitVect *rsavebits;
/* now we need to restore the registers */
/* if this isr has no bank i.e. is going to
/* if any registers used */
if (sym->regsUsed)
{
- bool bits_popped = FALSE;
/* save the registers used */
for (i = sym->regsUsed->size; i >= 0; i--)
{
if (bitVectBitValue (sym->regsUsed, i))
- bits_popped = popReg (i, bits_popped);
+ popReg (i, TRUE);
}
}
}
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);
}
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 (IS_BIT(_G.currentFunc->etype))
{
- if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
- emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
- else
- movc (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
+ if (!IS_OP_RUONLY (IC_LEFT (ic)))
+ toCarry (IC_LEFT (ic));
}
else
{
if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
{
/* #NOCHANGE */
- l = aopGet (IC_LEFT (ic), offset++,
- FALSE, TRUE);
+ l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE);
emitcode ("push", "%s", l);
pushed++;
}
else
{
- l = aopGet (IC_LEFT (ic), offset,
- FALSE, FALSE);
+ l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
if (strcmp (fReturn[offset], l))
emitcode ("mov", "%s,%s", fReturn[offset++], l);
}
{
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");
emitLabel (lbl);
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,%s", zero);
&& (SPEC_ADDR (OP_SYM_ETYPE (op)) & 0xff) == 0
)
{
- D(emitcode ("; genPlus aligned array",""));
+ D(emitcode (";", "genPlus aligned array"));
aopPut (IC_RESULT (ic),
aopGet (rightOp, 0, FALSE, FALSE),
0);
skip_bytes++;
}
if (skip_bytes)
- D(emitcode ("; genPlus shortcut",""));
+ D(emitcode (";", "genPlus shortcut"));
}
while (size--)
char *l;
bool pushedB;
- D(emitcode ("; genDivbits",""));
+ D(emitcode (";", "genDivbits"));
pushedB = pushB ();
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:
D (emitcode (";", "genDiv"));
- /* assign the amsops */
+ /* assign the asmops */
aopOp (left, ic, FALSE);
aopOp (right, ic, FALSE);
aopOp (result, ic, TRUE);
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);
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);
/* 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;
/* gencjne - compare and jump if not equal */
/*-----------------------------------------------------------------*/
static void
-gencjne (operand * left, operand * right, symbol * lbl)
+gencjne (operand * left, operand * right, symbol * lbl, bool useCarry)
{
symbol *tlbl = newiTempLabel (NULL);
gencjneshort (left, right, lbl);
- emitcode ("mov", "a,%s", one);
+ if (useCarry)
+ SETC;
+ else
+ MOVA (one);
emitcode ("sjmp", "%05d$", tlbl->key + 100);
emitLabel (lbl);
- emitcode ("clr", "a");
+ if (useCarry)
+ CLRC;
+ else
+ MOVA (zero);
emitLabel (tlbl);
}
}
else
{
- gencjne (left, right, newiTempLabel (NULL));
if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
{
- aopPut (result, "a", 0);
+ gencjne (left, right, newiTempLabel (NULL), TRUE);
+ aopPut (result, "c", 0);
goto release;
}
+ gencjne (left, right, newiTempLabel (NULL), FALSE);
if (ifx)
{
genIfxJump (ifx, "a", left, right, result);
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
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
{
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
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
{
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);
if (AOP_TYPE (right) == AOP_CRY)
{
// c = bit ^ bit;
- emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+ if (IS_OP_ACCUSE (left))
+ {// left already is in the carry
+ operand *tmp = right;
+ right = left;
+ left = tmp;
+ }
+ else
+ {
+ toCarry (right);
+ }
}
else
{
- int sizer = AOP_SIZE (right);
// c = bit ^ val
- // if val>>1 != 0, result = 1
- emitcode ("setb", "c");
- while (sizer)
- {
- MOVA (aopGet (right, sizer - 1, FALSE, FALSE));
- if (sizer == 1)
- // test the msb of the lsb
- emitcode ("anl", "a,#0xfe");
- emitcode ("jnz", "%05d$", tlbl->key + 100);
- sizer--;
- }
- // val = (0,1)
- emitcode ("rrc", "a");
+ toCarry (right);
}
emitcode ("jnb", "%s,%05d$", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
emitcode ("cpl", "c");
// val = c
if (size)
outBitC (result);
- // if(bit | ...)
+ // if(bit ^ ...)
else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
genIfxJump (ifx, "c", left, right, result);
goto release;
genInline (iCode * ic)
{
char *buffer, *bp, *bp1;
+ bool inComment = FALSE;
D (emitcode (";", "genInline"));
_G.inLine += (!options.asmpeep);
- buffer = bp = bp1 = Safe_strdup(IC_INLINE(ic));
+ buffer = bp = bp1 = Safe_strdup (IC_INLINE (ic));
/* emit each line as a code */
while (*bp)
{
- if (*bp == '\n')
+ switch (*bp)
{
+ case ';':
+ inComment = TRUE;
+ ++bp;
+ break;
+
+ case '\n':
+ inComment = FALSE;
*bp++ = '\0';
emitcode (bp1, "");
bp1 = bp;
- }
- else
- {
+ break;
+
+ default:
/* Add \n for labels, not dirs such as c:\mydir */
- if ( (*bp == ':') && (isspace((unsigned char)bp[1])) )
+ if (!inComment && (*bp == ':') && (isspace((unsigned char)bp[1])))
{
- bp++;
+ ++bp;
*bp = '\0';
- bp++;
+ ++bp;
emitcode (bp1, "");
bp1 = bp;
}
else
- bp++;
+ ++bp;
+ break;
}
}
if (bp1 != bp)
emitcode (bp1, "");
- /* emitcode("",buffer); */
+
+ Safe_free (buffer);
+
_G.inLine -= (!options.asmpeep);
}
{
operand *left, *result;
- D(emitcode ("; genSwap",""));
+ D(emitcode (";", "genSwap"));
left = IC_LEFT (ic);
result = IC_RESULT (ic);
int bstr; /* bitfield starting bit within byte */
char buffer[10];
- D(emitcode ("; genUnpackBits",""));
+ D(emitcode (";", "genUnpackBits"));
etype = getSpec (operandType (result));
rsize = getSize (operandType (result));
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:
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);
l = aopGet (result, 0, FALSE, TRUE);
l++; //remove #
- size = AOP_SIZE (right);
+ size = max (AOP_SIZE (right), AOP_SIZE (result));
while (size--)
{
if (offset)
aopGet (right, offset++, FALSE, FALSE));
}
- freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
+ freeAsmop (result, NULL, ic, TRUE);
}
/*-----------------------------------------------------------------*/
-/* genNearPointerSet - emitcode for near pointer put */
+/* genNearPointerSet - emitcode for near pointer put */
/*-----------------------------------------------------------------*/
static void
genNearPointerSet (operand * right,
}
/* 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);
/* 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 (result, one, 0);
- else
- aopPut (result, zero, 0);
- 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 (result, "c", 0);
- goto release;
- }
-
- /* we need to or */
- toBoolean (right);
- aopPut (result, "a", 0);
+ assignBit (result, right);
goto release;
}
/* if the result is a bit (and not a bitfield) */
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 (result, one, 0);
- else
- aopPut (result, zero, 0);
-
- 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 (result, "c", 0);
- goto release;
- }
-
- /* we need to or */
- toBoolean (right);
- aopPut (result, "a", 0);
+ assignBit (result, right);
goto release;
}
static void
genEndCritical (iCode *ic)
{
- D(emitcode("; genEndCritical",""));
+ D(emitcode(";", "genEndCritical"));
if (IC_RIGHT (ic))
{
debugFile->writeCLine (ic);
}
if (!options.noCcodeInAsm) {
- emitcode ("", ";\t%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
#endif
}
iLine = printILine(ic);
- emitcode("", "; [%s] ic:%d: %s", regsInUse, ic->seq, printILine(ic));
+ emitcode(";", "[%s] ic:%d: %s", regsInUse, ic->seq, iLine);
dbuf_free(iLine);
}
/* if the result is marked as