#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"
#include "gen.h"
-#if defined(__BORLANDC__) || defined(_MSC_VER)
-#define STRCASECMP stricmp
-#else
-#define STRCASECMP strcasecmp
-#endif
-
extern int allocInfo;
/* this is the down and dirty file with all kinds of
extern int xa51_ptrRegReq;
extern int xa51_nRegs;
-extern FILE *codeOutFile;
+extern struct dbuf_s *codeOutBuf;
static lineNode *lineHead = NULL;
static lineNode *lineCurr = NULL;
else
vsprintf (lb, fmt, ap);
- while (isspace ((int)*lbp))
+ while (isspace (*lbp))
lbp++;
if (lbp && *lbp)
va_end (ap);
}
+/*-----------------------------------------------------------------*/
+/* xa51_emitDebuggerSymbol - associate the current code location */
+/* with a debugger symbol */
+/*-----------------------------------------------------------------*/
+void
+xa51_emitDebuggerSymbol (char * debugSym)
+{
+ _G.debugLine = 1;
+ emitcode ("", "%s ==.", debugSym);
+ _G.debugLine = 0;
+}
+
+
char *getStackOffset(int stack) {
static char gsoBuf[1024];
sprintf (gsoBuf, "r7+(%d%+d%+d)", stack,
switch (size)
{
case 1:
- emitcode ("mov.b", "r0l,[%s]", getStackOffset(sym->stack));
+ emitcode ("mov.b", "r0l,[%s] ;aopForSym:stack:1", getStackOffset(sym->stack));
sprintf (aop->name[0], "r0l");
return aop;
case 2:
- emitcode ("mov.w", "r0,[%s]", getStackOffset(sym->stack));
+ emitcode ("mov.w", "r0,[%s] ;aopForSym:stack:2", getStackOffset(sym->stack));
sprintf (aop->name[0], "r0");
return aop;
case 3:
- emitcode ("mov.w", "r0,[%s]", getStackOffset(sym->stack));
+ emitcode ("mov.w", "r0,[%s] ;aopForSym:stack:3.w", getStackOffset(sym->stack));
sprintf (aop->name[0], "r0");
- emitcode ("mov.b", "r1l,[%s]", getStackOffset(sym->stack+2));
+ emitcode ("mov.b", "r1l,[%s] ;aopForSym:stack:3.b", getStackOffset(sym->stack+2));
sprintf (aop->name[1], "r1l");
return aop;
case 4:
- emitcode ("mov.w", "r0,[%s]", getStackOffset(sym->stack));
+ emitcode ("mov.w", "r0,[%s] ;aopForSym:stack:4", getStackOffset(sym->stack));
sprintf (aop->name[0], "r0");
- emitcode ("mov.w", "r1,[%s]", getStackOffset(sym->stack+2));
+ emitcode ("mov.w", "r1,[%s] ;aopForSym:stack:4", getStackOffset(sym->stack+2));
sprintf (aop->name[1], "r1");
return aop;
}
{
case 1:
emitcode (MOV, "r0,#%s", sym->rname);
- emitcode (MOVC, "r0l,[r0]");
+ emitcode (MOVC, "r0l,[r0+]");
sprintf (aop->name[0], "r0l");
return aop;
case 2:
emitcode (MOV, "r0,#%s", sym->rname);
- emitcode (MOVC, "r0,[r0]");
+ emitcode (MOVC, "r0,[r0+]");
sprintf (aop->name[0], "r0");
return aop;
case 3:
emitcode (MOV, "r0,#%s", sym->rname);
- emitcode (MOVC, "r1l,[r0+2]");
- sprintf (aop->name[1], "r1l");
- emitcode (MOV, "r0,[r0]");
- sprintf (aop->name[0], "r0");
+ emitcode (MOVC, "r0,[r0+]");
+ sprintf (aop->name[1], "r0");
+ emitcode (MOV, "r1l,[r0+]");
+ sprintf (aop->name[0], "r1l");
return aop;
case 4:
emitcode (MOV, "r0,#%s", sym->rname);
- emitcode (MOVC, "r1,[r0+2]");
- sprintf (aop->name[1], "r1");
- emitcode (MOVC, "r0,[r0]");
+ emitcode (MOVC, "r1,[r0+]");
+ emitcode (MOVC, "r0,[r0+]");
+ emitcode ("xch", "r0,r1");
sprintf (aop->name[0], "r0");
+ sprintf (aop->name[1], "r1");
return aop;
}
sprintf (aop->name[1], "#0");
break;
case 4:
- sprintf (aop->name[0], "#0x%04lx",
+ sprintf (aop->name[0], "#0x%04x",
SPEC_CVAL(operandType(op)).v_ulong & 0xffff);
- sprintf (aop->name[1], "#0x%04lx",
+ sprintf (aop->name[1], "#0x%04x",
SPEC_CVAL(operandType(op)).v_ulong >> 16);
break;
default:
break;
case V_INT:
if (SPEC_LONG(OP_VALUE(op)->type)) {
- sprintf (opName, "#%s0x%02lx", decorate?"(long)":"",
+ sprintf (opName, "#%s0x%02x", decorate?"(long)":"",
SPEC_CVAL(OP_VALUE(op)->type).v_long);
} else {
sprintf (opName, "#%s0x%02x", decorate?"(int)":"",
return line;
}
-void printIc (char *op, iCode * ic, bool result, bool left, bool right) {
+void printIc (bool printToStderr,
+ char *op, iCode * ic, bool result, bool left, bool right) {
char line[132];
sprintf (line, "%s(%d)", op, ic->lineno);
strcat (line, printOp (IC_RIGHT(ic)));
}
emitcode (";", line);
+ if (printToStderr) {
+ fprintf (stderr, "%s\n", line);
+ }
}
/*-----------------------------------------------------------------*/
/* genNot - generate code for ! operation */
/*-----------------------------------------------------------------*/
static void genNot (iCode * ic) {
- printIc("genNot:", ic, 1,1,0);
+ printIc (0, "genNot:", ic, 1,1,0);
}
/*-----------------------------------------------------------------*/
/* genCpl - generate code for complement */
/*-----------------------------------------------------------------*/
static void genCpl (iCode * ic) {
- printIc("genCpl", ic, 1,1,0);
+ printIc (0, "genCpl", ic, 1,1,0);
}
/*-----------------------------------------------------------------*/
/* genUminus - unary minus code generation */
/*-----------------------------------------------------------------*/
static void genUminus (iCode * ic) {
- printIc("genUminus", ic, 1,1,0);
+ printIc (0, "genUminus", ic, 1,1,0);
}
/*-----------------------------------------------------------------*/
static void genIpush (iCode * ic) {
operand *left=IC_LEFT(ic);
- printIc ("genIpush", ic, 0,1,0);
+ printIc (0, "genIpush", ic, 0,1,0);
aopOp(left,FALSE,FALSE);
/* genIpop - recover the registers: can happen only for spilling */
/*-----------------------------------------------------------------*/
static void genIpop (iCode * ic) {
- printIc ("genIpop", ic, 0,1,0);
+ printIc (0, "genIpop", ic, 0,1,0);
}
/*-----------------------------------------------------------------*/
emitcode (";", "genFunction %s", sym->rname);
/* print the allocation information */
- printAllocInfo (currFunc, codeOutFile);
+ printAllocInfo (currFunc, codeOutBuf);
emitcode ("", "%s:", sym->rname);
{
symbol *sym = OP_SYMBOL (IC_LEFT (ic));
- printIc ("genEndFunction", ic, 0,0,0);
+ printIc (0, "genEndFunction", ic, 0,0,0);
if (IFFUNC_ISNAKED(sym->type)) {
emitcode(";", "naked function: no epilogue.");
+ if (options.debug && currFunc)
+ debugFile->writeEndFunction (currFunc, ic, 0);
return;
}
emitcode ("add", "r7,#%d\t; release stack space for locals", sym->stack);
}
+ if (options.debug && currFunc) {
+ debugFile->writeEndFunction (currFunc, ic, 1);
+ }
+
if (IFFUNC_ISISR(sym->type)) {
emitcode ("reti", "");
} else {
/*-----------------------------------------------------------------*/
static void genRet (iCode * ic) {
- printIc ("genRet", ic, 0,1,0);
-
- aopOp(IC_LEFT(ic), TRUE, TRUE);
+ if (!IC_LEFT(ic)) {
+ printIc (0, "genRet", ic, 0, 0, 0);
+ } else {
+ printIc (0, "genRet", ic, 0, 1, 0);
+ aopOp(IC_LEFT(ic), TRUE, TRUE);
+ switch (AOP_SIZE(IC_LEFT(ic)))
+ {
+ case 4:
+ emitcode ("mov", "r1,%s", AOP_NAME(IC_LEFT(ic))[1]);
+ emitcode ("mov", "r0,%s", AOP_NAME(IC_LEFT(ic))[0]);
+ break;
+ case 3:
+ emitcode ("mov", "r1l,%s", AOP_NAME(IC_LEFT(ic))[1]);
+ // fall through
+ case 2:
+ emitcode ("mov", "r0,%s", AOP_NAME(IC_LEFT(ic))[0]);
+ break;
+ case 1:
+ emitcode ("mov", "r0l,%s", AOP_NAME(IC_LEFT(ic))[0]);
+ break;
+ default:
+ bailOut("genRet");
+ }
+ }
- switch (AOP_SIZE(IC_LEFT(ic)))
- {
- case 4:
- emitcode ("mov", "r1,%s", AOP_NAME(IC_LEFT(ic))[1]);
- emitcode ("mov", "r0,%s", AOP_NAME(IC_LEFT(ic))[0]);
- break;
- case 3:
- emitcode ("mov", "r1l,%s", AOP_NAME(IC_LEFT(ic))[1]);
- // fall through
- case 2:
- emitcode ("mov", "r0,%s", AOP_NAME(IC_LEFT(ic))[0]);
- break;
- case 1:
- emitcode ("mov", "r0l,%s", AOP_NAME(IC_LEFT(ic))[0]);
- break;
- default:
- bailOut("genRet");
- }
emitcode ("jmp", "%05d$", returnLabel->key+100);
}
int size;
char *instr;
- printIc ("genPlus", ic, 1,1,1);
+ printIc (0, "genPlus", ic, 1,1,1);
size=aopOp(result, TRUE, TRUE);
aopOp(left, !aopIsPtr(result), !aopIsDir(result));
aopOp(right, !aopIsPtr(result), !aopIsDir(result));
+ // special case for "* = * + char", needs a closer look
+ // heck, this shouldn't have come here but bug-223113 does
+ if (size==3 && AOP_SIZE(right)==1) {
+ emitcode ("mov", "r1l,%s", AOP_NAME(right)[0]);
+ emitcode ("mov", "r1h,#0"); // ptr arith unsigned????????????
+ emitcode ("mov", "%s,%s", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ emitcode ("add.w", "%s,r1", AOP_NAME(result)[0]);
+ emitcode ("mov", "%s,%s", AOP_NAME(result)[1], AOP_NAME(left)[1]);
+ return;
+ }
+
+ // special case for "xdata * = xdata * + char", needs a closer look
+ // heck, this shouldn't have come here but bug-441448 does
+ if (size==2 && AOP_SIZE(right)==1) {
+ emitcode ("mov", "r1l,%s", AOP_NAME(right)[0]);
+ emitcode ("mov", "r1h,#0"); // ptr arith unsigned????????????
+ emitcode ("mov", "%s,%s", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ emitcode ("add.w", "%s,r1", AOP_NAME(result)[0]);
+ return;
+ }
+
if (size>1) {
instr="add.w";
} else {
/* genMinus - generates code for subtraction */
/*-----------------------------------------------------------------*/
static void genMinus (iCode * ic) {
- printIc ("genMinus", ic, 1,1,1);
-}
+ operand *result=IC_RESULT(ic), *left=IC_LEFT(ic), *right=IC_RIGHT(ic);
+ int size;
+ char *instr;
+
+ printIc (0, "genMinus", ic, 1,1,1);
+ size=aopOp(result, TRUE, TRUE);
+
+ /* if left is a literal, then exchange them */
+ if (IS_LITERAL(operandType(left))) {
+ operand *tmp = right;
+ right = left;
+ left = tmp;
+ }
+
+ if (aopIsBit(result)) {
+ if (IS_LITERAL(operandType(right))) {
+ if (operandLitValue(right)) {
+ emitcode ("clr", AOP_NAME(result)[0]);
+ return;
+ }
+ aopOp(left, TRUE, TRUE);
+ emitcode ("mov", "%s,%s", AOP_NAME(result)[0], toBoolean(left));
+ return;
+ }
+ bailOut("genPlus: unfinished genPlus bit");
+ }
+
+ if (isOperandEqual(result,left)) {
+ left->aop=result->aop;
+ } else {
+ aopOp(left, !aopIsPtr(result), !aopIsDir(result));
+ }
+ aopOp(right, !aopIsPtr(result), !aopIsDir(result));
+
+ if (size>1) {
+ instr="sub.w";
+ } else {
+ instr="sub.b";
+ }
+ if (!aopEqual(result->aop, left->aop, 0)) {
+ emitcode ("mov", "%s,%s", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ }
+ emitcode (instr, "%s,%s", AOP_NAME(result)[0], AOP_NAME(right)[0]);
+ if (size>2) {
+ if (!aopEqual(result->aop, left->aop, 1)) {
+ emitcode ("mov", "%s,%s", AOP_NAME(result)[1], AOP_NAME(left)[1]);
+ }
+ if (size==3) {
+ // generic pointer
+ } else {
+ emitcode ("subb.w", "%s,%s", AOP_NAME(result)[1], AOP_NAME(right)[1]);
+ }
+ }
+ return;
+}
/*-----------------------------------------------------------------*/
/* genMult - generates code for multiplication */
/*-----------------------------------------------------------------*/
static void genMult (iCode * ic) {
- printIc ("genMult", ic, 1,1,1);
+ printIc (0, "genMult", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
/* genDiv - generates code for division */
/*-----------------------------------------------------------------*/
static void genDiv (iCode * ic) {
- printIc ("genDiv", ic, 1,1,1);
+ printIc (0, "genDiv", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
/* genMod - generates code for division */
/*-----------------------------------------------------------------*/
static void genMod (iCode * ic) {
- printIc ("genMod", ic, 1,1,1);
-}
-
-/*-----------------------------------------------------------------*/
-/* genCmpGt :- greater than comparison */
-/*-----------------------------------------------------------------*/
-static void genCmpGt (iCode * ic) {
- printIc ("genCmpGt", ic, 1,1,1);
-}
-/*-----------------------------------------------------------------*/
-/* genCmpGt :- greater than comparison */
-/*-----------------------------------------------------------------*/
-static void genCmpLe (iCode * ic) {
- printIc ("genCmpLe", ic, 1,1,1);
-}
-/*-----------------------------------------------------------------*/
-/* genCmpGt :- greater than comparison */
-/*-----------------------------------------------------------------*/
-static void genCmpGe (iCode * ic) {
- printIc ("genCmpGe", ic, 1,1,1);
-}
-/*-----------------------------------------------------------------*/
-/* genCmpGt :- greater than comparison */
-/*-----------------------------------------------------------------*/
-static void genCmpNe (iCode * ic) {
- printIc ("genCmpNe", ic, 1,1,1);
-}
-/*-----------------------------------------------------------------*/
-/* genCmpLt - less than comparisons */
-/*-----------------------------------------------------------------*/
-static void genCmpLt (iCode * ic) {
- printIc ("genCmpLt", ic, 1,1,1);
-}
-/*-----------------------------------------------------------------*/
-/* genCmpEq - generates code for equal to */
-/*-----------------------------------------------------------------*/
-static void genCmpEq (iCode * ic) {
- printIc ("genCmpEq", ic, 1,1,1);
+ printIc (0, "genMod", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
return NULL;
}
+/*-----------------------------------------------------------------*/
+/* genCmp - compares whatever */
+/*-----------------------------------------------------------------*/
+static void genCmp (iCode * ic, char *trueInstr, char *falseInstr) {
+ iCode *ifx=ifxForOp(IC_RESULT(ic),ic);
+ operand *left=IC_LEFT(ic), *right=IC_RIGHT(ic);
+ int size;
+ bool isTrue;
+ char *instr;
+ int jlbl;
+
+
+ size=aopOp(left, TRUE, TRUE);
+ aopOp(right, !aopIsPtr(left), TRUE);
+
+ if (size==1) {
+ instr="cmp.b";
+ } else {
+ instr="cmp.w";
+ }
+
+ if (IC_TRUE(ifx)) {
+ isTrue=TRUE;
+ jlbl=IC_TRUE(ifx)->key+100;
+ } else {
+ isTrue=FALSE;
+ jlbl=IC_FALSE(ifx)->key+100;
+ }
+
+ if (!ifx) {
+ aopOp(IC_RESULT(ic), !aopIsPtr(left), TRUE);
+ jlbl=newiTempLabel(NULL)->key+100;
+ emitcode("mov", "%s,#-1", AOP_NAME(IC_RESULT(ic))[0]);
+ emitcode(instr, "%s,%s", AOP_NAME(left)[0], AOP_NAME(right)[0]);
+ emitcode(isTrue ? trueInstr : falseInstr, "%05d$", jlbl);
+ emitcode("cpl", "%s", AOP_NAME(IC_RESULT(ic))[0]);
+ emitcode("", "%05d$:", jlbl);
+ } else {
+ emitcode(instr, "%s,%s", AOP_NAME(left)[0], AOP_NAME(right)[0]);
+ emitcode(isTrue ? trueInstr : falseInstr, "%05d$", jlbl);
+ ifx->generated=1;
+ }
+
+ if (size>2) {
+ bailOut("genCmp: size > 2");
+ }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genCmpEq :- generates code for equal to */
+/*-----------------------------------------------------------------*/
+static void genCmpEq (iCode * ic) {
+ printIc (0, "genCmpEq", ic, 0,1,1);
+ genCmp(ic, "beq", "bne"); // no sign
+}
+
+/*-----------------------------------------------------------------*/
+/* genCmpGt :- greater than comparison */
+/*-----------------------------------------------------------------*/
+static void genCmpGt (iCode * ic) {
+ printIc (0, "genCmpGt", ic, 0,1,1);
+ if (SPEC_USIGN(operandType(IC_LEFT(ic))) ||
+ SPEC_USIGN(operandType(IC_RIGHT(ic)))) {
+ genCmp(ic, "bg", "bl"); // unsigned
+ } else {
+ genCmp(ic, "bgt", "ble"); // signed
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* genCmpLt - less than comparisons */
+/*-----------------------------------------------------------------*/
+static void genCmpLt (iCode * ic) {
+ printIc (0, "genCmpLt", ic, 0,1,1);
+ if (SPEC_USIGN(operandType(IC_LEFT(ic))) ||
+ SPEC_USIGN(operandType(IC_RIGHT(ic)))) {
+ genCmp(ic, "bcs", "bcc"); // unsigned
+ } else {
+ genCmp(ic, "blt", "bge"); // signed
+ }
+}
+
/*-----------------------------------------------------------------*/
/* hasInc - operand is incremented before any other use */
/*-----------------------------------------------------------------*/
}
}
/* if the operand used or deffed */
- if (bitVectBitValue(OP_USES(op),lic->key) || (unsigned) lic->defKey == op->key) {
+ if (bitVectBitValue(OP_USES(op),lic->key) || lic->defKey == op->key) {
return NULL;
}
/* if GOTO or IFX */
/* genAndOp - for && operation */
/*-----------------------------------------------------------------*/
static void genAndOp (iCode * ic) {
- printIc ("genAndOp(&&)", ic, 1,1,1);
+ printIc (0, "genAndOp(&&)", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
/* genOrOp - for || operation */
/*-----------------------------------------------------------------*/
static void genOrOp (iCode * ic) {
- printIc ("genOrOp(||)", ic, 1,1,1);
+ printIc (0, "genOrOp(||)", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
/* genAnd - code for and */
/*-----------------------------------------------------------------*/
static void genAnd (iCode * ic, iCode * ifx) {
- printIc ("genAnd", ic, 1,1,1);
+ printIc (0, "genAnd", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
int size;
char *instr;
- printIc ("genOr", ic, 1,1,1);
+ printIc (0, "genOr", ic, 1,1,1);
size=aopOp(result, TRUE, TRUE);
/* genXor - code for xclusive or */
/*-----------------------------------------------------------------*/
static void genXor (iCode * ic, iCode * ifx) {
- printIc ("genXor", ic, 1,1,1);
+ printIc (0, "genXor", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genInline (iCode * ic) {
- printIc ("genInline", ic, 0,0,0);
+ printIc (0, "genInline", ic, 0,0,0);
emitcode ("", IC_INLINE(ic));
}
/* genRRC - rotate right with carry */
/*-----------------------------------------------------------------*/
static void genRRC (iCode * ic) {
- printIc ("genRRC", ic, 1,1,0);
+ printIc (0, "genRRC", ic, 1,1,0);
}
/*-----------------------------------------------------------------*/
/* genRLC - generate code for rotate left with carry */
/*-----------------------------------------------------------------*/
static void genRLC (iCode * ic) {
- printIc ("genRLC", ic, 1,1,0);
+ printIc (0, "genRLC", ic, 1,1,0);
}
/*-----------------------------------------------------------------*/
/* genGetHbit - generates code get highest order bit */
/*-----------------------------------------------------------------*/
static void genGetHbit (iCode * ic) {
- printIc ("genGetHbit", ic, 1,1,0);
+ printIc (0, "genGetHbit", ic, 1,1,0);
}
/*-----------------------------------------------------------------*/
/* genLeftShift - generates code for left shifting */
/*-----------------------------------------------------------------*/
static void genLeftShift (iCode * ic) {
- printIc ("genLeftShift", ic, 1,1,1);
+ printIc (0, "genLeftShift", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
/* genRightShift - generate code for right shifting */
/*-----------------------------------------------------------------*/
static void genRightShift (iCode * ic) {
- printIc ("genRightShift", ic, 1,1,1);
+ printIc (0, "genRightShift", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
int size;
if (pi) {
- printIc ("genPointerGet pi", ic, 1,1,0);
+ printIc (0, "genPointerGet pi", ic, 1,1,0);
} else {
- printIc ("genPointerGet", ic, 1,1,0);
+ printIc (0, "genPointerGet", ic, 1,1,0);
}
if (!IS_PTR(operandType(left))) {
switch (AOP_TYPE(left))
{
+ case AOP_LIT:
+ emitcode("mov","r1,%s", AOP_NAME(left)[0]);
+ sprintf (AOP_NAME(left)[0], "r1");
+ // fall through
case AOP_REG:
if (size>1) {
if (codePointer) {
operand *result=IC_RESULT(ic), *right=IC_RIGHT(ic);
int size;
- printIc ("genPointerSet", ic, 1,0,1);
+ printIc (0, "genPointerSet", ic, 1,0,1);
if (!IS_PTR(operandType(result))) {
bailOut ("genPointerSet: pointer required");
int size;
operand *left=IC_LEFT(ic);
- printIc ("genAddrOf", ic, 1,1,0);
+ printIc (0, "genAddrOf", ic, 1,1,0);
size=aopOp (IC_RESULT(ic), FALSE, TRUE);
getStackOffset(OP_SYMBOL(left)->stack));
if (size > 2) {
// this must be a generic pointer
- emitcode ("mov", "%s,#0x%02x", AOP_NAME(IC_RESULT(ic))[1], FPOINTER);
+ emitcode ("mov.b", "%s,#0x%02x", AOP_NAME(IC_RESULT(ic))[1], FPOINTER);
}
return;
}
int size;
char *instr;
- printIc ("genAssign", ic, 1,0,1);
+ printIc (0, "genAssign", ic, 1,0,1);
if (!IS_SYMOP(result)) {
bailOut("genAssign: result is not a symbol");
return;
}
+ // TODO: if (-8 >= right==lit <= 7) instr=MOVS
/* general case */
if (size>1) {
instr=MOVW;
/* genJumpTab - genrates code for jump table */
/*-----------------------------------------------------------------*/
static void genJumpTab (iCode * ic) {
- printIc ("genJumpTab", ic, 0,0,0);
+ printIc (0, "genJumpTab", ic, 0,0,0);
}
/*-----------------------------------------------------------------*/
sym_link *etype=getSpec(rtype);
short ptrType, signedness;
- printIc ("genCast", ic, 1,1,1);
+ printIc (0, "genCast", ic, 1,1,1);
aopOp(result, TRUE, TRUE);
aopOp(right, !aopIsPtr(result), AOP_TYPE(result)!=AOP_DIR);
switch (ptrType)
{
case POINTER:
- emitcode ("mov", "%s,#0x00", AOP_NAME(result)[1]);
+ emitcode ("mov.b", "%s,#0x00", AOP_NAME(result)[1]);
break;
case FPOINTER:
- emitcode ("mov", "%s,#0x01", AOP_NAME(result)[1]);
+ emitcode ("mov.b", "%s,#0x01", AOP_NAME(result)[1]);
break;
case CPOINTER:
- emitcode ("mov", "%s,#0x02", AOP_NAME(result)[1]);
+ emitcode ("mov.b", "%s,#0x02", AOP_NAME(result)[1]);
break;
default:
bailOut("genCast: got unknown storage class");
if (size==2)
return;
// fall through: case 0x41
- emitcode("sext", AOP_NAME(result)[1]);
+ if (signedness) {
+ emitcode("sext", "r1");
+ } else {
+ emitcode("mov", "r1,#0");
+ }
+ emitcode("mov", "%s,r1", AOP_NAME(result)[1]);
return;
case 0x14:
case 0x12:
if (getSize (operandType (IC_RESULT (ic))) > 2)
return 0;
- printIc ("genDjnz", ic, 1,1,1);
+ printIc (0, "genDjnz", ic, 1,1,1);
/* otherwise we can save BIG */
lbl = newiTempLabel (NULL);
/* genReceive - generate code for a receive iCode */
/*-----------------------------------------------------------------*/
static void genReceive (iCode * ic) {
- printIc ("genReceive", ic, 1,0,0);
+ printIc (0, "genReceive", ic, 1,0,0);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDummyRead - generate code for dummy read of volatiles */
+/*-----------------------------------------------------------------*/
+static void
+genDummyRead (iCode * ic)
+{
+ emitcode ("; genDummyRead","");
+
+ ic = ic;
}
/*-----------------------------------------------------------------*/
void genXA51Code (iCode * lic) {
iCode *ic;
int cln = 0;
-
+
lineHead = lineCurr = NULL;
-
+
/* if debug information required */
if (options.debug && currFunc)
{
- cdbSymbol (currFunc, cdbFile, FALSE, TRUE);
- _G.debugLine = 1;
- if (IS_STATIC (currFunc->etype))
- emitcode ("", "F%s$%s$0$0 ==.", moduleName, currFunc->name);
- else
- emitcode ("", "G$%s$0$0 ==.", currFunc->name);
- _G.debugLine = 0;
+ debugFile->writeFunction (currFunc, lic);
}
-
+
for (ic = lic; ic; ic = ic->next) {
if (ic->lineno && cln != ic->lineno) {
if (options.debug) {
- _G.debugLine = 1;
- emitcode ("", "C$%s$%d$%d$%d ==.",
- FileBaseName (ic->filename), ic->lineno,
- ic->level, ic->block);
- _G.debugLine = 0;
+ debugFile->writeCLine (ic);
+ }
+ if (!options.noCcodeInAsm) {
+ emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
+ printCLine(ic->filename, ic->lineno));
}
- emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
- printCLine(ic->filename, ic->lineno));
cln = ic->lineno;
}
+ if (options.iCodeInAsm) {
+ char *iLine = printILine(ic);
+ emitcode("", ";ic:%d: %s", ic->key, iLine);
+ dbuf_free(iLine);
+ }
+
/* if the result is marked as
spilt and rematerializable or code for
this has already been generated then
do nothing */
if (resultRemat (ic) || ic->generated)
continue;
-
+
/* depending on the operation */
switch (ic->op)
{
case '!':
genNot (ic);
break;
-
+
case '~':
genCpl (ic);
break;
-
+
case UNARYMINUS:
genUminus (ic);
break;
break;
case LE_OP:
- genCmpLe (ic);
- break;
-
case GE_OP:
- genCmpGe (ic);
- break;
-
case NE_OP:
- genCmpNe (ic);
+
+ /* note these two are xlated by algebraic equivalence
+ during parsing SDCC.y */
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "got '>=' or '<=' shouldn't have come here");
break;
case EQ_OP:
case RLC:
genRLC (ic);
break;
-
+
case GETHBIT:
genGetHbit (ic);
break;
case RECEIVE:
genReceive (ic);
break;
-
+
case SEND:
addSet (&_G.sendSet, ic);
break;
-
+
+ case DUMMY_READ_VOLATILE:
+ genDummyRead (ic);
+ break;
+
default:
ic = ic;
}
}
-
-
+
+
/* now we are ready to call the
peep hole optimizer */
if (!options.nopeep)
peepHole (&lineHead);
-
+
/* now do the actual printing */
- printLine (lineHead, codeOutFile);
+ printLine (lineHead, codeOutBuf);
return;
}
projects / fw / sdcc / blobdiff