#define MSB24 2
#define MSB32 3
+static char *MOVB="mov.b";
+static char *MOVW="mov.w";
+//static char *MOVCB="movc.b";
+//static char *MOVCW="movc.w";
+
+void bailOut (char *mesg) {
+ fprintf (stderr, "%s: bailing out\n", mesg);
+ exit (1);
+}
+
/*-----------------------------------------------------------------*/
/* emitcode - writes the code into a file : for now it is simple */
/*-----------------------------------------------------------------*/
va_end (ap);
}
+char *getStackOffset(int stack) {
+ static char gsoBuf[1024];
+ sprintf (gsoBuf, "r7+(%d%+d%+d)", stack,
+ FUNC_ISISR(currFunc->type) ?
+ port->stack.isr_overhead : port->stack.call_overhead,
+ _G.nRegsSaved);
+ return gsoBuf;
+}
+
/*-----------------------------------------------------------------*/
/* newAsmop - creates a new asmOp */
/*-----------------------------------------------------------------*/
case AOP_DIR: return "dir";
case AOP_FAR: return "far";
case AOP_CODE: return "code";
+ case AOP_GPTR: return "gptr";
case AOP_STK: return "stack";
case AOP_IMMD: return "imm";
- case AOP_CRY: return "bit";
+ case AOP_BIT: return "bit";
}
return "unknown";
}
/*-----------------------------------------------------------------*/
/* aopForSym - for a true symbol */
/*-----------------------------------------------------------------*/
-static asmop *aopForSym(symbol *sym, bool result) {
+static asmop *aopForSym(symbol *sym, bool result, bool cantUsePointer) {
+ int size;
asmop *aop;
sym->aop = aop = newAsmop(0);
- aop->size=getSize(sym->type);
+ size=aop->size=getSize(sym->type);
- // if it is in registers
+ // if the sym has registers
if (sym->nRegs && sym->regs[0]) {
aop->type=AOP_REG;
- if (sym->regs[1]) {
+ sprintf (aop->name[0], sym->regs[0]->name);
+ if (size > 2) {
sprintf (aop->name[1], sym->regs[1]->name);
}
- sprintf (aop->name[0], sym->regs[0]->name);
return aop;
}
// if it is on stack
if (sym->onStack) {
+ if (cantUsePointer) {
+ aop->type=AOP_REG;
+ switch (size)
+ {
+ case 1:
+ emitcode ("mov.b", "r0l,[%s]", getStackOffset(sym->stack));
+ sprintf (aop->name[0], "r0l");
+ return aop;
+ case 2:
+ emitcode ("mov.w", "r0,[%s]", getStackOffset(sym->stack));
+ sprintf (aop->name[0], "r0");
+ return aop;
+ case 3:
+ emitcode ("mov.w", "r0,[%s]", getStackOffset(sym->stack));
+ sprintf (aop->name[0], "r0");
+ emitcode ("mov.b", "r1l,[%s]", getStackOffset(sym->stack+2));
+ sprintf (aop->name[1], "r1l");
+ return aop;
+ case 4:
+ emitcode ("mov.w", "r0,[%s]", getStackOffset(sym->stack));
+ sprintf (aop->name[0], "r0");
+ emitcode ("mov.w", "r1,[%s]", getStackOffset(sym->stack+2));
+ sprintf (aop->name[1], "r1");
+ return aop;
+ }
+ bailOut("aopForSym: onStack CantUsePointer unknown size");
+ }
aop->type=AOP_STK;
- sprintf (aop->name[0], "[r7+%d+0+%d+%d]", sym->stack,
- FUNC_ISISR(currFunc->type) ? 6 : 4, _G.nRegsSaved);
- sprintf (aop->name[1], "[r7+%d+2+%d+%d]", sym->stack,
- FUNC_ISISR(currFunc->type) ? 6 : 4, _G.nRegsSaved);
+ sprintf (aop->name[0], "[%s]", getStackOffset(sym->stack));
+ if (size > 2) {
+ sprintf (aop->name[1], "[%s]", getStackOffset(sym->stack+2));
+ }
return aop;
}
// if it has a spillLoc
if (sym->usl.spillLoc) {
- return aopForSym (sym->usl.spillLoc, result);
+ return aopForSym (sym->usl.spillLoc, result, cantUsePointer);
}
// if in bit space
if (IN_BITSPACE(SPEC_OCLS(sym->etype))) {
- aop->type=AOP_CRY;
+ aop->type=AOP_BIT;
sprintf (aop->name[0], sym->rname);
return aop;
}
if (IN_DIRSPACE(SPEC_OCLS(sym->etype))) {
aop->type=AOP_DIR;
sprintf (aop->name[0], sym->rname);
- sprintf (aop->name[1], "#0x%02x", POINTER);
+ if (size>2) {
+ sprintf (aop->name[1], "%s+2", sym->rname);
+ }
return aop;
}
// if in code space
if (IN_CODESPACE(SPEC_OCLS(sym->etype))) {
if (result) {
- fprintf (stderr, "aopForSym: result can not be in code space\n");
- exit (1);
+ bailOut("aopForSym: result can not be in code space");
}
aop->type=AOP_CODE;
- emitcode ("mov", "r0,#%s", sym->rname);
- sprintf (aop->name[0], "r0");
- sprintf (aop->name[1], "#0x%02x", CPOINTER);
+ emitcode ("mov", "r0,#%s ; aopForSym:code", sym->rname);
+ sprintf (aop->name[0], "[r0]");
+ if (size>2) {
+ sprintf (aop->name[1], "[r0+2]");
+ }
return aop;
}
// if in far space
if (IN_FARSPACE(SPEC_OCLS(sym->etype))) {
aop->type=AOP_FAR;
- emitcode ("mov", "r0,#%s", sym->rname);
+ emitcode ("mov", "r0,#%s ; aopForSym:far", sym->rname);
sprintf (aop->name[0], "[r0]");
- if (result) {
+ if (size>2) {
sprintf (aop->name[1], "[r0+2]");
- } else {
- sprintf (aop->name[1], "#0x%02x", FPOINTER);
}
return aop;
}
- // special case for a function
- if (IS_FUNC (sym->type)) {
- aop->type=AOP_IMMD;
- sprintf (aop->name[0], sym->rname);
- return aop;
- }
-
- fprintf (stderr, "aopForSym (%s): What's up?\n", sym->name);
- exit (1);
+ bailOut("aopForSym");
+ return NULL;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static asmop *aopForVal(operand *op) {
asmop *aop;
- long v=floatFromVal(OP_VALUE(op));
if (IS_OP_LITERAL(op)) {
op->aop = aop = newAsmop (AOP_LIT);
switch ((aop->size=getSize(operandType(op))))
{
case 1:
- sprintf (aop->name[0], "#0x%02lx", v);
+ sprintf (aop->name[0], "#0x%02x",
+ SPEC_CVAL(operandType(op)).v_int & 0xff);
+ sprintf (aop->name[1], "#0");
break;
case 2:
- sprintf (aop->name[0], "#0x%04lx", v);
+ sprintf (aop->name[0], "#0x%04x",
+ SPEC_CVAL(operandType(op)).v_int & 0xffff);
+ sprintf (aop->name[1], "#0");
+ break;
+ case 3:
+ // must be a generic pointer, can only be zero
+ // ?? if (v!=0) fprintf (stderr, "invalid val op for gptr\n"); exit(1);
+ sprintf (aop->name[0], "#0x%04x",
+ SPEC_CVAL(operandType(op)).v_uint & 0xffff);
+ sprintf (aop->name[1], "#0");
break;
case 4:
- sprintf (aop->name[0], "#(0x%08lx >> 16)", v);
- sprintf (aop->name[1], "#(0x%08lx & 0xffff)", v);
+ sprintf (aop->name[0], "#0x%04lx",
+ SPEC_CVAL(operandType(op)).v_ulong >> 16);
+ sprintf (aop->name[1], "#0x%04x",
+ SPEC_CVAL(operandType(op)).v_ulong && 0xffff);
break;
default:
- fprintf (stderr, "aopForVal (lit): unknown size\n");
- exit (1);
+ bailOut("aopForVal");
}
return aop;
}
return aop;
}
}
- fprintf (stderr, "aopForVal: unknown type\n");
- exit (1);
+
+ bailOut ("aopForVal: unknown type");
return NULL;
}
-static void aopOp(operand *op, bool result) {
+static void aopOp(operand *op, bool result, bool cantUsePointer) {
if (IS_SYMOP(op)) {
- op->aop=aopForSym (OP_SYMBOL(op), result);
+ op->aop=aopForSym (OP_SYMBOL(op), result, cantUsePointer);
return;
}
if (IS_VALOP(op)) {
if (result) {
- fprintf (stderr, "aopOp: result can not be a value\n");
- exit (1);
+ bailOut("aopOp: result can not be a value");
}
- aopForVal (op);
+ op->aop=aopForVal (op);
return;
}
- fprintf (stderr, "aopOp: unexpected operand\n");
- exit (1);
+ bailOut("aopOp: unexpected operand");
}
+bool aopIsPtr(operand *op) {
+ if (AOP_TYPE(op)==AOP_STK ||
+ AOP_TYPE(op)==AOP_CODE ||
+ AOP_TYPE(op)==AOP_FAR) {
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
char *opRegName(operand *op, int offset, char *opName) {
if (IS_SYMOP(op)) {
if (OP_SYMBOL(op)->onStack) {
- sprintf (opName, "[r7+%d+0+%d+%d]", OP_SYMBOL(op)->stack,
- FUNC_ISISR(currFunc->type) ? 6 : 4, _G.nRegsSaved);
+ sprintf (opName, "[%s]", getStackOffset(OP_SYMBOL(op)->stack));
return opName;
}
if (IS_TRUE_SYMOP(op))
else if (OP_SYMBOL(op)->regs[offset])
return OP_SYMBOL(op)->regs[offset]->name;
else
- return "NULL";
+ bailOut("opRegName: unknown regs");
}
if (IS_VALOP(op)) {
switch (SPEC_NOUN(OP_VALUE(op)->type)) {
+ case V_SBIT:
case V_BIT:
if (SPEC_CVAL(OP_VALUE(op)->type).v_int &&
SPEC_CVAL(OP_VALUE(op)->type).v_int != 1) {
- fprintf (stderr, "opRegName: invalid bit value (%d)\n",
- SPEC_CVAL(OP_VALUE(op)->type).v_int);
- exit (1);
+ bailOut("opRegName: invalid bit value");
}
// fall through
case V_CHAR:
}
break;
case V_FLOAT:
- sprintf (opName, "#0x%02lx", SPEC_CVAL(OP_VALUE(op)->type).v_long);
+ sprintf (opName, "#%f", SPEC_CVAL(OP_VALUE(op)->type).v_float);
break;
default:
- fprintf (stderr, "opRegName: unexpected noun\n");
- exit (1);
+ bailOut("opRegName: unexpected noun");
}
return opName;
}
- fprintf (stderr, "opRegName: unexpected operand type\n");
- exit (1);
- return NULL; // to keep the compiler happy
+ bailOut("opRegName: unexpected operand type");
+ return NULL;
}
char * printOp (operand *op) {
static char line[132];
- bool isPtr = op->isPtr | op->isGptr;
+ sym_link *optype=operandType(op);
+ bool isPtr = IS_PTR(optype);
if (IS_SYMOP(op)) {
symbol *sym=OP_SYMBOL(op);
sym=SYM_SPIL_LOC(sym);
}
if (isPtr) {
- sprintf (line, "[%s]:", sym->name);
+ sprintf (line, "[");
+ if (DCL_TYPE(optype)==FPOINTER)
+ strcat (line, "far * ");
+ else if (DCL_TYPE(optype)==CPOINTER)
+ strcat (line, "code * ");
+ else if (DCL_TYPE(optype)==GPOINTER)
+ strcat (line, "gen * ");
+ else if (DCL_TYPE(optype)==POINTER)
+ strcat (line, "near * ");
+ else
+ strcat (line, "unknown * ");
+ strcat (line, "(");
+ strcat (line, nounName(sym->etype));
+ strcat (line, ")");
+ strcat (line, sym->name);
+ strcat (line, "]:");
} else {
- sprintf (line, "%s:", sym->name);
+ sprintf (line, "(%s)%s:", nounName(sym->etype), sym->name);
}
if (sym->regs[0]) {
strcat (line, sym->regs[0]->name);
return line;
}
if (sym->onStack) {
- sprintf (line+strlen(line), "stack+%d", sym->stack);
+ sprintf (line+strlen(line), "stack%+d", sym->stack);
+ return line;
+ }
+ if (IN_CODESPACE(SPEC_OCLS(sym->etype))) {
+ strcat (line, "code");
return line;
}
if (IN_FARSPACE(SPEC_OCLS(sym->etype))) {
} else if (IS_VALOP(op)) {
opRegName(op, 0, line);
} else if (IS_TYPOP(op)) {
- sprintf (line, "(");
+ sprintf (line, "[");
+ if (isPtr) {
+ if (DCL_TYPE(optype)==FPOINTER)
+ strcat (line, "far * ");
+ else if (DCL_TYPE(optype)==CPOINTER)
+ strcat (line, "code * ");
+ else if (DCL_TYPE(optype)==GPOINTER)
+ strcat (line, "gen * ");
+ else if (DCL_TYPE(optype)==POINTER)
+ strcat (line, "near * ");
+ else
+ strcat (line, "unknown * ");
+ }
// forget about static, volatile, ... for now
if (SPEC_USIGN(operandType(op))) strcat (line, "unsigned ");
if (SPEC_LONG(operandType(op))) strcat (line, "long ");
strcat (line, nounName(operandType(op)));
- strcat (line, ")");
+ strcat (line, "]");
} else {
- fprintf (stderr, "printOp: unexpected operand type\n");
- exit (1);
+ bailOut("printOp: unexpected operand type");
}
return line;
}
void printIc (char *op, iCode * ic, bool result, bool left, bool right) {
char line[132];
- sprintf (line, "%s", op);
+ sprintf (line, "%s(%d)", op, ic->lineno);
if (result) {
strcat (line, " result=");
strcat (line, printOp (IC_RESULT(ic)));
}
/*-----------------------------------------------------------------*/
-/* toBoolean - return bit for operand!=0 */
+/* toBoolean - return carry for operand!=0 */
/*-----------------------------------------------------------------*/
static char *toBoolean (operand * op) {
switch (AOP_SIZE(op))
case 1:
case 2:
emitcode ("cmp", "%s,#0", AOP_NAME(op));
- return "z";
+ emitcode ("mov", "c,z");
+ return "c";
}
- fprintf (stderr, "toBoolean: unknown size %d\n", AOP_SIZE(op));
- exit (1);
+ bailOut("toBoolean: unknown size");
return NULL;
}
/* genCall - generates a call statement */
/*-----------------------------------------------------------------*/
static void genCall (iCode * ic) {
- emitcode (";", "genCall %s", OP_SYMBOL(IC_LEFT(ic))->name);
+ emitcode (";", "genCall %s result=%s", OP_SYMBOL(IC_LEFT(ic))->name,
+ printOp (IC_RESULT(ic)));
}
/*-----------------------------------------------------------------*/
/* genRet - generate code for return statement */
/*-----------------------------------------------------------------*/
static void genRet (iCode * ic) {
- emitcode (";", "genRet");
+
+ printIc ("genRet", ic, 0,1,0);
+
+ aopOp(IC_LEFT(ic),FALSE, FALSE);
+
+ 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]);
+ return;
+ 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]);
+ return;
+ case 1:
+ emitcode ("mov", "r0l,%s", AOP_NAME(IC_LEFT(ic))[0]);
+ return;
+ }
+ bailOut("genRet");
}
/*-----------------------------------------------------------------*/
}
/*-----------------------------------------------------------------*/
-/* genGoto - generates a ljmp */
+/* genGoto - generates a jmp */
/*-----------------------------------------------------------------*/
static void genGoto (iCode * ic) {
emitcode (";", "genGoto %s", IC_LABEL(ic)->name);
- emitcode ("ljmp", "%05d$", (IC_LABEL (ic)->key + 100));
+ emitcode ("jmp", "%05d$", (IC_LABEL (ic)->key + 100));
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
/* genCmpGt :- greater than comparison */
/*-----------------------------------------------------------------*/
-static void genCmpGt (iCode * ic, iCode * ifx) {
+static void genCmpGt (iCode * ic) {
+ printIc ("genCmpGt", ic, 1,1,1);
+}
+/*-----------------------------------------------------------------*/
+/* genCmpGt :- greater than comparison */
+/*-----------------------------------------------------------------*/
+static void genCmpLe (iCode * ic) {
+ printIc ("genCmpGt", ic, 1,1,1);
+}
+/*-----------------------------------------------------------------*/
+/* genCmpGt :- greater than comparison */
+/*-----------------------------------------------------------------*/
+static void genCmpGe (iCode * ic) {
+ printIc ("genCmpGt", ic, 1,1,1);
+}
+/*-----------------------------------------------------------------*/
+/* genCmpGt :- greater than comparison */
+/*-----------------------------------------------------------------*/
+static void genCmpNe (iCode * ic) {
printIc ("genCmpGt", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
/* genCmpLt - less than comparisons */
/*-----------------------------------------------------------------*/
-static void genCmpLt (iCode * ic, iCode * ifx) {
+static void genCmpLt (iCode * ic) {
printIc ("genCmpLt", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
/* genCmpEq - generates code for equal to */
/*-----------------------------------------------------------------*/
-static void genCmpEq (iCode * ic, iCode * ifx) {
+static void genCmpEq (iCode * ic) {
printIc ("genCmpEq", ic, 1,1,1);
}
/*-----------------------------------------------------------------*/
static void genPointerGet (iCode * ic, iCode *pi) {
printIc ("genPointerGet", ic, 1,1,0);
+#if 0
+ char *instr, *scratchReg;
+ operand *result=IC_RESULT(ic), *left=IC_LEFT(ic);
+
+ if (!IS_PTR(operandType(left))) {
+ bailOut ("genPointerGet: pointer required");
+ }
+
+ aopOp(left,FALSE);
+ aopOp(result,TRUE);
+
+ if (IS_GENPTR(operandType(left))) {
+ emitcode (";", "INLINE\t_gptrget ; %s %s = [%s %s]",
+ AOP_NAME(result)[0], AOP_NAME(result)[1],
+ AOP_NAME(left)[0], AOP_NAME(left)[1]);
+ return;
+ }
+
+ switch (AOP_TYPE(left))
+ {
+ case AOP_CODE:
+ if (AOP_SIZE(result)==1) {
+ instr=MOVCB;
+ } else {
+ instr=MOVCW;
+ }
+ emitcode (instr, "%s,[%s]", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ if (AOP_SIZE(result) > 2) {
+ if (AOP_SIZE(result)==3) {
+ instr=MOVCB;
+ } else {
+ instr=MOVCW;
+ }
+ emitcode (instr, "%s,[%s+2]", AOP_NAME(result)[1], AOP_NAME(left)[0]);
+ }
+ return;
+ case AOP_FAR:
+ if (AOP_SIZE(result)==1) {
+ instr=MOVB;
+ } else {
+ instr=MOVW;
+ }
+ emitcode (instr, "%s,[%s]", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ if (AOP_SIZE(result) > 2) {
+ if (AOP_SIZE(result)==3) {
+ instr=MOVB;
+ } else {
+ instr=MOVW;
+ }
+ emitcode (instr, "%s,[%s+2]", AOP_NAME(result)[1], AOP_NAME(left)[0]);
+ }
+ return;
+ case AOP_DIR:
+ if (AOP_SIZE(result)==1) {
+ instr=MOVB;
+ } else {
+ instr=MOVW;
+ }
+ emitcode (instr, "%s,%s", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ if (AOP_SIZE(result) > 2) {
+ if (AOP_SIZE(result)==3) {
+ instr=MOVB;
+ } else {
+ instr=MOVW;
+ }
+ emitcode (instr, "%s,%s+2", AOP_NAME(result)[1], AOP_NAME(left)[0]);
+ }
+ return;
+ case AOP_REG:
+ if (AOP_SIZE(result)==1) {
+ instr=MOVB;
+ scratchReg=R0L;
+ } else {
+ instr=MOVW;
+ scratchReg=R0;
+ }
+ // if result=onstack
+ if (AOP_TYPE(result)==AOP_STK) {
+ emitcode (instr, "%s,[%s]", scratchReg, AOP_NAME(left)[0]);
+ emitcode (instr, "%s,%s", AOP_NAME(result)[0], scratchReg);
+ } else {
+ emitcode (instr, "%s,[%s]", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ }
+ if (AOP_SIZE(result) > 2) {
+ // result is generic pointer
+ sym_link *optype=operandType(left);
+ sym_link *opetype=getSpec(optype);
+ if (IS_PTR(optype) && !IS_GENPTR(optype)) {
+ emitcode (MOVB, "%s,#0x%02x", AOP_NAME(result)[1],
+ PTR_TYPE(SPEC_OCLS(opetype)));
+ } else {
+ emitcode (MOVB, "%s,[%s]", AOP_NAME(result)[1], AOP_NAME(left)[1]);
+ }
+ }
+ return;
+ case AOP_STK:
+ // if both on stack
+ if (AOP_TYPE(result)==AOP_STK) {
+ if (AOP_SIZE(result)==1) {
+ emitcode ("mov", "r0l,%s", AOP_NAME(left)[0]);
+ emitcode ("mov", "%s,r0l", AOP_NAME(result)[0]);
+ } else {
+ emitcode ("mov", "r0,%s", AOP_NAME(left)[0]);
+ emitcode ("mov", "%s,r0", AOP_NAME(result)[0]);
+ }
+ } else {
+ if (AOP_SIZE(result)==1) {
+ emitcode ("mov.b", "%s,%s", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ } else {
+ emitcode ("mov.w", "%s,%s", AOP_NAME(result)[0], AOP_NAME(left)[0]);
+ }
+ }
+ if (AOP_SIZE(result) > 2) {
+ if (AOP_TYPE(result)==AOP_STK) {
+ if (AOP_SIZE(result)==3) {
+ emitcode ("mov", "r0l,%s", AOP_NAME(left)[1]);
+ emitcode ("mov", "%s,r0l", AOP_NAME(result)[1]);
+ } else {
+ emitcode ("mov", "r0,%s", AOP_NAME(left)[1]);
+ emitcode ("mov", "%s,r0", AOP_NAME(result)[1]);
+ }
+ } else {
+ emitcode ("mov", "%s,%s", AOP_NAME(result)[1], AOP_NAME(left)[1]);
+ }
+ }
+ return;
+ }
+ bailOut ("genPointerGet: unknown pointer");
+#endif
}
/*-----------------------------------------------------------------*/
/* genIfx - generate code for Ifx statement */
/*-----------------------------------------------------------------*/
static void genIfx (iCode * ic, iCode * popIc) {
+ char *instr;
bool trueOrFalse;
symbol *jlbl, *tlbl;
operand *cond=IC_COND(ic);
IC_TRUE(ic) ? IC_TRUE(ic)->name : "NULL",
IC_FALSE(ic) ? IC_FALSE(ic)->name : "NULL");
- aopOp(cond,FALSE);
+ aopOp(cond,FALSE,FALSE);
if (IC_TRUE(ic)) {
trueOrFalse=TRUE;
switch (AOP_TYPE(cond) )
{
- case AOP_CRY:
+ case AOP_BIT:
emitcode (trueOrFalse ? "jb" : "jbc", "%s,%05d$",
AOP_NAME(cond)[0], jlbl->key+100);
return;
case AOP_REG:
case AOP_DIR:
case AOP_FAR:
+ case AOP_STK:
tlbl=newiTempLabel(NULL);
- emitcode ("cmp", "%s,#0", AOP_NAME(cond)[0]);
- emitcode (trueOrFalse ? "bne" : "beq", "%05d$", tlbl->key+100);
- if (*AOP_NAME(cond)[1]) {
- emitcode ("cmp", "%s,#0", AOP_NAME(cond)[1]);
- emitcode (trueOrFalse ? "bne" : "beq", "%05d$", tlbl->key+100);
+ if (AOP_SIZE(cond)==1) {
+ instr="cmp.b";
+ } else {
+ instr="cmp.w";
+ }
+ emitcode (instr, "%s,#0", AOP_NAME(cond)[0]);
+ emitcode (trueOrFalse ? "beq" : "bne", "%05d$", tlbl->key+100);
+ if (AOP_SIZE(cond) > 2) {
+ if (AOP_SIZE(cond)==3) {
+ instr="cmp.b";
+ } else {
+ instr="cmp.w";
+ }
+ emitcode (instr, "%s,#0", AOP_NAME(cond)[1]);
+ emitcode (trueOrFalse ? "beq" : "bne", "%05d$", tlbl->key+100);
}
emitcode ("jmp", "%05d$", jlbl->key+100);
emitcode ("", "%05d$:", tlbl->key+100);
return;
}
+ bailOut ("genIfx");
}
/*-----------------------------------------------------------------*/
/* genAddrOf - generates code for address of */
/*-----------------------------------------------------------------*/
static void genAddrOf (iCode * ic) {
+ operand *left=IC_LEFT(ic);
+
printIc ("genAddrOf", ic, 1,1,0);
+
+ aopOp (IC_RESULT(ic),TRUE, FALSE);
+
+ if (isOperandOnStack(left)) {
+ emitcode ("lea", "%s,%s", AOP_NAME(IC_RESULT(ic))[0],
+ getStackOffset(OP_SYMBOL(left)->stack));
+ if (AOP_SIZE(IC_RESULT(ic)) > 2) {
+ // this must be a generic pointer
+ emitcode ("mov", "%s,#0x%02x", AOP_NAME(IC_RESULT(ic))[1], FPOINTER);
+ }
+ return;
+ }
+
+ if (isOperandInDirSpace(left) ||
+ isOperandInFarSpace(left) ||
+ isOperandInCodeSpace(left)) {
+ emitcode ("mov.w", "%s,#%s", AOP_NAME(IC_RESULT(ic))[0],
+ OP_SYMBOL(left)->rname);
+ if (AOP_SIZE(IC_RESULT(ic)) > 2) {
+ // this must be a generic pointer
+ int space=0; // dir space
+ if (isOperandInFarSpace(left)) {
+ space=1;
+ } else if (isOperandInCodeSpace(left)) {
+ space=2;
+ }
+ emitcode ("mov.b", "%s,#0x%02x", AOP_NAME(IC_RESULT(ic))[1], space);
+ }
+ return;
+ }
+
+ bailOut("genAddrOf");
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genAssign (iCode * ic) {
operand *result=IC_RESULT(ic), *right=IC_RIGHT(ic);
+ int size;
+ char *instr;
printIc ("genAssign", ic, 1,0,1);
if (!IS_SYMOP(result)) {
- fprintf (stderr, "genAssign: result is not a symbol\n");
- exit (1);
+ bailOut("genAssign: result is not a symbol");
}
- aopOp(right, FALSE);
- aopOp(result, TRUE);
-
- if (result->aop->type==AOP_REG ||
- right->aop->type==AOP_REG ||
- right->aop->type==AOP_LIT ||
- right->aop->type==AOP_IMMD) {
- // everything will do
- } else {
- // they have to match
- if (result->aop->type != right->aop->type) {
- fprintf (stderr, "genAssign: types don't match (%s!=%s)\n",
- aopTypeName(result->aop), aopTypeName(right->aop));
- exit (1);
- }
- }
+ aopOp(result, TRUE, FALSE);
+ aopOp(right, FALSE, aopIsPtr(result));
+ size=AOP_SIZE(result);
/* if result is a bit */
- if (AOP_TYPE(result) == AOP_CRY) {
+ if (AOP_TYPE(result) == AOP_BIT) {
/* if right is literal, we know what the value is */
if (AOP_TYPE(right) == AOP_LIT) {
if (operandLitValue(right)) {
return;
}
/* if right is also a bit */
- if (AOP_TYPE(right) == AOP_CRY) {
+ if (AOP_TYPE(right) == AOP_BIT) {
emitcode ("mov", "c,%s", AOP_NAME(right));
emitcode ("mov", "%s,c", AOP_NAME(result));
return;
}
/* general case */
- emitcode ("mov", "%s,%s",
- result->aop->name[0], right->aop->name[0]);
- if (IS_GENPTR(operandType(result))) {
- emitcode ("mov", "%s,%s",
- result->aop->name[1], right->aop->name[1]);
+ if (size==1) {
+ instr=MOVB;
+ } else {
+ instr=MOVW;
+ }
+ emitcode (instr, "%s,%s", AOP_NAME(result)[0], AOP_NAME(right)[0]);
+
+ if (AOP_SIZE(result) > 2) {
+ if (size==3) {
+ // generic pointer
+ instr=MOVB;
+ } else {
+ instr=MOVW;
+ }
+ emitcode (instr, "%s,%s", AOP_NAME(result)[1], AOP_NAME(right)[1]);
+ return;
}
-
}
/*-----------------------------------------------------------------*/
/* genDjnz - generate decrement & jump if not zero instrucion */
/*-----------------------------------------------------------------*/
static bool genDjnz (iCode * ic, iCode * ifx) {
- printIc ("genDjnz", ic, 0,0,0);
+ symbol *lbl, *lbl1;
+
+ if (!ifx)
+ return 0;
+
+ /* if the if condition has a false label
+ then we cannot save */
+ if (IC_FALSE (ifx))
+ return 0;
+
+ /* if the minus is not of the form
+ a = a - 1 */
+ if (!isOperandEqual (IC_RESULT (ic), IC_LEFT (ic)) ||
+ !IS_OP_LITERAL (IC_RIGHT (ic)))
+ return 0;
+
+ if (operandLitValue (IC_RIGHT (ic)) != 1)
+ return 0;
+
+ /* if the size of this greater than two then no
+ saving */
+ if (getSize (operandType (IC_RESULT (ic))) > 2)
+ return 0;
+
+ printIc ("genDjnz", ic, 1,1,1);
+
+ /* otherwise we can save BIG */
+ lbl = newiTempLabel (NULL);
+ lbl1 = newiTempLabel (NULL);
+
+ aopOp (IC_RESULT (ic), TRUE, FALSE);
+
+ if (AOP_TYPE(IC_RESULT(ic))==AOP_REG || AOP_TYPE(IC_RESULT(ic))==AOP_DIR) {
+ emitcode ("djnz", "%s,%05d$", AOP_NAME(IC_RESULT(ic)), lbl->key+100);
+ emitcode ("br", "%05d$", lbl1->key + 100);
+ emitcode ("", "%05d$:", lbl->key + 100);
+ emitcode ("jmp", "%05d$", IC_TRUE (ifx)->key + 100);
+ emitcode ("", "%05d$:", lbl1->key + 100);
+ return TRUE;
+ }
+
+ bailOut("genDjnz: aop type");
return FALSE;
}
iCode *ic;
int cln = 0;
- fprintf (stderr, "genXA51Code\n");
lineHead = lineCurr = NULL;
/* print the allocation information */
}
for (ic = lic; ic; ic = ic->next) {
- if (cln != ic->lineno) {
+ if (ic->lineno && cln != ic->lineno) {
if (options.debug) {
_G.debugLine = 1;
emitcode ("", "C$%s$%d$%d$%d ==.",
ic->level, ic->block);
_G.debugLine = 0;
}
- emitcode (";", "%s %d", ic->filename, ic->lineno);
+ emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
+ printCLine(ic->filename, ic->lineno));
cln = ic->lineno;
}
/* if the result is marked as
break;
case '>':
- genCmpGt (ic, ifxForOp (IC_RESULT (ic), ic));
+ genCmpGt (ic);
break;
case '<':
- genCmpLt (ic, ifxForOp (IC_RESULT (ic), ic));
+ genCmpLt (ic);
break;
case LE_OP:
+ genCmpLe (ic);
+ break;
+
case GE_OP:
+ genCmpGe (ic);
+ break;
+
case NE_OP:
-
- /* 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");
+ genCmpNe (ic);
break;
-
+
case EQ_OP:
- genCmpEq (ic, ifxForOp (IC_RESULT (ic), ic));
+ genCmpEq (ic);
break;
case AND_OP: