-------------------------------------------------------------------------*/
-#define D(x)
-//#define D(x) x
+/* Use the D macro for basic (unobtrusive) debugging messages */
+#define D(x) do if (options.verboseAsm) {x;} while(0)
+/* Use the DD macro for detailed debugging messages */
+#define DD(x)
+//#define DD(x) x
#include <stdio.h>
#include <stdlib.h>
extern int allocInfo;
static int pushReg (regs *reg, bool freereg);
static void pullReg (regs *reg);
+static void transferAopAop (asmop *srcaop, int srcofs, asmop *dstaop, int dstofs);
static char *zero = "#0x00";
static char *one = "#0x01";
extern int hc08_ptrRegReq;
extern int hc08_nRegs;
-extern FILE *codeOutFile;
+extern struct dbuf_s *codeOutBuf;
//static void saveRBank (int, iCode *, bool);
static bool operandsEqu (operand * op1, operand * op2);
static void loadRegFromConst (regs *reg, char *c);
emitLabel (symbol *tlbl)
{
emitcode ("", "%05d$:", (tlbl->key +100));
+ lineCurr->isLabel = 1;
}
/*-----------------------------------------------------------------*/
return;
}
- D(emitcode ("", "; transferRegReg(%s,%s)",
+ DD(emitcode ("", "; transferRegReg(%s,%s)",
sreg->name, dreg->name));
srcidx = sreg->rIdx;
printf(" reg missing operand link\n");
#endif
- D(emitcode ("", "; loadRegFromAop (%s, %s, %d)",
+ DD(emitcode ("", "; loadRegFromAop (%s, %s, %d)",
reg->name, aopName (aop), loffset));
/* If operand is volatile, we cannot optimize. */
&& (reg->aopofs == loffset))
{
hc08_useReg(reg);
- D(emitcode ("","; already had correct value for %s", reg->name));
+ DD(emitcode ("","; already had correct value for %s", reg->name));
return;
}
&& operandsEqu(hc08_reg_h->aop->op,aop->op)
&& (hc08_reg_h->aopofs == loffset))
{
- D(emitcode ("","; found correct value for %s in h", reg->name));
+ DD(emitcode ("","; found correct value for %s in h", reg->name));
transferRegReg (hc08_reg_h, reg, FALSE);
hc08_useReg (reg);
return;
&& operandsEqu(hc08_reg_x->aop->op,aop->op)
&& (hc08_reg_x->aopofs == loffset))
{
- D(emitcode ("","; found correct value for %s in x", reg->name));
+ DD(emitcode ("","; found correct value for %s in x", reg->name));
transferRegReg (hc08_reg_x, reg, FALSE);
hc08_useReg (reg);
return;
&& operandsEqu(hc08_reg_a->aop->op,aop->op)
&& (hc08_reg_a->aopofs == loffset))
{
- D(emitcode ("","; found correct value for %s in a", reg->name));
+ DD(emitcode ("","; found correct value for %s in a", reg->name));
transferRegReg (hc08_reg_a, reg, FALSE);
hc08_useReg (reg);
return;
/*--------------------------------------------------------------------------*/
/* forceStackedAop - Reserve space on the stack for asmop aop; when */
/* freeAsmop is called with aop, the stacked data will */
-/* be copied to the original aop location and */
+/* be copied to the original aop location. */
/*--------------------------------------------------------------------------*/
static asmop *
-forceStackedAop (asmop *aop)
+forceStackedAop (asmop *aop, bool copyOrig)
{
+ regs *reg;
int loffset;
asmop *newaop = newAsmop (aop->type);
memcpy (newaop, aop, sizeof(*newaop));
- D(emitcode("", "; forcedStackAop %s", aopName(aop)));
+ DD(emitcode("", "; forcedStackAop %s", aopName(aop)));
+
+ if (copyOrig && hc08_reg_a->isFree)
+ reg = hc08_reg_a;
+ else if (copyOrig && hc08_reg_x->isFree)
+ reg = hc08_reg_x;
+ else
+ reg = NULL;
+
for (loffset=0; loffset < newaop->size; loffset++)
{
asmop *aopsof = newAsmop (AOP_SOF);
aopsof->size = 1;
- aopsof->aopu.aop_stk = pushReg (hc08_reg_a, FALSE);
+ if (copyOrig && reg)
+ {
+ loadRegFromAop (reg, aop, loffset);
+ aopsof->aopu.aop_stk = pushReg (reg, FALSE);
+ }
+ else
+ {
+ aopsof->aopu.aop_stk = pushReg (hc08_reg_a, FALSE);
+ }
aopsof->op = aop->op;
newaop->stk_aop[loffset] = aopsof;
}
newaop->stacked = 1;
+
+ if (!reg && copyOrig)
+ {
+ for (loffset=0; loffset < newaop->size; loffset++)
+ {
+ transferAopAop (aop, loffset, newaop, loffset);
+ }
+ }
+
return newaop;
}
int otheridx;
#endif
- D(emitcode ("", "; storeRegToAop (%s, %s, %d), stacked=%d, isaddr=%d",
+ DD(emitcode ("", "; storeRegToAop (%s, %s, %d), stacked=%d, isaddr=%d",
reg->name, aopName (aop), loffset, aop->stacked, aop->isaddr));
if ((reg->rIdx == HX_IDX) && aop->stacked
&& operandsEqu(otherreg->aop->op,aop->op)
&& (otherreg->aopofs == loffset))
{
- D(emitcode("","; marking %s stale", otherreg->name));
+ DD(emitcode("","; marking %s stale", otherreg->name));
otherreg->aop=NULL;
}
}
if ((!hc08_reg_x->aop || !hc08_reg_h->aop) && hc08_reg_hx->aop)
{
hc08_reg_hx->aop = NULL;
- D(emitcode("","; marking hx stale"));
+ DD(emitcode("","; marking hx stale"));
}
if ((!hc08_reg_x->aop || !hc08_reg_a->aop) && hc08_reg_xa->aop)
{
hc08_reg_xa->aop = NULL;
- D(emitcode("","; marking xa stale"));
+ DD(emitcode("","; marking xa stale"));
}
reg->aop = aop;
return;
}
-// D(emitcode ("", "; transferAopAop (%s, %d, %s, %d)",
+// DD(emitcode ("", "; transferAopAop (%s, %d, %s, %d)",
// aopName (srcaop), srcofs, aopName (dstaop), dstofs));
-// D(emitcode ("", "; srcaop->type = %d", srcaop->type));
-// D(emitcode ("", "; dstaop->type = %d", dstaop->type));
+// DD(emitcode ("", "; srcaop->type = %d", srcaop->type));
+// DD(emitcode ("", "; dstaop->type = %d", dstaop->type));
if (dstofs >= dstaop->size)
return;
if (sym1 == sym2)
return TRUE;
+ /* if they have the same rname */
if (sym1->rname[0] && sym2->rname[0]
&& strcmp (sym1->rname, sym2->rname) == 0)
return TRUE;
int stackAdjust;
int loffset;
- D(emitcode ("","; freeAsmop restoring stacked %s", aopName(aop)));
+ DD(emitcode ("","; freeAsmop restoring stacked %s", aopName(aop)));
aop->stacked = 0;
stackAdjust = 0;
for (loffset=0; loffset<aop->size; loffset++)
sym_link *type, *etype;
int p_type;
- D(emitcode ("", "; aopDerefAop(%s)", aopName(aop)));
+ DD(emitcode ("", "; aopDerefAop(%s)", aopName(aop)));
if (aop->op)
{
emitcode ("tsta", "");
emitcode ("bne", "%05d$", (tlbl->key + 100));
emitcode ("tstx", "");
- emitcode ("", "%05d$:", (tlbl->key + 100));
+ emitLabel (tlbl);
}
else
{
emitcode ("tst", "%s", aopAdrStr (aop, 0, FALSE));
emitcode ("bne", "%05d$", (tlbl->key + 100));
emitcode ("tst", "%s", aopAdrStr (aop, 1, FALSE));
- emitcode ("", "%05d$:", (tlbl->key + 100));
+ emitLabel (tlbl);
break;
}
}
else
{
if (IS_AOP_XA (AOP (IC_RESULT (ic))))
- result = forceStackedAop (AOP (IC_RESULT (ic)));
+ result = forceStackedAop (AOP (IC_RESULT (ic)), FALSE);
else
result = AOP (IC_RESULT (ic));
emitBranch ("bsr", tlbl);
emitBranch ("bra", rlbl);
emitLabel (tlbl);
+ _G.stackPushes += 2; /* account for the bsr return address now on stack */
+ updateCFA();
/* Push the function's address */
aopOp (IC_LEFT (ic), ic, FALSE);
emitcode ("rts", "");
emitLabel (rlbl);
+ _G.stackPushes -= 4; /* account for rts here & in called function */
+ updateCFA();
/* if we need assign a result value */
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.stackOfs = 0;
debugFile->writeLabel(IC_LABEL (ic), ic);
- emitcode ("", "%05d$:", (IC_LABEL (ic)->key + 100));
+ emitLabel (IC_LABEL (ic));
}
icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
- D(emitcode ("", "; IS_AOP_HX = %d", IS_AOP_HX (AOP (left))));
+ DD(emitcode ("", "; IS_AOP_HX = %d", IS_AOP_HX (AOP (left))));
if ((IS_AOP_HX (AOP (left)) ||
( (AOP_TYPE (left) == AOP_DIR) && (AOP_TYPE (result) == AOP_DIR) )
return TRUE;
}
- D(emitcode ("", "; icount = %d, sameRegs=%d", icount,
+ DD(emitcode ("", "; icount = %d, sameRegs=%d", icount,
sameRegs (AOP (left), AOP (result))));
if ((icount > 255) || (icount<0))
if (genPlusIncr (ic) == TRUE)
goto release;
- D(emitcode("","; left size = %d", getDataSize (IC_LEFT(ic))));
- D(emitcode("","; right size = %d", getDataSize (IC_RIGHT(ic))));
- D(emitcode("","; result size = %d", getDataSize (IC_RESULT(ic))));
+ DD(emitcode("","; left size = %d", getDataSize (IC_LEFT(ic))));
+ DD(emitcode("","; right size = %d", getDataSize (IC_RIGHT(ic))));
+ DD(emitcode("","; result size = %d", getDataSize (IC_RESULT(ic))));
size = getDataSize (IC_RESULT (ic));
|| (lUnsigned && rUnsigned))
{
// just an unsigned 8*8=8/16 multiply
- //D(emitcode (";","unsigned"));
+ //DD(emitcode (";","unsigned"));
loadRegFromAop (hc08_reg_a, AOP (left), 0);
loadRegFromAop (hc08_reg_x, AOP (right), 0);
return EQ_OP; /* shouldn't happen, but need to return something */
}
-/* compile only if the debugging macro D is enabled */
-#if (D(1) -0)
+/*------------------------------------------------------------------*/
+/* nameCmp : helper function for human readable debug output */
+/*------------------------------------------------------------------*/
static char *
nameCmp (int opcode)
{
return "invalid";
}
}
-#endif
/*------------------------------------------------------------------*/
/* branchInstCmp : returns the conditional branch instruction that */
asmop *derefaop;
/* Make sure we have a next iCode */
- D(emitcode("","; checking lic"));
+ DD(emitcode("","; checking lic"));
if (!lic)
return FALSE;
/* Make sure the result of the addition is an iCode */
- D(emitcode("","; checking IS_ITEMP"));
+ DD(emitcode("","; checking IS_ITEMP"));
if (!IS_ITEMP (IC_RESULT (ic)))
return FALSE;
/* Make sure the next iCode is a pointer set or get */
pset = POINTER_SET(lic);
pget = POINTER_GET(lic);
- D(emitcode("","; pset=%d, pget=%d",pset,pget));
+ DD(emitcode("","; pset=%d, pget=%d",pset,pget));
if (!pset && !pget)
return FALSE;
if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
return FALSE;
- D(emitcode("", "; checking pset operandsEqu"));
+ DD(emitcode("", "; checking pset operandsEqu"));
if (pset & !operandsEqu (IC_RESULT (ic), IC_RESULT (lic)))
return FALSE;
- D(emitcode("", "; checking pget operandsEqu"));
+ DD(emitcode("", "; checking pget operandsEqu"));
if (pget & !operandsEqu (IC_RESULT (ic), IC_LEFT (lic)))
return FALSE;
- D(emitcode("", "; checking IS_SYMOP"));
+ DD(emitcode("", "; checking IS_SYMOP"));
if (!IS_SYMOP (IC_LEFT (ic)))
return FALSE;
- D(emitcode("", "; checking !IS_TRUE_SYMOP"));
+ DD(emitcode("", "; checking !IS_TRUE_SYMOP"));
if (IS_TRUE_SYMOP (IC_LEFT (ic)))
return FALSE;
sym = OP_SYMBOL (IC_LEFT (ic));
- D(emitcode("", "; checking remat"));
+ DD(emitcode("", "; checking remat"));
if (!sym->remat)
return FALSE;
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
#ifdef DEBUG_TYPE
- D(emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
+ DD(emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
AOP_TYPE (result),
AOP_TYPE (left), AOP_TYPE (right)));
- D(emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
+ DD(emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
AOP_SIZE (result),
AOP_SIZE (left), AOP_SIZE (right)));
#endif
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
#ifdef DEBUG_TYPE
- D(emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
+ DD(emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
AOP_TYPE (result),
AOP_TYPE (left), AOP_TYPE (right)));
- D(emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
+ DD(emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
AOP_SIZE (result),
AOP_SIZE (left), AOP_SIZE (right)));
#endif
aopOp ((result = IC_RESULT (ic)), ic, TRUE);
#ifdef DEBUG_TYPE
- D(emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
+ DD(emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
AOP_TYPE (result),
AOP_TYPE (left), AOP_TYPE (right)));
- D(emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
+ DD(emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
AOP_SIZE (result),
AOP_SIZE (left), AOP_SIZE (right)));
#endif
genInline (iCode * ic)
{
char *buffer, *bp, *bp1;
+ bool inComment = FALSE;
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')
- {
- *bp++ = '\0';
- /* emitcode (bp1, ""); */
- emitinline (ic, bp1);
- bp1 = bp;
- }
- else
- {
- if (*bp == ':')
- {
- bp++;
- *bp = '\0';
- bp++;
- emitcode (bp1, "");
- bp1 = bp;
- }
- else
- bp++;
- }
+ switch (*bp)
+ {
+ case ';':
+ inComment = TRUE;
+ ++bp;
+ break;
+
+ case '\n':
+ inComment = FALSE;
+ *bp++ = '\0';
+ emitinline (ic, bp1);
+ bp1 = bp;
+ break;
+
+ default:
+ /* Add \n for labels, not dirs such as c:\mydir */
+ if (!inComment && (*bp == ':') && (isspace((unsigned char)bp[1])))
+ {
+ ++bp;
+ *bp = '\0';
+ ++bp;
+ emitcode (bp1, "");
+ bp1 = bp;
+ }
+ else
+ ++bp;
+ break;
+ }
}
if (bp1 != bp)
- {
- /* emitcode (bp1, ""); */
- emitinline (ic, bp1);
- }
- /* emitcode("",buffer); */
+ emitinline (ic, bp1);
+
+ Safe_free (buffer);
+
_G.inLine -= (!options.asmpeep);
}
hc08_freeReg (hc08_reg_a);
break;
case 2: /* swap bytes in a word */
- if (operandsEqu (left, result))
+ if (operandsEqu (left, result) || sameRegs (AOP (left), AOP (result)))
{
loadRegFromAop (hc08_reg_a, AOP (left), 0);
hc08_useReg (hc08_reg_a);
/*-----------------------------------------------------------------*/
/* shiftLLong - shift left one long from left to result */
-/* offl = LSB or MSB16 */
+/* offr = LSB or MSB16 */
/*-----------------------------------------------------------------*/
static void
shiftLLong (operand * left, operand * result, int offr)
loadRegFromAop (hc08_reg_xa, AOP (left), LSB);
rmwWithReg ("lsl", hc08_reg_a);
rmwWithReg ("rol", hc08_reg_x);
- storeRegToAop (hc08_reg_xa, AOP (result), offr);
if (offr==LSB)
{
+ storeRegToAop (hc08_reg_xa, AOP (result), offr);
loadRegFromAop (hc08_reg_xa, AOP (left), MSB24);
rmwWithReg ("rol", hc08_reg_a);
rmwWithReg ("rol", hc08_reg_x);
}
else if (offr==MSB16)
{
+ storeRegToAop (hc08_reg_a, AOP (result), offr);
loadRegFromAop (hc08_reg_a, AOP (left), MSB24);
+ storeRegToAop (hc08_reg_x, AOP (result), offr+1);
rmwWithReg ("rol", hc08_reg_a);
storeRegToAop (hc08_reg_a, AOP (result), offr+2);
storeConstToAop (zero, AOP (result), 0);
size = AOP_SIZE (result);
#if VIEW_SIZE
- D(emitcode ("; shift left ", "result %d, left %d", size,
+ DD(emitcode ("; shift left ", "result %d, left %d", size,
AOP_SIZE (left)));
#endif
int size, offset;
symbol *tlbl, *tlbl1;
char *shift;
+ asmop *aopResult;
D(emitcode ("; genLeftShift",""));
}
/* shift count is unknown then we have to form
- a loop get the loop count in A : Note: we take
+ a loop get the loop count in X : Note: we take
only the lower order byte since shifting
more that 32 bits make no sense anyway, ( the
largest size of an object can be only 32 bits ) */
aopOp (result, ic, FALSE);
aopOp (left, ic, FALSE);
+ aopResult = AOP (result);
- if (sameRegs(AOP (right), AOP (result)) || IS_AOP_XA (AOP (result)))
- AOP (result) = forceStackedAop (AOP (result));
+ if (sameRegs(AOP (right), AOP (result)) || IS_AOP_XA (AOP (result))
+ || isOperandVolatile (result, FALSE))
+ aopResult = forceStackedAop (AOP (result), sameRegs ( AOP (left), AOP (result)));
/* now move the left to the result if they are not the
same */
- if (!sameRegs (AOP (left), AOP (result)))
+ if (!sameRegs (AOP (left), aopResult))
{
size = AOP_SIZE (result);
offset = 0;
while (size--)
{
- transferAopAop (AOP (left), offset, AOP (result), offset);
+ transferAopAop (AOP (left), offset, aopResult, offset);
offset++;
}
}
freeAsmop (left, NULL, ic, TRUE);
+ AOP (result) = aopResult;
tlbl = newiTempLabel (NULL);
size = AOP_SIZE (result);
rmwWithReg ("lsr", hc08_reg_x);
rmwWithReg ("ror", hc08_reg_a);
storeRegToAop (hc08_reg_xa, AOP (result), MSB24);
+ loadRegFromAop (hc08_reg_xa, AOP (left), LSB);
}
else if (offl==MSB16)
{
rmwWithReg ("asr", hc08_reg_a);
else
rmwWithReg ("lsr", hc08_reg_a);
+ loadRegFromAop (hc08_reg_x, AOP (left), MSB24);
storeRegToAop (hc08_reg_a, AOP (result), MSB24);
- storeRegSignToUpperAop (hc08_reg_a, AOP (result), MSB32, sign);
+ loadRegFromAop (hc08_reg_a, AOP (left), MSB16);
}
- loadRegFromAop (hc08_reg_xa, AOP (left), offl);
rmwWithReg ("ror", hc08_reg_x);
rmwWithReg ("ror", hc08_reg_a);
storeRegToAop (hc08_reg_xa, AOP (result), LSB);
+ if (offl==MSB16)
+ {
+ if (sign)
+ {
+ loadRegFromAop (hc08_reg_a, AOP (left), MSB24);
+ storeRegSignToUpperAop (hc08_reg_a, AOP (result), MSB32, sign);
+ }
+ else
+ {
+ storeConstToAop (zero, AOP (result), MSB32);
+ }
+ }
pullOrFreeReg (hc08_reg_x, needpulx);
pullOrFreeReg (hc08_reg_a, needpula);
aopOp (result, ic, FALSE);
#if VIEW_SIZE
- D(emitcode ("; shift right ", "result %d, left %d", AOP_SIZE (result),
+ DD(emitcode ("; shift right ", "result %d, left %d", AOP_SIZE (result),
AOP_SIZE (left)));
#endif
symbol *tlbl, *tlbl1;
char *shift;
bool sign;
+ asmop *aopResult;
D(emitcode ("; genRightShift",""));
aopOp (result, ic, FALSE);
aopOp (left, ic, FALSE);
+ aopResult = AOP (result);
+
+ if (sameRegs(AOP (right), AOP (result)) || IS_AOP_XA (AOP (result))
+ || isOperandVolatile (result, FALSE))
+ aopResult = forceStackedAop (AOP (result), sameRegs ( AOP (left), AOP (result)));
- if (sameRegs(AOP (right), AOP (result)) || IS_AOP_XA (AOP (result)))
- AOP (result) = forceStackedAop (AOP (result));
-
/* now move the left to the result if they are not the
same */
- if (!sameRegs (AOP (left), AOP (result)))
+ if (!sameRegs (AOP (left), aopResult))
{
- size = AOP_SIZE (result);
+ size = AOP_SIZE (result);
offset = 0;
while (size--)
- {
- transferAopAop (AOP (left), offset, AOP (result), offset);
- offset++;
- }
+ {
+ transferAopAop (AOP (left), offset, aopResult, offset);
+ offset++;
+ }
}
freeAsmop (left, NULL, ic, TRUE);
+ AOP (result) = aopResult;
tlbl = newiTempLabel (NULL);
size = AOP_SIZE (result);
/* print the allocation information */
if (allocInfo && currFunc)
- printAllocInfo (currFunc, codeOutFile);
+ printAllocInfo (currFunc, codeOutBuf);
/* if debug information required */
if (options.debug && currFunc)
{
if (options.iCodeInAsm) {
char regsInUse[80];
int i;
+ char *iLine;
for (i=0; i<6; i++) {
sprintf (®sInUse[i],
"%c", ic->riu & (1<<i) ? i+'0' : '-');
}
regsInUse[i]=0;
+ iLine = printILine(ic);
emitcode("", "; [%s] ic:%d: %s", regsInUse, ic->seq, printILine(ic));
+ dbuf_free(iLine);
}
/* if the result is marked as
spilt and rematerializable or code for
}
if (!hc08_reg_a->isFree)
- D(emitcode("","; forgot to free a"));
+ DD(emitcode("","; forgot to free a"));
if (!hc08_reg_x->isFree)
- D(emitcode("","; forgot to free x"));
+ DD(emitcode("","; forgot to free x"));
if (!hc08_reg_h->isFree)
- D(emitcode("","; forgot to free h"));
+ DD(emitcode("","; forgot to free h"));
if (!hc08_reg_hx->isFree)
- D(emitcode("","; forgot to free hx"));
+ DD(emitcode("","; forgot to free hx"));
if (!hc08_reg_xa->isFree)
- D(emitcode("","; forgot to free xa"));
+ DD(emitcode("","; forgot to free xa"));
}
debugFile->writeFrameAddress (NULL, NULL, 0); /* have no idea where frame is now */
peepHole (&lineHead);
/* now do the actual printing */
- printLine (lineHead, codeOutFile);
+ printLine (lineHead, codeOutBuf);
return;
}
projects / fw / sdcc / blobdiff