X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fmcs51%2Fgen.c;h=957d58dca8dcff26bb363f35348308b930bc40fd;hb=6210487131834e13c9a50d4eb9739f9036bb66e0;hp=0757d80dcbd284ecb38568a82fb079b03d7eaf10;hpb=a0df5f7e9b47a96bef4a94b8c96692f0156acec0;p=fw%2Fsdcc diff --git a/src/mcs51/gen.c b/src/mcs51/gen.c index 0757d80d..957d58dc 100644 --- a/src/mcs51/gen.c +++ b/src/mcs51/gen.c @@ -1,5 +1,5 @@ /*------------------------------------------------------------------------- - SDCCgen51.c - source file for code generation for 8051 + gen.c - source file for code generation for 8051 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998) and - Jean-Louis VERN.jlvern@writeme.com (1999) @@ -28,8 +28,7 @@ Made everything static -------------------------------------------------------------------------*/ -//#define D(x) -#define D(x) x +#define D(x) do if (options.verboseAsm) {x;} while(0) #include #include @@ -41,7 +40,9 @@ #include "common.h" #include "SDCCpeeph.h" #include "ralloc.h" +#include "rtrack.h" #include "gen.h" +#include "dbuf_string.h" char *aopLiteral (value * val, int offset); char *aopLiteralLong (value * val, int offset, int size); @@ -65,19 +66,21 @@ static char *accUse[] = static unsigned short rbank = -1; +#define REG_WITH_INDEX mcs51_regWithIdx + #define AOP(op) op->aop #define AOP_TYPE(op) AOP(op)->type #define AOP_SIZE(op) AOP(op)->size #define IS_AOP_PREG(x) (AOP(x) && (AOP_TYPE(x) == AOP_R1 || \ - AOP_TYPE(x) == AOP_R0)) + AOP_TYPE(x) == AOP_R0)) #define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY || \ - AOP_TYPE(x) == AOP_DPTR || AOP(x)->paged)) + AOP_TYPE(x) == AOP_DPTR || \ + AOP(x)->paged)) #define AOP_INPREG(x) (x && (x->type == AOP_REG && \ - (x->aopu.aop_reg[0] == mcs51_regWithIdx(R0_IDX) || \ - x->aopu.aop_reg[0] == mcs51_regWithIdx(R1_IDX) ))) - + (x->aopu.aop_reg[0] == REG_WITH_INDEX(R0_IDX) || \ + x->aopu.aop_reg[0] == REG_WITH_INDEX(R1_IDX) ))) #define SYM_BP(sym) (SPEC_OCLS (sym->etype)->paged ? "_bpx" : "_bp") @@ -115,16 +118,15 @@ static char *rb1regs[] = { "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7" }; -extern int mcs51_ptrRegReq; -extern int mcs51_nRegs; -extern FILE *codeOutFile; -static void saveRBank (int, iCode *, bool); +extern struct dbuf_s *codeOutBuf; #define RESULTONSTACK(x) \ (IC_RESULT(x) && IC_RESULT(x)->aop && \ IC_RESULT(x)->aop->type == AOP_STK ) #define MOVA(x) mova(x) /* use function to avoid multiple eval */ +#define MOVB(x) movb(x) + #define CLRC emitcode("clr","c") #define SETC emitcode("setb","c") @@ -146,38 +148,63 @@ static unsigned char SRMask[] = /*-----------------------------------------------------------------*/ /* emitcode - writes the code into a file : for now it is simple */ /*-----------------------------------------------------------------*/ -static void -emitcode (char *inst, const char *fmt,...) +void +emitcode (const char *inst, const char *fmt,...) { va_list ap; - char lb[INITIAL_INLINEASM]; - char *lbp = lb; + struct dbuf_s dbuf; + const char *lbp, *lb; + + dbuf_init (&dbuf, INITIAL_INLINEASM); va_start (ap, fmt); if (inst && *inst) { + dbuf_append_str (&dbuf, inst); + if (fmt && *fmt) - SNPRINTF (lb, sizeof(lb), "%s\t", inst); - else - SNPRINTF (lb, sizeof(lb), "%s", inst); - tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb), fmt, ap); + { + dbuf_append_char (&dbuf, '\t'); + dbuf_tvprintf (&dbuf, fmt, ap); + } } else - tvsprintf (lb, sizeof(lb), fmt, ap); + { + dbuf_tvprintf (&dbuf, fmt, ap); + } + + lbp = lb = dbuf_c_str(&dbuf); while (isspace ((unsigned char)*lbp)) + { lbp++; + } + + if (lbp) + { + rtrackUpdate (lbp); - if (lbp && *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); +} + +static void +emitLabel (symbol *tlbl) +{ + emitcode ("", "%05d$:", tlbl->key + 100); + lineCurr->isLabel = 1; } /*-----------------------------------------------------------------*/ @@ -202,25 +229,32 @@ mova (const char *x) if (!strncmp(x, "a", 2) || !strncmp(x, "acc", 4)) return; - emitcode("mov","a,%s", x); + /* if it is a literal mov try to get it cheaper */ + if (*x == '#' && + rtrackMoveALit(x)) + return; + + emitcode("mov", "a,%s", x); } /*-----------------------------------------------------------------*/ -/* movc - moves specified value into the carry */ +/* movb - moves specified value into register b */ /*-----------------------------------------------------------------*/ static void -movc (const char *s) +movb (const char *x) { - if (s == zero) - CLRC; - else if (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"); + /* do some early peephole optimization */ + if (!strncmp(x, "b", 2)) + return; + + /* if it is a literal mov try to get it cheaper */ + if (*x == '#') + { + emitcode("mov","b,%s", rtrackGetLit(x)); + return; } + + emitcode("mov","b,%s", x); } /*-----------------------------------------------------------------*/ @@ -266,7 +300,7 @@ popB (bool pushedB) static bool pushReg (int index, bool bits_pushed) { - regs * reg = mcs51_regWithIdx (index); + regs * reg = REG_WITH_INDEX (index); if (reg->type == REG_BIT) { if (!bits_pushed) @@ -284,7 +318,7 @@ pushReg (int index, bool bits_pushed) static bool popReg (int index, bool bits_popped) { - regs * reg = mcs51_regWithIdx (index); + regs * reg = REG_WITH_INDEX (index); if (reg->type == REG_BIT) { if (!bits_popped) @@ -325,7 +359,7 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result) ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX); (*aopp)->type = AOP_R0; - return (*aopp)->aopu.aop_ptr = mcs51_regWithIdx (R0_IDX); + return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R0_IDX); } /* if no usage of r1 then return it */ @@ -334,7 +368,7 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result) ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX); (*aopp)->type = AOP_R1; - return (*aopp)->aopu.aop_ptr = mcs51_regWithIdx (R1_IDX); + return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R1_IDX); } /* now we know they both have usage */ @@ -344,21 +378,20 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result) /* push it if not already pushed */ if (ic->op == IPUSH) { - emitcode ("mov", "b,%s", - mcs51_regWithIdx (R0_IDX)->dname); + MOVB (REG_WITH_INDEX (R0_IDX)->dname); R0INB++; } else if (!_G.r0Pushed) { emitcode ("push", "%s", - mcs51_regWithIdx (R0_IDX)->dname); + REG_WITH_INDEX (R0_IDX)->dname); _G.r0Pushed++; } ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX); (*aopp)->type = AOP_R0; - return (*aopp)->aopu.aop_ptr = mcs51_regWithIdx (R0_IDX); + return (*aopp)->aopu.aop_ptr = REG_WITH_INDEX (R0_IDX); } /* if r1 not used then */ @@ -368,39 +401,41 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result) /* push it if not already pushed */ if (ic->op == IPUSH) { - emitcode ("mov", "b,%s", - mcs51_regWithIdx (R1_IDX)->dname); + MOVB (REG_WITH_INDEX (R1_IDX)->dname); R1INB++; } else if (!_G.r1Pushed) { emitcode ("push", "%s", - mcs51_regWithIdx (R1_IDX)->dname); + REG_WITH_INDEX (R1_IDX)->dname); _G.r1Pushed++; } ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX); (*aopp)->type = AOP_R1; - return mcs51_regWithIdx (R1_IDX); + return REG_WITH_INDEX (R1_IDX); } + endOfWorld: /* I said end of world, but not quite end of world yet */ - if (result) { - /* we can push it on the stack */ - (*aopp)->type = AOP_STK; - return NULL; - } else { - /* in the case that result AND left AND right needs a pointer reg - we can safely use the result's */ - if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R0_IDX)) { + /* if this is a result then we can push it on the stack */ + if (result) + { + (*aopp)->type = AOP_STK; + return NULL; + } + /* in the case that result AND left AND right needs a pointer reg + we can safely use the result's */ + if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R0_IDX)) + { (*aopp)->type = AOP_R0; - return mcs51_regWithIdx (R0_IDX); + return REG_WITH_INDEX (R0_IDX); } - if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R1_IDX)) { + if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R1_IDX)) + { (*aopp)->type = AOP_R1; - return mcs51_regWithIdx (R1_IDX); + return REG_WITH_INDEX (R1_IDX); } - } /* now this is REALLY the end of the world */ werror (E_INTERNAL_ERROR, __FILE__, __LINE__, @@ -449,7 +484,7 @@ getTempRegs(regs **tempRegs, int size, iCode *ic) for (i=0; isize; i++) { if (bitVectBitValue(freeRegs,i)) - tempRegs[offset++] = mcs51_regWithIdx(i); + tempRegs[offset++] = REG_WITH_INDEX(i); if (offset>=size) { freeBitVect(freeRegs); @@ -458,7 +493,7 @@ getTempRegs(regs **tempRegs, int size, iCode *ic) } freeBitVect(freeRegs); - return 1; + return 0; } @@ -472,6 +507,7 @@ newAsmop (short type) aop = Safe_calloc (1, sizeof (asmop)); aop->type = type; + aop->allocated = 1; return aop; } @@ -560,6 +596,7 @@ aopForSym (iCode * ic, symbol * sym, bool result) { asmop *aop; memmap *space; + bool accuse = leftRightUseAcc (ic) || _G.accInUse; wassertl (ic != NULL, "Got a null iCode"); wassertl (sym != NULL, "Got a null symbol"); @@ -568,7 +605,10 @@ aopForSym (iCode * ic, symbol * sym, bool result) /* if already has one */ if (sym->aop) - return sym->aop; + { + sym->aop->allocated++; + return sym->aop; + } /* assign depending on the storage class */ /* if it is on the stack or indirectly addressable */ @@ -583,14 +623,14 @@ aopForSym (iCode * ic, symbol * sym, bool result) the pointer register */ if (aop->type != AOP_STK) { - if (sym->onStack) { - char offset = ((sym->stack < 0) ? - ((char) (sym->stack - _G.nRegsSaved)) : - ((char) sym->stack)) & 0xff; + signed char offset = ((sym->stack < 0) ? + ((signed char) (sym->stack - _G.nRegsSaved)) : + ((signed char) sym->stack)) & 0xff; - if ((offset >= -3) && (offset <= 3)) + if ((abs(offset) <= 3) || + (accuse && (abs(offset) <= 7))) { emitcode ("mov", "%s,%s", aop->aopu.aop_ptr->name, SYM_BP (sym)); @@ -607,20 +647,21 @@ aopForSym (iCode * ic, symbol * sym, bool result) } else { - if (_G.accInUse || leftRightUseAcc (ic)) + if (accuse) emitcode ("push", "acc"); emitcode ("mov", "a,%s", SYM_BP (sym)); - emitcode ("add", "a,#0x%02x", offset); - emitcode ("mov", "%s,a", - aop->aopu.aop_ptr->name); - if (_G.accInUse || leftRightUseAcc (ic)) + emitcode ("add", "a,#0x%02x", offset & 0xff); + emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name); + if (accuse) emitcode ("pop", "acc"); } } else - emitcode ("mov", "%s,#%s", - aop->aopu.aop_ptr->name, - sym->rname); + { + emitcode ("mov", "%s,#%s", + aop->aopu.aop_ptr->name, + sym->rname); + } aop->paged = space->paged; } else @@ -652,8 +693,7 @@ aopForSym (iCode * ic, symbol * sym, bool result) if (IS_FUNC (sym->type)) { sym->aop = aop = newAsmop (AOP_IMMD); - aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (sym->rname) + 1); - strcpy (aop->aopu.aop_immd.aop_immd1, sym->rname); + aop->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname); aop->size = getSize (sym->type); return aop; } @@ -700,21 +740,25 @@ aopForRemat (symbol * sym) } if (val) - sprintf (buffer, "(%s %c 0x%04x)", - OP_SYMBOL (IC_LEFT (ic))->rname, - val >= 0 ? '+' : '-', - abs (val) & 0xffff); + { + SNPRINTF (buffer, sizeof(buffer), + "(%s %c 0x%04x)", + OP_SYMBOL (IC_LEFT (ic))->rname, + val >= 0 ? '+' : '-', + abs (val) & 0xffff); + } else - strcpy (buffer, OP_SYMBOL (IC_LEFT (ic))->rname); + { + strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer)); + } - aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1); - strcpy (aop->aopu.aop_immd.aop_immd1, buffer); + aop->aopu.aop_immd.aop_immd1 = Safe_strdup(buffer); /* set immd2 field if required */ - if (aop->aopu.aop_immd.from_cast_remat) { - sprintf(buffer,"#0x%02x",ptr_type); - aop->aopu.aop_immd.aop_immd2 = Safe_calloc (1, strlen (buffer) + 1); - strcpy (aop->aopu.aop_immd.aop_immd2, buffer); - } + if (aop->aopu.aop_immd.from_cast_remat) + { + SNPRINTF (buffer, sizeof(buffer), "#0x%02x", ptr_type); + aop->aopu.aop_immd.aop_immd2 = Safe_strdup(buffer); + } return aop; } @@ -805,6 +849,27 @@ operandsEqu (operand * op1, operand * op2) return FALSE; } +/*-----------------------------------------------------------------*/ +/* sameByte - two asmops have the same address at given offsets */ +/*-----------------------------------------------------------------*/ +static bool +sameByte (asmop * aop1, int off1, asmop * aop2, int off2) +{ + if (aop1 == aop2 && off1 == off2) + return TRUE; + + if (aop1->type != AOP_REG && aop1->type != AOP_CRY) + return FALSE; + + if (aop1->type != aop2->type) + return FALSE; + + if (aop1->aopu.aop_reg[off1] != aop2->aopu.aop_reg[off2]) + return FALSE; + + return TRUE; +} + /*-----------------------------------------------------------------*/ /* sameRegs - two asmops have the same registers */ /*-----------------------------------------------------------------*/ @@ -826,8 +891,7 @@ sameRegs (asmop * aop1, asmop * aop2) return FALSE; for (i = 0; i < aop1->size; i++) - if (aop1->aopu.aop_reg[i] != - aop2->aopu.aop_reg[i]) + if (aop1->aopu.aop_reg[i] != aop2->aopu.aop_reg[i]) return FALSE; return TRUE; @@ -856,13 +920,17 @@ aopOp (operand * op, iCode * ic, bool result) } /* if already has a asmop then continue */ - if (op->aop ) - return; + if (op->aop) + { + op->aop->allocated++; + return; + } /* if the underlying symbol has a aop */ if (IS_SYMOP (op) && OP_SYMBOL (op)->aop) { op->aop = OP_SYMBOL (op)->aop; + op->aop->allocated++; return; } @@ -886,8 +954,8 @@ aopOp (operand * op, iCode * ic, bool result) /* 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; } @@ -900,8 +968,7 @@ aopOp (operand * op, iCode * ic, bool result) /* rematerialize it NOW */ if (sym->remat) { - sym->aop = op->aop = aop = - aopForRemat (sym); + sym->aop = op->aop = aop = aopForRemat (sym); aop->size = getSize (sym->type); return; } @@ -909,7 +976,7 @@ aopOp (operand * op, iCode * ic, bool result) 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]; @@ -920,7 +987,7 @@ aopOp (operand * op, iCode * ic, bool result) { 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]; @@ -929,13 +996,21 @@ aopOp (operand * op, iCode * ic, bool result) if (sym->usl.spillLoc) { + asmop *oldAsmOp = NULL; + if (getSize(sym->type) != getSize(sym->usl.spillLoc->type)) { /* force a new aop if sizes differ */ + oldAsmOp = sym->usl.spillLoc->aop; sym->usl.spillLoc->aop = NULL; } sym->aop = op->aop = aop = aopForSym (ic, sym->usl.spillLoc, result); + if (getSize(sym->type) != getSize(sym->usl.spillLoc->type)) + { + /* Don't reuse the new aop, go with the last one */ + sym->usl.spillLoc->aop = oldAsmOp; + } aop->size = getSize (sym->type); return; } @@ -979,13 +1054,13 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop) if (!aop) return; - if (aop->freed) - goto dealloc; + aop->allocated--; - aop->freed = 1; + if (aop->allocated) + goto dealloc; - /* depending on the asmop type only three cases need work AOP_RO - , AOP_R1 && AOP_STK */ + /* depending on the asmop type only three cases need work + AOP_R0, AOP_R1 & AOP_STK */ switch (aop->type) { case AOP_R0: @@ -1011,7 +1086,7 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop) emitcode ("mov", "r1,b"); R1INB--; } - if (_G.r1Pushed) + else if (_G.r1Pushed) { if (pop) { @@ -1057,13 +1132,13 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop) emitcode ("pop", "ar1"); _G.r1Pushed--; } - if (_G.r0Pushed) { emitcode ("pop", "ar0"); _G.r0Pushed--; } } + break; } dealloc: @@ -1098,7 +1173,7 @@ freeForBranchAsmop (operand * op) if (!aop) return; - if (aop->freed) + if (!aop->allocated) return; switch (aop->type) @@ -1206,14 +1281,12 @@ aopGetUsesAcc (operand * oper, int offset) } } -/*-----------------------------------------------------------------*/ -/* aopGet - for fetching value of the aop */ -/*-----------------------------------------------------------------*/ +/*-------------------------------------------------------------------*/ +/* aopGet - for fetching value of the aop */ +/*-------------------------------------------------------------------*/ static char * aopGet (operand * oper, int offset, bool bit16, bool dname) { - char *s = buffer; - char *rs; asmop * aop = AOP (oper); /* offset is greater than @@ -1249,10 +1322,8 @@ aopGet (operand * oper, int offset, bool bit16, bool dname) emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name); return (dname ? "acc" : "a"); } - sprintf (s, "@%s", aop->aopu.aop_ptr->name); - rs = Safe_calloc (1, strlen (s) + 1); - strcpy (rs, s); - return rs; + SNPRINTF (buffer, sizeof(buffer), "@%s", aop->aopu.aop_ptr->name); + return Safe_strdup(buffer); case AOP_DPTR: if (aop->code && aop->coff==0 && offset>=1) { @@ -1285,36 +1356,54 @@ aopGet (operand * oper, int offset, bool bit16, bool dname) } return (dname ? "acc" : "a"); - case AOP_IMMD: - if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) { - sprintf(s,"%s",aop->aopu.aop_immd.aop_immd2); - } else if (bit16) - sprintf (s, "#%s", aop->aopu.aop_immd.aop_immd1); + if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) + { + SNPRINTF(buffer, sizeof(buffer), + "%s",aop->aopu.aop_immd.aop_immd2); + } + else if (bit16) + { + SNPRINTF(buffer, sizeof(buffer), + "#%s", aop->aopu.aop_immd.aop_immd1); + } else if (offset) - sprintf (s, "#(%s >> %d)", - aop->aopu.aop_immd.aop_immd1, - offset * 8); + { + SNPRINTF (buffer, sizeof(buffer), + "#(%s >> %d)", + aop->aopu.aop_immd.aop_immd1, + offset * 8); + } else - sprintf (s, "#%s", - aop->aopu.aop_immd.aop_immd1); - rs = Safe_calloc (1, strlen (s) + 1); - strcpy (rs, s); - return rs; + { + SNPRINTF (buffer, sizeof(buffer), + "#%s", + aop->aopu.aop_immd.aop_immd1); + } + return Safe_strdup(buffer); case AOP_DIR: if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset) - sprintf (s, "(%s >> %d)", - aop->aopu.aop_dir, offset * 8); + { + SNPRINTF (buffer, sizeof(buffer), + "(%s >> %d)", + aop->aopu.aop_dir, offset * 8); + } else if (offset) - sprintf (s, "(%s + %d)", - aop->aopu.aop_dir, - offset); + { + SNPRINTF (buffer, sizeof(buffer), + "(%s + %d)", + aop->aopu.aop_dir, + offset); + } else - sprintf (s, "%s", aop->aopu.aop_dir); - rs = Safe_calloc (1, strlen (s) + 1); - strcpy (rs, s); - return rs; + { + SNPRINTF (buffer, sizeof(buffer), + "%s", + aop->aopu.aop_dir); + } + + return Safe_strdup(buffer); case AOP_REG: if (dname) @@ -1323,8 +1412,8 @@ aopGet (operand * oper, int offset, bool bit16, bool dname) 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"); @@ -1350,15 +1439,60 @@ aopGet (operand * oper, int offset, bool bit16, bool dname) "aopget got unsupported aop->type"); exit (1); } + +/*-----------------------------------------------------------------*/ +/* aopPutUsesAcc - indicates ahead of time whether aopPut() will */ +/* clobber the accumulator */ +/*-----------------------------------------------------------------*/ +static bool +aopPutUsesAcc (operand * oper, const char *s, int offset) +{ + asmop * aop = AOP (oper); + + if (offset > (aop->size - 1)) + return FALSE; + + switch (aop->type) + { + case AOP_DUMMY: + return TRUE; + case AOP_DIR: + return FALSE; + case AOP_REG: + wassert(strcmp(aop->aopu.aop_reg[offset]->name, "a")); + return FALSE; + case AOP_DPTR: + return TRUE; + case AOP_R0: + case AOP_R1: + return ((aop->paged) || (*s == '@')); + case AOP_STK: + return (*s == '@'); + case AOP_CRY: + return (!aop->aopu.aop_dir || strcmp(s, aop->aopu.aop_dir)); + case AOP_STR: + return FALSE; + case AOP_IMMD: + return FALSE; + case AOP_ACC: + return FALSE; + default: + /* Error case --- will have been caught already */ + wassert(0); + return FALSE; + } +} + /*-----------------------------------------------------------------*/ /* aopPut - puts a string for a aop and indicates if acc is in use */ /*-----------------------------------------------------------------*/ static bool -aopPut (operand * result, const char *s, int offset, bool bvolatile) +aopPut (operand * result, const char *s, int offset) { - char *d = buffer; + bool bvolatile = isOperandVolatile (result, FALSE); bool accuse = FALSE; asmop * aop = AOP (result); + const char *d = NULL; if (aop->size && offset > (aop->size - 1)) { @@ -1378,20 +1512,32 @@ aopPut (operand * result, const char *s, int offset, bool bvolatile) case AOP_DIR: if (SPEC_SCLS (getSpec (operandType (result))) == S_SFR && offset) - sprintf (d, "(%s >> %d)", - aop->aopu.aop_dir, offset * 8); + { + SNPRINTF (buffer, sizeof(buffer), + "(%s >> %d)", + aop->aopu.aop_dir, offset * 8); + } else if (offset) - sprintf (d, "(%s + %d)", - aop->aopu.aop_dir, offset); + { + SNPRINTF (buffer, sizeof(buffer), + "(%s + %d)", + aop->aopu.aop_dir, offset); + } else - sprintf (d, "%s", aop->aopu.aop_dir); + { + SNPRINTF (buffer, sizeof(buffer), + "%s", + aop->aopu.aop_dir); + } - if (strcmp (d, s) || - bvolatile) - emitcode ("mov", "%s,%s", d, s); - if (!strcmp (d, "acc")) + if (strcmp (buffer, s) || bvolatile) + { + emitcode ("mov", "%s,%s", buffer, s); + } + if (!strcmp (buffer, "acc")) + { accuse = TRUE; - + } break; case AOP_REG: @@ -1407,11 +1553,15 @@ aopPut (operand * result, const char *s, int offset, bool bvolatile) strcmp (s, "r5") == 0 || strcmp (s, "r6") == 0 || strcmp (s, "r7") == 0) - emitcode ("mov", "%s,%s", - aop->aopu.aop_reg[offset]->dname, s); + { + emitcode ("mov", "%s,%s", + aop->aopu.aop_reg[offset]->dname, s); + } else - emitcode ("mov", "%s,%s", - aop->aopu.aop_reg[offset]->name, s); + { + emitcode ("mov", "%s,%s", + aop->aopu.aop_reg[offset]->name, s); + } } break; @@ -1461,7 +1611,6 @@ aopPut (operand * result, const char *s, int offset, bool bvolatile) { MOVA (s); emitcode ("movx", "@%s,a", aop->aopu.aop_ptr->name); - } else if (*s == '@') { @@ -1478,71 +1627,96 @@ aopPut (operand * result, const char *s, int offset, bool bvolatile) strcmp (s, "r7") == 0) { char buffer[10]; - sprintf (buffer, "a%s", s); + SNPRINTF (buffer, sizeof(buffer), "a%s", s); emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, buffer); } else - emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s); - + { + emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s); + } break; case AOP_STK: if (strcmp (s, "a") == 0) - emitcode ("push", "acc"); - else - if (*s=='@') { + { + emitcode ("push", "acc"); + } + else if (*s=='@') + { MOVA(s); emitcode ("push", "acc"); - } else { + } + else if (strcmp (s, "r0") == 0 || + strcmp (s, "r1") == 0 || + strcmp (s, "r2") == 0 || + strcmp (s, "r3") == 0 || + strcmp (s, "r4") == 0 || + strcmp (s, "r5") == 0 || + strcmp (s, "r6") == 0 || + strcmp (s, "r7") == 0) + { + char buffer[10]; + SNPRINTF (buffer, sizeof(buffer), "a%s", s); + emitcode ("push", buffer); + } + else + { emitcode ("push", s); } 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: aop->coff = offset; - if (strcmp (aop->aopu.aop_str[offset], s) || - bvolatile) + if (strcmp (aop->aopu.aop_str[offset], s) || bvolatile) emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s); break; case AOP_ACC: accuse = TRUE; aop->coff = offset; - if (!offset && (strcmp (s, "acc") == 0) && - !bvolatile) + if (!offset && (strcmp (s, "acc") == 0) && !bvolatile) break; - if (strcmp (aop->aopu.aop_str[offset], s) && - !bvolatile) + if (strcmp (aop->aopu.aop_str[offset], s) && !bvolatile) emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s); break; @@ -1590,7 +1764,7 @@ pointToEnd (asmop * aop) static void reAdjustPreg (asmop * aop) { - if ((aop->coff==0) || aop->size <= 1) + if ((aop->coff==0) || (aop->size <= 1)) return; switch (aop->type) @@ -1658,13 +1832,13 @@ outAcc (operand * result) size = getDataSize (result); if (size) { - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); size--; offset = 1; /* unsigned or positive */ while (size--) { - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset++); } } } @@ -1677,7 +1851,10 @@ outBitC (operand * result) { /* if the result is bit */ if (AOP_TYPE (result) == AOP_CRY) - aopPut (result, "c", 0, isOperandVolatile (result, FALSE)); + { + if (!IS_OP_RUONLY (result)) + aopPut (result, "c", 0); + } else { emitcode ("clr", "a"); @@ -1722,11 +1899,88 @@ toBoolean (operand * oper) { while (size--) { - emitcode ("orl", "a,%s", aopGet (oper, offset++, FALSE, FALSE)); + emitcode ("orl", "a,%s", + aopGet (oper, offset++, FALSE, FALSE)); } } } +/*-----------------------------------------------------------------*/ +/* 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 */ +/*-------------------------------------------------------------------*/ +static char * +xch_a_aopGet (operand * oper, int offset, bool bit16, bool dname) +{ + char * l; + + if (aopGetUsesAcc (oper, offset)) + { + emitcode("mov", "b,a"); + MOVA (aopGet (oper, offset, bit16, dname)); + emitcode("xch", "a,b"); + aopPut (oper, "a", offset); + emitcode("xch", "a,b"); + l = "b"; + } + else + { + l = aopGet (oper, offset, bit16, dname); + emitcode("xch", "a,%s", l); + } + return l; +} + /*-----------------------------------------------------------------*/ /* genNot - generate code for ! operation */ @@ -1736,7 +1990,7 @@ genNot (iCode * ic) { symbol *tlbl; - D(emitcode ("; genNot","")); + D (emitcode (";", "genNot")); /* assign asmOps to operand & result */ aopOp (IC_LEFT (ic), ic, FALSE); @@ -1752,7 +2006,7 @@ genNot (iCode * ic) } else { - emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir); + toCarry (IC_LEFT (ic)); emitcode ("cpl", "c"); outBitC (IC_RESULT (ic)); } @@ -1764,13 +2018,13 @@ genNot (iCode * ic) /* set C, if a == 0 */ tlbl = newiTempLabel (NULL); emitcode ("cjne", "a,#0x01,%05d$", tlbl->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); outBitC (IC_RESULT (ic)); release: /* release the aops */ - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); } @@ -1820,7 +2074,7 @@ genCpl (iCode * ic) MOVA (l); emitcode ("cjne", "a,#0xFF,%05d$", tlbl->key + 100); } - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); outBitC (IC_RESULT(ic)); goto release; } @@ -1831,14 +2085,14 @@ genCpl (iCode * ic) char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE); MOVA (l); emitcode ("cpl", "a"); - aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", offset++); } release: /* release the aops */ - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); } /*-----------------------------------------------------------------*/ @@ -1850,7 +2104,7 @@ genUminusFloat (operand * op, operand * result) int size, offset = 0; char *l; - D(emitcode ("; genUminusFloat","")); + D (emitcode (";", "genUminusFloat")); /* for this we just copy and then flip the bit */ @@ -1860,17 +2114,15 @@ genUminusFloat (operand * op, operand * result) { aopPut (result, aopGet (op, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } l = aopGet (op, offset, FALSE, FALSE); - MOVA (l); emitcode ("cpl", "acc.7"); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } /*-----------------------------------------------------------------*/ @@ -1880,10 +2132,9 @@ static void genUminus (iCode * ic) { int offset, size; - sym_link *optype, *rtype; + sym_link *optype; - - D(emitcode ("; genUminus","")); + D (emitcode (";", "genUminus")); /* assign asmops */ aopOp (IC_LEFT (ic), ic, FALSE); @@ -1902,7 +2153,6 @@ genUminus (iCode * ic) } optype = operandType (IC_LEFT (ic)); - rtype = operandType (IC_RESULT (ic)); /* if float then do float stuff */ if (IS_FLOAT (optype)) @@ -1914,7 +2164,6 @@ genUminus (iCode * ic) /* otherwise subtract from zero */ size = AOP_SIZE (IC_LEFT (ic)); offset = 0; - //CLRC ; while (size--) { char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE); @@ -1932,7 +2181,7 @@ genUminus (iCode * ic) emitcode ("clr", "a"); emitcode ("subb", "a,%s", l); } - aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", offset++); } /* if any remaining bytes in the result */ @@ -1942,13 +2191,13 @@ genUminus (iCode * ic) emitcode ("rlc", "a"); emitcode ("subb", "a,acc"); while (size--) - aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", offset++); } release: /* release the aops */ - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1)); } /*-----------------------------------------------------------------*/ @@ -1977,8 +2226,8 @@ saveRegisters (iCode * lic) if (ic->regsSaved) return; if (IS_SYMOP(IC_LEFT(ic)) && - (IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type) || - IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT (ic))))) + (IFFUNC_CALLEESAVES (OP_SYMBOL (IC_LEFT (ic))->type) || + IFFUNC_ISNAKED (OP_SYM_TYPE (IC_LEFT (ic))))) return; /* save the registers in use at this time but skip the @@ -1989,11 +2238,22 @@ saveRegisters (iCode * lic) ic->regsSaved = 1; if (options.useXstack) { + bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave); + int nBits = bitVectnBitsOn (rsavebits); int count = bitVectnBitsOn (rsave); + if (nBits != 0) + { + count = count - nBits + 1; + /* remove all but the first bits as they are pushed all at once */ + rsave = bitVectCplAnd (rsave, rsavebits); + rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits)); + } + freeBitVect (rsavebits); + if (count == 1) { - regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave)); + regs * reg = REG_WITH_INDEX (bitVectFirstBit (rsave)); if (reg->type == REG_BIT) { emitcode ("mov", "a,%s", reg->base); @@ -2010,20 +2270,9 @@ saveRegisters (iCode * lic) } else if (count != 0) { - bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave); - int nBits = bitVectnBitsOn (rsavebits); - - if (nBits != 0) - { - count = count - nBits + 1; - /* remove all but the first bits as they are pushed all at once */ - rsave = bitVectCplAnd (rsave, rsavebits); - rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits)); - } - if (bitVectBitValue (rsave, R0_IDX)) { - emitcode ("push", "%s", mcs51_regWithIdx (R0_IDX)->dname); + emitcode ("push", "%s", REG_WITH_INDEX (R0_IDX)->dname); } emitcode ("mov", "r0,%s", spname); MOVA ("r0"); @@ -2033,7 +2282,7 @@ saveRegisters (iCode * lic) { if (bitVectBitValue (rsave, i)) { - regs * reg = mcs51_regWithIdx (i); + regs * reg = REG_WITH_INDEX (i); if (i == R0_IDX) { emitcode ("pop", "acc"); @@ -2056,7 +2305,7 @@ saveRegisters (iCode * lic) } if (bitVectBitValue (rsave, R0_IDX)) { - emitcode ("pop", "%s", mcs51_regWithIdx (R0_IDX)->dname); + emitcode ("pop", "%s", REG_WITH_INDEX (R0_IDX)->dname); } } } @@ -2071,6 +2320,7 @@ saveRegisters (iCode * lic) } } } + freeBitVect (rsave); } /*-----------------------------------------------------------------*/ @@ -2089,11 +2339,22 @@ unsaveRegisters (iCode * ic) if (options.useXstack) { + bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave); + int nBits = bitVectnBitsOn (rsavebits); int count = bitVectnBitsOn (rsave); + if (nBits != 0) + { + count = count - nBits + 1; + /* remove all but the first bits as they are popped all at once */ + rsave = bitVectCplAnd (rsave, rsavebits); + rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits)); + } + freeBitVect (rsavebits); + if (count == 1) { - regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave)); + regs * reg = REG_WITH_INDEX (bitVectFirstBit (rsave)); emitcode ("mov", "r0,%s", spname); emitcode ("dec", "r0"); emitcode ("movx", "a,@r0"); @@ -2109,23 +2370,12 @@ unsaveRegisters (iCode * ic) } else if (count != 0) { - bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave); - int nBits = bitVectnBitsOn (rsavebits); - - if (nBits != 0) - { - count = count - nBits + 1; - /* remove all but the first bits as they are popped all at once */ - rsave = bitVectCplAnd (rsave, rsavebits); - rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits)); - } - emitcode ("mov", "r0,%s", spname); for (i = mcs51_nRegs; i >= 0; i--) { if (bitVectBitValue (rsave, i)) { - regs * reg = mcs51_regWithIdx (i); + regs * reg = REG_WITH_INDEX (i); emitcode ("dec", "r0"); emitcode ("movx", "a,@r0"); if (i == R0_IDX) @@ -2160,6 +2410,7 @@ unsaveRegisters (iCode * ic) } } } + freeBitVect (rsave); } @@ -2196,6 +2447,7 @@ assignResultValue (operand * oper, operand * func) int offset = 0; int size = AOP_SIZE (oper); bool accuse = FALSE; + bool pushedA = FALSE; if (func && IS_BIT (OP_SYM_ETYPE (func))) { @@ -2203,9 +2455,16 @@ assignResultValue (operand * oper, operand * func) return FALSE; } + if ((size > 3) && aopPutUsesAcc (oper, fReturn[offset], offset)) + { + emitcode ("push", "acc"); + pushedA = TRUE; + } while (size--) { - accuse |= aopPut (oper, fReturn[offset], offset, isOperandVolatile (oper, FALSE)); + if ((offset == 3) && pushedA) + emitcode ("pop", "acc"); + accuse |= aopPut (oper, fReturn[offset], offset); offset++; } return accuse; @@ -2222,7 +2481,7 @@ genXpush (iCode * ic) regs *r; int size, offset = 0; - D(emitcode ("; genXpush","")); + D (emitcode (";", "genXpush")); aopOp (IC_LEFT (ic), ic, FALSE); r = getFreePtr (ic, &aop, FALSE); @@ -2266,7 +2525,7 @@ genIpush (iCode * ic) char *l; char *prev = ""; - D(emitcode ("; genIpush","")); + D (emitcode (";", "genIpush")); /* if this is not a parm push : ie. it is spill push and spill push is always done on the local stack */ @@ -2316,8 +2575,7 @@ genIpush (iCode * ic) { l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE); if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG && - AOP_TYPE (IC_LEFT (ic)) != AOP_DIR && - strcmp (l, "a")) + AOP_TYPE (IC_LEFT (ic)) != AOP_DIR) { if (strcmp (l, prev) || *l == '@') MOVA (l); @@ -2341,7 +2599,7 @@ genIpop (iCode * ic) { int size, offset; - D(emitcode ("; genIpop","")); + D (emitcode (";", "genIpop")); /* if the temp was not pushed then */ if (OP_SYMBOL (IC_LEFT (ic))->isspilt) @@ -2351,8 +2609,10 @@ genIpop (iCode * ic) size = AOP_SIZE (IC_LEFT (ic)); offset = (size - 1); while (size--) - emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--, - FALSE, TRUE)); + { + emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--, + FALSE, TRUE)); + } freeAsmop (IC_LEFT (ic), NULL, ic, TRUE); } @@ -2364,22 +2624,22 @@ static void saveRBank (int bank, iCode * ic, bool pushPsw) { int i; - int count = mcs51_nRegs + (pushPsw ? 1 : 0); + int count = 8 + (pushPsw ? 1 : 0); asmop *aop = NULL; regs *r = NULL; if (options.useXstack) { if (!ic) - { + { /* Assume r0 is available for use. */ - r = mcs51_regWithIdx (R0_IDX);; - } + r = REG_WITH_INDEX (R0_IDX); + } else - { + { aop = newAsmop (0); r = getFreePtr (ic, &aop, FALSE); - } + } // allocate space first emitcode ("mov", "%s,%s", r->name, spname); MOVA (r->name); @@ -2387,7 +2647,7 @@ saveRBank (int bank, iCode * ic, bool pushPsw) emitcode ("mov", "%s,a", spname); } - for (i = 0; i < mcs51_nRegs; i++) + for (i = 0; i < 8; i++) { if (options.useXstack) { @@ -2408,7 +2668,6 @@ saveRBank (int bank, iCode * ic, bool pushPsw) { emitcode ("mov", "a,psw"); emitcode ("movx", "@%s,a", r->name); - } else { @@ -2424,9 +2683,9 @@ saveRBank (int bank, iCode * ic, bool pushPsw) } if (ic) - { - ic->bankSaved = 1; - } + { + ic->bankSaved = 1; + } } /*-----------------------------------------------------------------*/ @@ -2444,7 +2703,7 @@ unsaveRBank (int bank, iCode * ic, bool popPsw) if (!ic) { /* Assume r0 is available for use. */ - r = mcs51_regWithIdx (R0_IDX);; + r = REG_WITH_INDEX (R0_IDX);; } else { @@ -2468,7 +2727,7 @@ unsaveRBank (int bank, iCode * ic, bool popPsw) } } - for (i = (mcs51_nRegs - 1); i >= 0; i--) + for (i = 7; i >= 0; i--) { if (options.useXstack) { @@ -2507,12 +2766,12 @@ static void genSend(set *sendSet) for (sic = setFirstItem (sendSet); sic; sic = setNextItem (sendSet)) { - aopOp (IC_LEFT (sic), sic, FALSE); - if (sic->argreg > 12) { int bit = sic->argreg-13; + aopOp (IC_LEFT (sic), sic, FALSE); + /* if left is a literal then we know what the value is */ if (AOP_TYPE (IC_LEFT (sic)) == AOP_LIT) @@ -2522,25 +2781,17 @@ static void genSend(set *sendSet) 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++; BitBankUsed = 1; + + freeAsmop (IC_LEFT (sic), NULL, sic, TRUE); } - freeAsmop (IC_LEFT (sic), NULL, sic, TRUE); } if (bit_count) @@ -2553,30 +2804,35 @@ static void genSend(set *sendSet) for (sic = setFirstItem (sendSet); sic; sic = setNextItem (sendSet)) { - int size, offset = 0; - aopOp (IC_LEFT (sic), sic, FALSE); - size = AOP_SIZE (IC_LEFT (sic)); - - if (sic->argreg == 1) + if (sic->argreg <= 12) { - while (size--) + int size, offset = 0; + aopOp (IC_LEFT (sic), sic, FALSE); + size = AOP_SIZE (IC_LEFT (sic)); + + if (sic->argreg == 1) { - char *l = aopGet (IC_LEFT (sic), offset, FALSE, FALSE); - if (strcmp (l, fReturn[offset])) - emitcode ("mov", "%s,%s", fReturn[offset], l); - offset++; + while (size--) + { + char *l = aopGet (IC_LEFT (sic), offset, FALSE, FALSE); + if (strcmp (l, fReturn[offset])) + { + emitcode ("mov", "%s,%s", fReturn[offset], l); + } + offset++; + } } - } - else if (sic->argreg <= 12) - { - while (size--) + else { - emitcode ("mov","%s,%s", rb1regs[sic->argreg+offset-5], - aopGet (IC_LEFT (sic), offset,FALSE, FALSE)); - offset++; + while (size--) + { + emitcode ("mov","%s,%s", rb1regs[sic->argreg+offset-5], + aopGet (IC_LEFT (sic), offset,FALSE, FALSE)); + offset++; + } } + freeAsmop (IC_LEFT (sic), NULL, sic, TRUE); } - freeAsmop (IC_LEFT (sic), NULL, sic, TRUE); } } @@ -2612,8 +2868,9 @@ genCall (iCode * ic) bool accuse = FALSE; bool accPushed = FALSE; bool resultInF0 = FALSE; + bool assignResultGenerated = FALSE; - D(emitcode("; genCall","")); + D (emitcode (";", "genCall")); dtype = operandType (IC_LEFT (ic)); etype = getSpec(dtype); @@ -2625,7 +2882,6 @@ genCall (iCode * ic) } else { genSend(_G.sendSet); } - _G.sendSet = NULL; } @@ -2694,6 +2950,7 @@ genCall (iCode * ic) _G.accInUse--; accuse = assignResultValue (IC_RESULT (ic), IC_LEFT (ic)); + assignResultGenerated = TRUE; freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); } @@ -2710,7 +2967,8 @@ genCall (iCode * ic) accPushed = TRUE; } if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) && - IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic)))) + IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && + !assignResultGenerated) { emitcode ("mov", "F0,c"); resultInF0 = TRUE; @@ -2749,7 +3007,7 @@ genCall (iCode * ic) // if (restoreBank) // unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE); - if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic)))) + if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && !assignResultGenerated) { if (resultInF0) emitcode ("mov", "c,F0"); @@ -2764,7 +3022,7 @@ genCall (iCode * ic) } /*-----------------------------------------------------------------*/ -/* -10l - generates a call by pointer statement */ +/* genPcall - generates a call by pointer statement */ /*-----------------------------------------------------------------*/ static void genPcall (iCode * ic) @@ -2776,7 +3034,7 @@ genPcall (iCode * ic) bool swapBanks = FALSE; bool resultInF0 = FALSE; - D(emitcode("; genPCall","")); + D (emitcode (";", "genPcall")); dtype = operandType (IC_LEFT (ic))->next; etype = getSpec(dtype); @@ -2787,7 +3045,7 @@ genPcall (iCode * ic) /* 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)) { @@ -2797,7 +3055,7 @@ genPcall (iCode * ic) // 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) @@ -2809,12 +3067,12 @@ genPcall (iCode * ic) 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); } @@ -2835,9 +3093,9 @@ genPcall (iCode * ic) } 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); } @@ -2847,6 +3105,7 @@ genPcall (iCode * ic) 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)); @@ -2871,14 +3130,14 @@ genPcall (iCode * ic) 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)); @@ -2903,17 +3162,49 @@ genPcall (iCode * ic) if (swapBanks) { emitcode ("mov", "psw,#0x%02x", - ((FUNC_REGBANK(dtype)) << 3) & 0xff); + ((FUNC_REGBANK (dtype)) << 3) & 0xff); } /* make the call */ emitcode ("ret", ""); - emitcode ("", "%05d$:", (rlbl->key + 100)); + 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 */ @@ -2953,7 +3244,6 @@ genPcall (iCode * ic) else for (i = 0; i < ic->parmBytes; i++) emitcode ("dec", "%s", spname); - } // /* if register bank was saved then unsave them */ @@ -2961,7 +3251,7 @@ genPcall (iCode * ic) // 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)))) @@ -2994,12 +3284,6 @@ resultRemat (iCode * ic) 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 */ /*-----------------------------------------------------------------*/ @@ -3043,6 +3327,7 @@ genFunction (iCode * ic) emitcode (";", "-----------------------------------------"); emitcode ("", "%s:", sym->rname); + lineCurr->isLabel = 1; ftype = operandType (IC_LEFT (ic)); _G.currentFunc = sym; @@ -3080,6 +3365,15 @@ genFunction (iCode * 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"); @@ -3094,42 +3388,38 @@ genFunction (iCode * ic) registers :-) */ if (!FUNC_REGBANK (sym->type)) { + int i; /* if this function does not call any other function then we can be economical and save only those registers that are used */ if (!IFFUNC_HASFCALL(sym->type)) { - int i; - /* 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 { - /* this function has a function call. We cannot - determines register usage so we will have to push the + determine register usage so we will have to push the entire bank */ saveRBank (0, ic, FALSE); if (options.parms_in_bank1) { - int i; for (i=0; i < 8 ; i++ ) { emitcode ("push","%s",rb1regs[i]); } } } } - else + else { /* This ISR uses a non-zero bank. * @@ -3259,7 +3549,6 @@ genFunction (iCode * ic) } } - if (fReentrant) { if (options.useXstack) @@ -3315,7 +3604,7 @@ genFunction (iCode * ic) int ofs; _G.current_iCode = ric; - D(emitcode ("; genReceive","")); + D(emitcode (";", "genReceive")); for (ofs=0; ofs < sym->recvSize; ofs++) { if (!strcmp (fReturn[ofs], "a")) @@ -3340,7 +3629,7 @@ genFunction (iCode * ic) 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]); @@ -3376,11 +3665,11 @@ genFunction (iCode * ic) /* if it's a callee-saves function we need a saved register */ if (calleesaves_saved_register >= 0) { - emitcode ("mov", "%s,a", mcs51_regWithIdx (calleesaves_saved_register)->dname); + emitcode ("mov", "%s,a", REG_WITH_INDEX (calleesaves_saved_register)->dname); emitcode ("mov", "a,sp"); emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff)); emitcode ("mov", "sp,a"); - emitcode ("mov", "a,%s", mcs51_regWithIdx (calleesaves_saved_register)->dname); + emitcode ("mov", "a,%s", REG_WITH_INDEX (calleesaves_saved_register)->dname); } else /* do it the hard way */ @@ -3409,14 +3698,14 @@ genFunction (iCode * ic) if (i > 3 && accIsFree) { emitcode ("mov", "a,_spx"); - emitcode ("add", "a,#0x%02x", i); + emitcode ("add", "a,#0x%02x", i & 0xff); emitcode ("mov", "_spx,a"); } else if (i > 5) { emitcode ("push", "acc"); emitcode ("mov", "a,_spx"); - emitcode ("add", "a,#0x%02x", i); + emitcode ("add", "a,#0x%02x", i & 0xff); emitcode ("mov", "_spx,a"); emitcode ("pop", "acc"); } @@ -3434,7 +3723,7 @@ genFunction (iCode * ic) emitcode ("setb", "c"); emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */ emitcode ("clr", "c"); - emitcode ("", "%05d$:", (tlbl->key + 100)); + emitLabel (tlbl); emitcode ("push", "psw"); /* save old ea via c in psw */ } } @@ -3498,7 +3787,8 @@ genEndFunction (iCode * ic) } else if (sym->stack || FUNC_HASSTACKPARM(sym->type)) { - emitcode ("mov", "sp,_bp"); + if (sym->stack) + emitcode ("mov", "sp,_bp"); emitcode ("pop", "_bp"); } } @@ -3506,7 +3796,7 @@ genEndFunction (iCode * ic) /* restore the register bank */ if ( /* FUNC_REGBANK (sym->type) || */ IFFUNC_ISISR (sym->type)) { - if (/* !FUNC_REGBANK (sym->type) || */ !IFFUNC_ISISR (sym->type) + if (!FUNC_REGBANK (sym->type) || !IFFUNC_ISISR (sym->type) || !options.useXstack) { /* Special case of ISR using non-zero bank with useXstack @@ -3518,6 +3808,7 @@ genEndFunction (iCode * ic) 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 @@ -3525,35 +3816,32 @@ genEndFunction (iCode * ic) registers :-) */ if (!FUNC_REGBANK (sym->type)) { + int i; /* if this function does not call any other function then we can be economical and save only those registers that are used */ if (!IFFUNC_HASFCALL(sym->type)) { - int i; - /* 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); } } } else { if (options.parms_in_bank1) { - int i; for (i = 7 ; i >= 0 ; i-- ) { 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); } @@ -3594,6 +3882,11 @@ genEndFunction (iCode * ic) 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) { @@ -3616,13 +3909,13 @@ genEndFunction (iCode * ic) { if (bitVectBitValue (sym->regsUsed, i) || (mcs51_ptrRegReq && (i == R0_IDX || i == R1_IDX))) - emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname); + emitcode ("pop", "%s", REG_WITH_INDEX (i)->dname); } } else if (mcs51_ptrRegReq) { - emitcode ("pop", "%s", mcs51_regWithIdx (R1_IDX)->dname); - emitcode ("pop", "%s", mcs51_regWithIdx (R0_IDX)->dname); + emitcode ("pop", "%s", REG_WITH_INDEX (R1_IDX)->dname); + emitcode ("pop", "%s", REG_WITH_INDEX (R0_IDX)->dname); } } @@ -3731,7 +4024,7 @@ genEndFunction (iCode * ic) for (idx = 0; idx < regsUnneeded->size; idx++) if (bitVectBitValue (regsUnneeded, idx)) - emitcode ("", ";\teliminated unneeded push/pop %s", mcs51_regWithIdx (idx)->dname); + emitcode (";", "eliminated unneeded push/pop %s", REG_WITH_INDEX (idx)->dname); freeBitVect (regsUnneeded); freeBitVect (regsUsed); @@ -3746,7 +4039,7 @@ genRet (iCode * ic) { int size, offset = 0, pushed = 0; - D(emitcode ("; genRet","")); + D (emitcode (";", "genRet")); /* if we have no return value then just generate the "ret" */ @@ -3758,41 +4051,40 @@ genRet (iCode * ic) aopOp (IC_LEFT (ic), ic, FALSE); size = AOP_SIZE (IC_LEFT (ic)); - if (IS_BIT(_G.currentFunc->etype)) { - movc (aopGet (IC_LEFT (ic), 0, FALSE, FALSE)); - size = 0; + if (!IS_OP_RUONLY (IC_LEFT (ic))) + toCarry (IC_LEFT (ic)); } - - while (size--) + else { - char *l; - if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR) + while (size--) { - /* #NOCHANGE */ - l = aopGet (IC_LEFT (ic), offset++, - FALSE, TRUE); - emitcode ("push", "%s", l); - pushed++; + char *l; + if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR) + { + /* #NOCHANGE */ + l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE); + emitcode ("push", "%s", l); + pushed++; + } + else + { + l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE); + if (strcmp (fReturn[offset], l)) + emitcode ("mov", "%s,%s", fReturn[offset++], l); + } } - else + + while (pushed) { - l = aopGet (IC_LEFT (ic), offset, - FALSE, FALSE); - if (strcmp (fReturn[offset], l)) - emitcode ("mov", "%s,%s", fReturn[offset++], l); + pushed--; + if (strcmp (fReturn[pushed], "a")) + emitcode ("pop", fReturn[pushed]); + else + emitcode ("pop", "acc"); } } - - while (pushed) - { - pushed--; - if (strcmp (fReturn[pushed], "a")) - emitcode ("pop", fReturn[pushed]); - else - emitcode ("pop", "acc"); - } freeAsmop (IC_LEFT (ic), NULL, ic, TRUE); jumpret: @@ -3815,7 +4107,7 @@ genLabel (iCode * ic) if (IC_LABEL (ic) == entryLabel) return; - emitcode ("", "%05d$:", (IC_LABEL (ic)->key + 100)); + emitLabel (IC_LABEL (ic)); } /*-----------------------------------------------------------------*/ @@ -3876,10 +4168,12 @@ genPlusIncr (iCode * ic) icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); - D(emitcode ("; genPlusIncr","")); + D(emitcode (";","genPlusIncr")); /* if increment >=16 bits in register or direct space */ - if ((AOP_TYPE(IC_LEFT(ic)) == AOP_REG || AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) && + if (( AOP_TYPE(IC_LEFT(ic)) == AOP_REG || + AOP_TYPE(IC_LEFT(ic)) == AOP_DIR || + (IS_AOP_PREG (IC_LEFT(ic)) && !AOP_NEEDSACC (IC_LEFT(ic))) ) && sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) && !isOperandVolatile (IC_RESULT (ic), FALSE) && (size > 1) && @@ -3897,7 +4191,7 @@ genPlusIncr (iCode * ic) && (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0 && labelRange <= 10) { - emitcode (";", "tail increment optimized"); + D (emitcode (";", "tail increment optimized (range %d)", labelRange)); tlbl = IC_LABEL (ic->next); emitTlbl = 0; } @@ -3953,7 +4247,7 @@ genPlusIncr (iCode * ic) if (emitTlbl) { - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } return TRUE; } @@ -3973,8 +4267,8 @@ genPlusIncr (iCode * ic) if ((AOP_TYPE (IC_LEFT (ic)) != AOP_DIR) && (icount > 5)) return FALSE; - aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 0, FALSE, FALSE), 0, FALSE); - aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1, FALSE); + aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 0, FALSE, FALSE), 0); + aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1); while (icount--) emitcode ("inc", "dptr"); @@ -3996,23 +4290,31 @@ genPlusIncr (iCode * ic) same */ if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic)))) { - if (icount > 3) { MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE)); emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff); - aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", 0); } else { - while (icount--) - emitcode ("inc", "%s", aopGet (IC_LEFT (ic), 0, FALSE, FALSE)); + { + emitcode ("inc", "%s", aopGet (IC_LEFT (ic), 0, FALSE, FALSE)); + } } return TRUE; } + if (icount == 1) + { + MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE)); + emitcode ("inc", "a"); + aopPut (IC_RESULT (ic), "a", 0); + return TRUE; + } + return FALSE; } @@ -4026,13 +4328,13 @@ outBitAcc (operand * result) /* if the result is a bit */ if (AOP_TYPE (result) == AOP_CRY) { - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); } else { emitcode ("jz", "%05d$", tlbl->key + 100); emitcode ("mov", "a,%s", one); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); outAcc (result); } } @@ -4043,24 +4345,23 @@ outBitAcc (operand * result) static void genPlusBits (iCode * ic) { - D(emitcode ("; genPlusBits","")); + 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"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); outBitC (IC_RESULT (ic)); } 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,#0x00"); + emitcode ("addc", "a,%s", zero); outAcc (IC_RESULT (ic)); } } @@ -4079,16 +4380,14 @@ adjustArithmeticResult (iCode * ic) !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)))) aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic)), 2, FALSE, FALSE), - 2, - isOperandVolatile (IC_RESULT (ic), FALSE)); + 2); if (AOP_SIZE (IC_RESULT (ic)) == 3 && AOP_SIZE (IC_RIGHT (ic)) == 3 && !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic)))) aopPut (IC_RESULT (ic), aopGet (IC_RIGHT (ic)), 2, FALSE, FALSE), - 2, - isOperandVolatile (IC_RESULT (ic), FALSE)); + 2); if (AOP_SIZE (IC_RESULT (ic)) == 3 && AOP_SIZE (IC_LEFT (ic)) < 3 && @@ -4098,7 +4397,7 @@ adjustArithmeticResult (iCode * ic) { char buffer[5]; sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL)); - aopPut (IC_RESULT (ic), buffer, 2, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), buffer, 2); } } #else @@ -4115,8 +4414,7 @@ adjustArithmeticResult (iCode * ic) { aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE), - GPTRSIZE - 1, - isOperandVolatile (IC_RESULT (ic), FALSE)); + GPTRSIZE - 1); } if (opIsGptr (IC_RESULT (ic)) && @@ -4125,8 +4423,7 @@ adjustArithmeticResult (iCode * ic) { aopPut (IC_RESULT (ic), aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE), - GPTRSIZE - 1, - isOperandVolatile (IC_RESULT (ic), FALSE)); + GPTRSIZE - 1); } if (opIsGptr (IC_RESULT (ic)) && @@ -4136,8 +4433,9 @@ adjustArithmeticResult (iCode * ic) !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic)))) { char buffer[5]; - sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL)); - aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE)); + SNPRINTF (buffer, sizeof(buffer), + "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL)); + aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1); } } #endif @@ -4151,12 +4449,13 @@ genPlus (iCode * ic) int size, offset = 0; int skip_bytes = 0; char *add = "add"; + bool swappedLR = FALSE; operand *leftOp, *rightOp; operand * op; - /* special cases :- */ + D (emitcode (";", "genPlus")); - D(emitcode ("; genPlus","")); + /* special cases :- */ aopOp (IC_LEFT (ic), ic, FALSE); aopOp (IC_RIGHT (ic), ic, FALSE); @@ -4172,6 +4471,7 @@ genPlus (iCode * ic) operand *t = IC_RIGHT (ic); IC_RIGHT (ic) = IC_LEFT (ic); IC_LEFT (ic) = t; + swappedLR = TRUE; } /* if both left & right are in bit @@ -4201,8 +4501,8 @@ genPlus (iCode * ic) while (size--) { MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE)); - emitcode ("addc", "a,#00"); - aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + emitcode ("addc", "a,%s", zero); + aopPut (IC_RESULT (ic), "a", offset++); } } goto release; @@ -4216,7 +4516,7 @@ genPlus (iCode * ic) size = getDataSize (IC_RESULT (ic)); leftOp = IC_LEFT(ic); rightOp = IC_RIGHT(ic); - op=IC_LEFT(ic); + op = IC_LEFT(ic); /* if this is an add for an array access at a 256 byte boundary */ @@ -4228,24 +4528,22 @@ genPlus (iCode * ic) && (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, - isOperandVolatile (IC_RESULT (ic), FALSE)); + 0); if( 1 == getDataSize (IC_RIGHT (ic)) ) { aopPut (IC_RESULT (ic), aopGet (leftOp, 1, FALSE, FALSE), - 1, - isOperandVolatile (IC_RESULT (ic), FALSE)); + 1); } else { MOVA (aopGet (IC_LEFT (ic), 1, FALSE, FALSE)); emitcode ("add", "a,%s", aopGet (rightOp, 1, FALSE, FALSE)); - aopPut (IC_RESULT (ic), "a", 1, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", 1); } goto release; } @@ -4259,7 +4557,7 @@ genPlus (iCode * ic) skip_bytes++; } if (skip_bytes) - D(emitcode ("; genPlus shortcut","")); + D(emitcode (";", "genPlus shortcut")); } while (size--) @@ -4286,7 +4584,7 @@ genPlus (iCode * ic) MOVA (aopGet (rightOp, offset, FALSE, TRUE)); emitcode (add, "a,%s", aopGet (leftOp, offset, FALSE, TRUE)); } - aopPut (IC_RESULT (ic), "a", offset, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", offset); add = "addc"; /* further adds must propagate carry */ } else @@ -4297,8 +4595,7 @@ genPlus (iCode * ic) /* just move */ aopPut (IC_RESULT (ic), aopGet (leftOp, offset, FALSE, FALSE), - offset, - isOperandVolatile (IC_RESULT (ic), FALSE)); + offset); } } offset++; @@ -4307,9 +4604,17 @@ genPlus (iCode * ic) adjustArithmeticResult (ic); release: - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + if (!swappedLR) + { + freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + } + else + { + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + } } /*-----------------------------------------------------------------*/ @@ -4332,10 +4637,12 @@ genMinusDec (iCode * ic) if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4) return FALSE; - D(emitcode ("; genMinusDec","")); + D (emitcode (";", "genMinusDec")); /* if decrement >=16 bits in register or direct space */ - if ((AOP_TYPE(IC_LEFT(ic)) == AOP_REG || AOP_TYPE(IC_LEFT(ic)) == AOP_DIR) && + if (( AOP_TYPE(IC_LEFT(ic)) == AOP_REG || + AOP_TYPE(IC_LEFT(ic)) == AOP_DIR || + (IS_AOP_PREG (IC_LEFT(ic)) && !AOP_NEEDSACC (IC_LEFT(ic))) ) && sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) && (size > 1) && (icount == 1)) @@ -4352,7 +4659,7 @@ genMinusDec (iCode * ic) && (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0 && labelRange <= 10) { - emitcode (";", "tail decrement optimized"); + D (emitcode (";", "tail decrement optimized (range %d)", labelRange)); tlbl = IC_LABEL (ic->next); emitTlbl = 0; } @@ -4408,7 +4715,7 @@ genMinusDec (iCode * ic) } if (emitTlbl) { - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } return TRUE; } @@ -4423,13 +4730,37 @@ genMinusDec (iCode * ic) same */ if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic)))) { + char *l; + + if (aopGetUsesAcc (IC_LEFT (ic), 0)) + { + MOVA (aopGet (IC_RESULT (ic), 0, FALSE, FALSE)); + l = "a"; + } + else + { + l = aopGet (IC_RESULT (ic), 0, FALSE, FALSE); + } while (icount--) - emitcode ("dec", "%s", aopGet (IC_RESULT (ic), 0, FALSE, FALSE)); + { + emitcode ("dec", "%s", l); + } + + if (AOP_NEEDSACC (IC_RESULT (ic))) + aopPut (IC_RESULT (ic), "a", 0); return TRUE; } + if (icount == 1) + { + MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE)); + emitcode ("dec", "a"); + aopPut (IC_RESULT (ic), "a", 0); + return TRUE; + } + return FALSE; } @@ -4447,11 +4778,17 @@ addSign (operand * result, int offset, int sign) emitcode ("rlc", "a"); emitcode ("subb", "a,acc"); while (size--) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + { + aopPut (result, "a", offset++); + } } else - while (size--) - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + { + while (size--) + { + aopPut (result, zero, offset++); + } + } } } @@ -4463,14 +4800,14 @@ genMinusBits (iCode * ic) { symbol *lbl = newiTempLabel (NULL); - D(emitcode ("; genMinusBits","")); + D (emitcode (";", "genMinusBits")); if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY) { 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"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); outBitC (IC_RESULT (ic)); } else @@ -4479,8 +4816,8 @@ genMinusBits (iCode * ic) emitcode ("subb", "a,acc"); emitcode ("jnb", "%s,%05d$", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100)); emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); - aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE)); + emitLabel (lbl); + aopPut (IC_RESULT (ic), "a", 0); addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic))))); } } @@ -4493,7 +4830,7 @@ genMinus (iCode * ic) { int size, offset = 0; - D(emitcode ("; genMinus","")); + D (emitcode (";", "genMinus")); aopOp (IC_LEFT (ic), ic, FALSE); aopOp (IC_RIGHT (ic), ic, FALSE); @@ -4528,7 +4865,7 @@ genMinus (iCode * ic) { if (useCarry || ((lit >> (offset * 8)) & 0x0FFL)) { - MOVA (aopGet (IC_LEFT (ic), offset, FALSE, FALSE)); + MOVA (aopGet (IC_LEFT (ic), offset, FALSE, FALSE)); if (!offset && !size && lit== (unsigned long) -1) { emitcode ("dec", "a"); @@ -4545,7 +4882,7 @@ genMinus (iCode * ic) emitcode ("addc", "a,#0x%02x", (unsigned int) ((lit >> (offset * 8)) & 0x0FFL)); } - aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", offset++); } else { @@ -4553,7 +4890,7 @@ genMinus (iCode * ic) if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)))) { aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), offset, FALSE, FALSE), - offset, isOperandVolatile (IC_RESULT (ic), FALSE)); + offset); } offset++; } @@ -4584,7 +4921,7 @@ genMinus (iCode * ic) /* reverse subtraction with 2's complement */ if (offset == 0) emitcode( "setb", "c"); - else + else emitcode( "cpl", "c"); wassertl(!aopGetUsesAcc(leftOp, offset), "accumulator clash"); MOVA (aopGet(rightOp, offset, FALSE, TRUE)); @@ -4601,17 +4938,16 @@ genMinus (iCode * ic) aopGet(rightOp, offset, FALSE, TRUE)); } - aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", offset++); } } - adjustArithmeticResult (ic); release: - freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + freeAsmop (IC_RIGHT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); } @@ -4623,7 +4959,7 @@ genMultbits (operand * left, operand * right, operand * result) { - D(emitcode ("; genMultbits","")); + D (emitcode (";", "genMultbits")); emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir); emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir); @@ -4643,7 +4979,7 @@ genMultOneByte (operand * left, bool runtimeSign, compiletimeSign; bool lUnsigned, rUnsigned, pushedB; - D(emitcode ("; genMultOneByte","")); + D (emitcode (";", "genMultOneByte")); if (size < 1 || size > 2) { @@ -4689,7 +5025,7 @@ genMultOneByte (operand * left, { /* moving to accumulator first helps peepholes */ MOVA (aopGet (left, 0, FALSE, FALSE)); - emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE)); + MOVB (aopGet (right, 0, FALSE, FALSE)); } else { @@ -4698,9 +5034,9 @@ genMultOneByte (operand * left, } emitcode ("mul", "ab"); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); if (size == 2) - aopPut (result, "b", 1, isOperandVolatile (result, FALSE)); + aopPut (result, "b", 1); popB (pushedB); return; @@ -4767,7 +5103,6 @@ genMultOneByte (operand * left, else /* ! literal */ { if (rUnsigned) /* emitcode (";", "signed"); */ - emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE)); else { @@ -4777,7 +5112,7 @@ genMultOneByte (operand * left, emitcode ("cpl", "F0"); /* complement sign flag */ emitcode ("cpl", "a"); /* 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); emitcode ("mov", "b,a"); } } @@ -4802,7 +5137,7 @@ genMultOneByte (operand * left, emitcode ("cpl", "F0"); /* complement sign flag */ emitcode ("cpl", "a"); /* 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); } } @@ -4824,11 +5159,11 @@ genMultOneByte (operand * left, emitcode ("addc", "a,#0"); emitcode ("xch", "a,b"); } - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); } - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); if (size == 2) - aopPut (result, "b", 1, isOperandVolatile (result, FALSE)); + aopPut (result, "b", 1); popB (pushedB); } @@ -4843,9 +5178,9 @@ genMult (iCode * ic) operand *right = IC_RIGHT (ic); operand *result = IC_RESULT (ic); - D(emitcode ("; genMult","")); + D (emitcode (";", "genMult")); - /* assign the amsops */ + /* assign the asmops */ aopOp (left, ic, FALSE); aopOp (right, ic, FALSE); aopOp (result, ic, TRUE); @@ -4893,7 +5228,7 @@ genDivbits (operand * left, char *l; bool pushedB; - D(emitcode ("; genDivbits","")); + D(emitcode (";", "genDivbits")); pushedB = pushB (); @@ -4908,7 +5243,7 @@ genDivbits (operand * left, popB (pushedB); - aopPut (result, "c", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "c", 0); } /*-----------------------------------------------------------------*/ @@ -4921,10 +5256,12 @@ genDivOneByte (operand * left, { bool lUnsigned, rUnsigned, pushedB; bool runtimeSign, compiletimeSign; + bool accuse = FALSE; + bool pushedA = FALSE; 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: @@ -4963,12 +5300,12 @@ genDivOneByte (operand * left, if (lUnsigned && rUnsigned) { /* unsigned is easy */ - emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE)); + MOVB (aopGet (right, 0, FALSE, FALSE)); MOVA (aopGet (left, 0, FALSE, FALSE)); emitcode ("div", "ab"); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); while (size--) - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset++); popB (pushedB); return; @@ -5043,7 +5380,7 @@ genDivOneByte (operand * left, emitcode ("cpl", "F0"); /* complement sign flag */ emitcode ("cpl", "a"); /* 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); emitcode ("mov", "b,a"); } } @@ -5068,7 +5405,7 @@ genDivOneByte (operand * left, emitcode ("cpl", "F0"); /* complement sign flag */ emitcode ("cpl", "a"); /* 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); } } @@ -5082,31 +5419,45 @@ genDivOneByte (operand * left, emitcode ("jnb", "F0,%05d$", (lbl->key + 100)); emitcode ("cpl", "a"); /* lsb 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + accuse = aopPut (result, "a", 0); if (size > 0) { /* msb is 0x00 or 0xff depending on the sign */ if (runtimeSign) { + if (accuse) + { + emitcode ("push", "acc"); + pushedA = TRUE; + } emitcode ("mov", "c,F0"); emitcode ("subb", "a,acc"); while (size--) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); } else /* compiletimeSign */ - while (size--) - aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE)); + { + if (aopPutUsesAcc (result, "#0xFF", offset)) + { + emitcode ("push", "acc"); + pushedA = TRUE; + } + while (size--) + aopPut (result, "#0xff", offset++); + } } } else { - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); while (size--) - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset++); } + if (pushedA) + emitcode ("pop", "acc"); popB (pushedB); } @@ -5120,9 +5471,9 @@ genDiv (iCode * ic) operand *right = IC_RIGHT (ic); operand *result = IC_RESULT (ic); - D(emitcode ("; genDiv","")); + D (emitcode (";", "genDiv")); - /* assign the amsops */ + /* assign the asmops */ aopOp (left, ic, FALSE); aopOp (right, ic, FALSE); aopOp (result, ic, TRUE); @@ -5147,9 +5498,9 @@ genDiv (iCode * ic) /* should have been converted to function call */ assert (0); release: + freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (result, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -5163,7 +5514,7 @@ genModbits (operand * left, char *l; bool pushedB; - D(emitcode ("; genModbits","")); + D (emitcode (";", "genModbits")); pushedB = pushB (); @@ -5179,7 +5530,7 @@ genModbits (operand * left, popB (pushedB); - aopPut (result, "c", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "c", 0); } /*-----------------------------------------------------------------*/ @@ -5195,7 +5546,7 @@ genModOneByte (operand * left, symbol *lbl; int size, offset; - D(emitcode ("; genModOneByte","")); + D (emitcode (";", "genModOneByte")); size = AOP_SIZE (result) - 1; offset = 1; @@ -5236,19 +5587,19 @@ genModOneByte (operand * left, int size2 = size; int offs2 = offset; - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); while (size2--) - aopPut (result, "#0xff", offs2++, isOperandVolatile (result, FALSE)); + aopPut (result, "#0xff", offs2++); lbl2 = newiTempLabel (NULL); emitcode ("sjmp", "%05d$", (lbl2->key + 100)); } - emitcode ("", "%05d$:", (lbl->key + 100)); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + emitLabel (lbl); + aopPut (result, "a", 0); while (size--) - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset++); if (lbl2) { - emitcode ("", "%05d$:", (lbl2->key + 100)); + emitLabel (lbl2); } return; @@ -5263,12 +5614,12 @@ genModOneByte (operand * left, if (lUnsigned && rUnsigned) { /* unsigned is easy */ - emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE)); + MOVB (aopGet (right, 0, FALSE, FALSE)); MOVA (aopGet (left, 0, FALSE, FALSE)); emitcode ("div", "ab"); - aopPut (result, "b", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "b", 0); while (size--) - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset++); popB (pushedB); return; @@ -5299,7 +5650,7 @@ genModOneByte (operand * left, emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100)); emitcode ("cpl", "a"); /* 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); emitcode ("mov", "b,a"); } } @@ -5337,7 +5688,7 @@ genModOneByte (operand * left, emitcode ("setb", "F0"); /* set sign flag */ emitcode ("cpl", "a"); /* 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); } } @@ -5352,9 +5703,9 @@ genModOneByte (operand * left, emitcode ("jnb", "F0,%05d$", (lbl->key + 100)); emitcode ("cpl", "a"); /* 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); if (size > 0) { /* msb is 0x00 or 0xff depending on the sign */ @@ -5363,18 +5714,18 @@ genModOneByte (operand * left, emitcode ("mov", "c,F0"); emitcode ("subb", "a,acc"); while (size--) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); } else /* compiletimeSign */ while (size--) - aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "#0xff", offset++); } } else { - aopPut (result, "b", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "b", 0); while (size--) - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset++); } popB (pushedB); @@ -5390,7 +5741,7 @@ genMod (iCode * ic) operand *right = IC_RIGHT (ic); operand *result = IC_RESULT (ic); - D(emitcode ("; genMod","")); + D (emitcode (";", "genMod")); /* assign the asmops */ aopOp (left, ic, FALSE); @@ -5418,9 +5769,9 @@ genMod (iCode * ic) assert (0); release: + freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (result, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -5433,7 +5784,7 @@ genIfxJump (iCode * ic, char *jval, operand *left, operand *right, operand *resu symbol *tlbl = newiTempLabel (NULL); char *inst; - D(emitcode ("; genIfxJump","")); + D (emitcode (";", "genIfxJump")); /* if true label then we jump if condition supplied is true */ @@ -5458,7 +5809,7 @@ genIfxJump (iCode * ic, char *jval, operand *left, operand *right, operand *resu freeForBranchAsmop (right); freeForBranchAsmop (left); emitcode ("ljmp", "%05d$", jlbl->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); /* mark the icode as generated */ ic->generated = 1; @@ -5475,7 +5826,7 @@ genCmp (operand * left, operand * right, unsigned long lit = 0L; bool rightInB; - D(emitcode ("; genCmp","")); + D (emitcode (";", "genCmp")); /* if left & right are bit variables */ if (AOP_TYPE (left) == AOP_CRY && @@ -5500,7 +5851,7 @@ genCmp (operand * left, operand * right, aopGet (left, offset, FALSE, FALSE), aopGet (right, offset, FALSE, FALSE), lbl->key + 100); - emitcode ("", "%05d$:", lbl->key + 100); + emitLabel (lbl); } else { @@ -5525,8 +5876,37 @@ genCmp (operand * left, operand * right, return; } - else - emitcode ("rlc", "a"); + else + { + emitcode ("rlc", "a"); + } + } + goto release; + } + else + {//nonzero literal + int bytelit = ((lit >> (offset * 8)) & 0x0FFL); + while (size && (bytelit == 0)) + { + offset++; + bytelit = ((lit >> (offset * 8)) & 0x0FFL); + size--; + } + CLRC; + while (size--) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + if (sign && size == 0) + { + emitcode ("xrl", "a,#0x80"); + emitcode ("subb", "a,#0x%02x", + 0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL)); + } + else + { + emitcode ("subb", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } + offset++; } goto release; } @@ -5545,24 +5925,14 @@ genCmp (operand * left, operand * right, if (sign && size == 0) { emitcode ("xrl", "a,#0x80"); - if (AOP_TYPE (right) == AOP_LIT) - { - unsigned long lit = (unsigned long) - floatFromVal (AOP (right)->aopu.aop_lit); - emitcode ("subb", "a,#0x%02x", - 0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL)); - } - else + if (!rightInB) { - if (!rightInB) - { - pushedB = pushB (); - rightInB++; - emitcode ("mov", "b,%s", aopGet (right, offset, FALSE, FALSE)); - } - emitcode ("xrl", "b,#0x80"); - emitcode ("subb", "a,b"); + pushedB = pushB (); + rightInB++; + MOVB (aopGet (right, offset, FALSE, FALSE)); } + emitcode ("xrl", "b,#0x80"); + emitcode ("subb", "a,b"); } else { @@ -5591,9 +5961,13 @@ release: ifx conditional branch then generate code a little differently */ if (ifx) - genIfxJump (ifx, "c", NULL, NULL, result); + { + genIfxJump (ifx, "c", NULL, NULL, result); + } else - outBitC (result); + { + outBitC (result); + } /* leave the result in acc */ } } @@ -5608,7 +5982,7 @@ genCmpGt (iCode * ic, iCode * ifx) sym_link *letype, *retype; int sign; - D(emitcode ("; genCmpGt","")); + D (emitcode (";", "genCmpGt")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -5618,10 +5992,10 @@ genCmpGt (iCode * ic, iCode * ifx) 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); - aopOp (result, ic, TRUE); genCmp (right, left, result, ifx, sign, ic); @@ -5638,7 +6012,7 @@ genCmpLt (iCode * ic, iCode * ifx) sym_link *letype, *retype; int sign; - D(emitcode ("; genCmpLt","")); + D (emitcode (";", "genCmpLt")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -5648,10 +6022,10 @@ genCmpLt (iCode * ic, iCode * ifx) 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); - aopOp (result, ic, TRUE); genCmp (left, right, result, ifx, sign, ic); @@ -5668,11 +6042,14 @@ gencjneshort (operand * left, operand * right, symbol * lbl) int offset = 0; unsigned long lit = 0L; + D (emitcode (";", "gencjneshort")); + /* 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; @@ -5725,12 +6102,9 @@ gencjneshort (operand * left, operand * right, symbol * lbl) /* right is a pointer reg need both a & b */ while (size--) { - char *l; //if B in use: push B; mov B,left; mov A,right; clrc; subb A,B; pop B; jnz wassertl(!BINUSE, "B was in use"); - l = aopGet (left, offset, FALSE, FALSE); - if (strcmp (l, "b")) - emitcode ("mov", "b,%s", l); + MOVB (aopGet (left, offset, FALSE, FALSE)); MOVA (aopGet (right, offset, FALSE, FALSE)); emitcode ("cjne", "a,b,%05d$", lbl->key + 100); offset++; @@ -5746,13 +6120,15 @@ gencjne (operand * left, operand * right, symbol * lbl) { symbol *tlbl = newiTempLabel (NULL); + D (emitcode (";", "gencjne")); + gencjneshort (left, right, lbl); emitcode ("mov", "a,%s", one); emitcode ("sjmp", "%05d$", tlbl->key + 100); - emitcode ("", "%05d$:", lbl->key + 100); + emitLabel (lbl); emitcode ("clr", "a"); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } /*-----------------------------------------------------------------*/ @@ -5761,9 +6137,10 @@ gencjne (operand * left, operand * right, symbol * lbl) static void genCmpEq (iCode * ic, iCode * ifx) { + bool swappedLR = FALSE; operand *left, *right, *result; - D(emitcode ("; genCmpEq","")); + D (emitcode (";", "genCmpEq")); aopOp ((left = IC_LEFT (ic)), ic, FALSE); aopOp ((right = IC_RIGHT (ic)), ic, FALSE); @@ -5778,6 +6155,7 @@ genCmpEq (iCode * ic, iCode * ifx) operand *t = IC_RIGHT (ic); IC_RIGHT (ic) = IC_LEFT (ic); IC_LEFT (ic) = t; + swappedLR = TRUE; } if (ifx && !AOP_SIZE (result)) @@ -5811,7 +6189,7 @@ genCmpEq (iCode * ic, iCode * ifx) emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir); emitcode ("jb", "%s,%05d$", AOP (right)->aopu.aop_dir, (lbl->key + 100)); emitcode ("cpl", "c"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); } /* if true label then we jump if condition supplied is true */ @@ -5832,7 +6210,7 @@ genCmpEq (iCode * ic, iCode * ifx) freeForBranchAsmop (left); emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100); } - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } else { @@ -5844,18 +6222,18 @@ genCmpEq (iCode * ic, iCode * ifx) freeForBranchAsmop (right); freeForBranchAsmop (left); emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } else { symbol *lbl = newiTempLabel (NULL); emitcode ("sjmp", "%05d$", lbl->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); freeForBranchAsmop (result); freeForBranchAsmop (right); freeForBranchAsmop (left); emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100); - emitcode ("", "%05d$:", lbl->key + 100); + emitLabel (lbl); } } /* mark the icode as generated */ @@ -5891,7 +6269,7 @@ genCmpEq (iCode * ic, iCode * ifx) emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir); emitcode ("jb", "%s,%05d$", AOP (right)->aopu.aop_dir, (lbl->key + 100)); emitcode ("cpl", "c"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); } /* c = 1 if egal */ if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) @@ -5913,7 +6291,7 @@ genCmpEq (iCode * ic, iCode * ifx) gencjne (left, right, newiTempLabel (NULL)); if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) { - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); goto release; } if (ifx) @@ -5929,9 +6307,17 @@ genCmpEq (iCode * ic, iCode * ifx) } release: - freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (result, NULL, ic, TRUE); + if (!swappedLR) + { + freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + } + else + { + freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); + } } /*-----------------------------------------------------------------*/ @@ -5960,7 +6346,7 @@ ifxForOp (operand * op, iCode * ic) /* hasInc - operand is incremented before any other use */ /*-----------------------------------------------------------------*/ static iCode * -hasInc (operand *op, iCode *ic,int osize) +hasInc (operand *op, iCode *ic, int osize) { sym_link *type = operandType(op); sym_link *retype = getSpec (type); @@ -6002,7 +6388,7 @@ genAndOp (iCode * ic) operand *left, *right, *result; symbol *tlbl; - D(emitcode ("; genAndOp","")); + D (emitcode (";", "genAndOp")); /* note here that && operations that are in an if statement are taken away by backPatchLabels @@ -6025,13 +6411,13 @@ genAndOp (iCode * ic) toBoolean (left); emitcode ("jz", "%05d$", tlbl->key + 100); toBoolean (right); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); outBitAcc (result); } + freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (result, NULL, ic, TRUE); } @@ -6044,7 +6430,7 @@ genOrOp (iCode * ic) operand *left, *right, *result; symbol *tlbl; - D(emitcode ("; genOrOp","")); + D (emitcode (";", "genOrOp")); /* note here that || operations that are in an if statement are taken away by backPatchLabels @@ -6067,13 +6453,13 @@ genOrOp (iCode * ic) toBoolean (left); emitcode ("jnz", "%05d$", tlbl->key + 100); toBoolean (right); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); outBitAcc (result); } + freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (result, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -6131,12 +6517,12 @@ jmpTrueOrFalse (iCode * ic, symbol * tlbl, operand *left, operand *right, operan { symbol *nlbl = newiTempLabel (NULL); emitcode ("sjmp", "%05d$", nlbl->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); freeForBranchAsmop (result); freeForBranchAsmop (right); freeForBranchAsmop (left); emitcode ("ljmp", "%05d$", IC_TRUE (ic)->key + 100); - emitcode ("", "%05d$:", nlbl->key + 100); + emitLabel (nlbl); } else { @@ -6144,7 +6530,7 @@ jmpTrueOrFalse (iCode * ic, symbol * tlbl, operand *left, operand *right, operan freeForBranchAsmop (right); freeForBranchAsmop (left); emitcode ("ljmp", "%05d$", IC_FALSE (ic)->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } ic->generated = 1; } @@ -6161,17 +6547,17 @@ genAnd (iCode * ic, iCode * ifx) int bytelit = 0; char buffer[10]; - D(emitcode ("; genAnd","")); + D (emitcode (";", "genAnd")); aopOp ((left = IC_LEFT (ic)), ic, FALSE); aopOp ((right = IC_RIGHT (ic)), ic, FALSE); 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 @@ -6299,7 +6685,7 @@ genAnd (iCode * ic, iCode * ifx) } else {// what is this case? just found it in ds390/gen.c - emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07)); + emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07)); } goto release; } @@ -6332,7 +6718,7 @@ genAnd (iCode * ic, iCode * ifx) if (size) { emitcode ("clr", "c"); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } // if(left & literal) else @@ -6340,7 +6726,7 @@ genAnd (iCode * ic, iCode * ifx) if (ifx) jmpTrueOrFalse (ifx, tlbl, left, right, result); else - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); goto release; } } @@ -6366,13 +6752,13 @@ genAnd (iCode * ic, iCode * ifx) } else if (bytelit == 0) { - aopPut (result, zero, offset, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset); } else if (IS_AOP_PREG (result)) { MOVA (aopGet (left, offset, FALSE, TRUE)); emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE)); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else emitcode ("anl", "%s,%s", @@ -6381,9 +6767,24 @@ genAnd (iCode * ic, iCode * ifx) } else { - if (AOP_TYPE (left) == AOP_ACC && offset == 0) + if (AOP_TYPE (left) == AOP_ACC) + { + if (offset) + emitcode("mov", "a,b"); + emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("anl", "a,b"); + aopPut (result, "a", offset); + } + else if (aopGetUsesAcc (left, offset)) { + MOVA (aopGet (left, offset, FALSE, FALSE)); emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + aopPut (result, "a", offset); } else { @@ -6391,11 +6792,10 @@ genAnd (iCode * ic, iCode * ifx) if (IS_AOP_PREG (result)) { emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, TRUE)); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else - emitcode ("anl", "%s,a", - aopGet (left, offset, FALSE, TRUE)); + emitcode ("anl", "%s,a", aopGet (left, offset, FALSE, TRUE)); } } } @@ -6419,43 +6819,54 @@ genAnd (iCode * ic, iCode * ifx) { if (offset) emitcode("mov", "a,b"); - emitcode ("anl", "a,%s", - aopGet (right, offset, FALSE, FALSE)); - } else { - if (AOP_TYPE(left)==AOP_ACC) + emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } + else if (AOP_TYPE(left)==AOP_ACC) + { + if (!offset) + { + bool pushedB = pushB (); + emitcode("mov", "b,a"); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("anl", "a,b"); + popB (pushedB); + } + else { - if (!offset) - { - bool pushedB = pushB (); - emitcode("mov", "b,a"); - MOVA (aopGet (right, offset, FALSE, FALSE)); - emitcode("anl", "a,b"); - popB (pushedB); - } - else - { - MOVA (aopGet (right, offset, FALSE, FALSE)); - emitcode("anl", "a,b"); - } - } else { MOVA (aopGet (right, offset, FALSE, FALSE)); - emitcode ("anl", "a,%s", - aopGet (left, offset, FALSE, FALSE)); + emitcode("anl", "a,b"); + } + } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("anl", "a,b"); + } + else if (aopGetUsesAcc (left, offset)) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE)); } + else + { + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE)); } + emitcode ("jnz", "%05d$", tlbl->key + 100); offset++; } if (size) { CLRC; - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); outBitC (result); } else if (ifx) jmpTrueOrFalse (ifx, tlbl, left, right, result); else - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } else { @@ -6470,8 +6881,7 @@ genAnd (iCode * ic, iCode * ifx) { aopPut (result, aopGet (left, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); continue; } else if (bytelit == 0) @@ -6479,7 +6889,7 @@ genAnd (iCode * ic, iCode * ifx) /* dummy read of volatile operand */ if (isOperandVolatile (left, FALSE)) MOVA (aopGet (left, offset, FALSE, FALSE)); - aopPut (result, zero, offset, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset); continue; } else if (AOP_TYPE (left) == AOP_ACC) @@ -6487,40 +6897,67 @@ genAnd (iCode * ic, iCode * ifx) if (!offset) { emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE)); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); continue; } else { emitcode ("anl", "b,%s", aopGet (right, offset, FALSE, FALSE)); - aopPut (result, "b", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "b", offset); continue; } } } // faster than result <- left, anl result,right // and better if result is SFR - if (AOP_TYPE (left) == AOP_ACC) + if ((AOP_TYPE(right)==AOP_REG || IS_AOP_PREG(right) || AOP_TYPE(right)==AOP_DIR) + && AOP_TYPE(left)==AOP_ACC) { if (offset) emitcode("mov", "a,b"); emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE)); } + else if (AOP_TYPE(left)==AOP_ACC) + { + if (!offset) + { + bool pushedB = pushB (); + emitcode("mov", "b,a"); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("anl", "a,b"); + popB (pushedB); + } + else + { + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("anl", "a,b"); + } + } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("anl", "a,b"); + } + else if (aopGetUsesAcc (left, offset)) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } else { MOVA (aopGet (right, offset, FALSE, FALSE)); - emitcode ("anl", "a,%s", - aopGet (left, offset, FALSE, FALSE)); + emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE)); } - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } } } release: + freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (result, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -6534,17 +6971,17 @@ genOr (iCode * ic, iCode * ifx) unsigned long lit = 0L; int bytelit = 0; - D(emitcode ("; genOr","")); + D (emitcode (";", "genOr")); aopOp ((left = IC_LEFT (ic)), ic, FALSE); aopOp ((right = IC_RIGHT (ic)), ic, FALSE); 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 @@ -6633,7 +7070,7 @@ genOr (iCode * ic, iCode * ifx) else { CLRC; - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } } } @@ -6673,7 +7110,7 @@ genOr (iCode * ic, iCode * ifx) symbol *tlbl = newiTempLabel (NULL); emitcode ("jnz", "%05d$", tlbl->key + 100); CLRC; - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } else { @@ -6703,13 +7140,13 @@ genOr (iCode * ic, iCode * ifx) } else if (bytelit == 0x0FF) { - aopPut (result, "#0xFF", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "#0xFF", offset); } else if (IS_AOP_PREG (left)) { MOVA (aopGet (left, offset, FALSE, TRUE)); emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE)); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else { @@ -6726,18 +7163,30 @@ genOr (iCode * ic, iCode * ifx) emitcode("mov", "a,b"); emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE)); } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("orl", "a,b"); + aopPut (result, "a", offset); + } + else if (aopGetUsesAcc (left, offset)) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + aopPut (result, "a", offset); + } else { MOVA (aopGet (right, offset, FALSE, FALSE)); if (IS_AOP_PREG (left)) { emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, TRUE)); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else { - emitcode ("orl", "%s,a", - aopGet (left, offset, FALSE, TRUE)); + emitcode ("orl", "%s,a", aopGet (left, offset, FALSE, TRUE)); } } } @@ -6757,29 +7206,59 @@ genOr (iCode * ic, iCode * ifx) emitcode ("setb", "c"); while (sizer--) { - if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) { - if (offset) - emitcode("mov", "a,b"); - emitcode ("orl", "a,%s", - aopGet (right, offset, FALSE, FALSE)); - } else { - MOVA (aopGet (right, offset, FALSE, FALSE)); - emitcode ("orl", "a,%s", - aopGet (left, offset, FALSE, FALSE)); + if ((AOP_TYPE(right)==AOP_REG || IS_AOP_PREG(right) || AOP_TYPE(right)==AOP_DIR) + && AOP_TYPE(left)==AOP_ACC) + { + if (offset) + emitcode("mov", "a,b"); + emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } + else if (AOP_TYPE(left)==AOP_ACC) + { + if (!offset) + { + bool pushedB = pushB (); + emitcode("mov", "b,a"); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("orl", "a,b"); + popB (pushedB); + } + else + { + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("orl", "a,b"); + } + } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("orl", "a,b"); + } + else if (aopGetUsesAcc (left, offset)) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } + else + { + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, FALSE)); } + emitcode ("jnz", "%05d$", tlbl->key + 100); offset++; } if (size) { CLRC; - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); outBitC (result); } else if (ifx) jmpTrueOrFalse (ifx, tlbl, left, right, result); else - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } else { @@ -6794,8 +7273,7 @@ genOr (iCode * ic, iCode * ifx) { aopPut (result, aopGet (left, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); continue; } else if (bytelit == 0x0FF) @@ -6803,33 +7281,60 @@ genOr (iCode * ic, iCode * ifx) /* dummy read of volatile operand */ if (isOperandVolatile (left, FALSE)) MOVA (aopGet (left, offset, FALSE, FALSE)); - aopPut (result, "#0xFF", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "#0xFF", offset); continue; } } - // faster than result <- left, anl result,right + // faster than result <- left, orl result,right // and better if result is SFR - if (AOP_TYPE (left) == AOP_ACC) + if ((AOP_TYPE(right)==AOP_REG || IS_AOP_PREG(right) || AOP_TYPE(right)==AOP_DIR) + && AOP_TYPE(left)==AOP_ACC) { if (offset) emitcode("mov", "a,b"); emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE)); } + else if (AOP_TYPE(left)==AOP_ACC) + { + if (!offset) + { + bool pushedB = pushB (); + emitcode("mov", "b,a"); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("orl", "a,b"); + popB (pushedB); + } + else + { + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("orl", "a,b"); + } + } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("orl", "a,b"); + } + else if (aopGetUsesAcc (left, offset)) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } else { MOVA (aopGet (right, offset, FALSE, FALSE)); - emitcode ("orl", "a,%s", - aopGet (left, offset, FALSE, FALSE)); + emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, FALSE)); } - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } } } release: + freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (result, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -6843,17 +7348,17 @@ genXor (iCode * ic, iCode * ifx) unsigned long lit = 0L; int bytelit = 0; - D(emitcode ("; genXor","")); + D (emitcode (";", "genXor")); aopOp ((left = IC_LEFT (ic)), ic, FALSE); aopOp ((right = IC_RIGHT (ic)), ic, FALSE); 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 @@ -6884,6 +7389,7 @@ genXor (iCode * ic, iCode * ifx) right = left; left = tmp; } + if (AOP_TYPE (right) == AOP_LIT) lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); @@ -6934,7 +7440,6 @@ genXor (iCode * ic, iCode * ifx) } } } - } else { @@ -6947,31 +7452,18 @@ genXor (iCode * ic, iCode * ifx) } 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"); - emitcode ("", "%05d$:", (tlbl->key + 100)); + emitLabel (tlbl); } // bit = 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; @@ -6997,7 +7489,7 @@ genXor (iCode * ic, iCode * ifx) { MOVA (aopGet (left, offset, FALSE, TRUE)); emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE)); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else { @@ -7014,17 +7506,29 @@ genXor (iCode * ic, iCode * ifx) emitcode("mov", "a,b"); emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE)); } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("xrl", "a,b"); + aopPut (result, "a", offset); + } + else if (aopGetUsesAcc (left, offset)) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + aopPut (result, "a", offset); + } else { MOVA (aopGet (right, offset, FALSE, FALSE)); if (IS_AOP_PREG (left)) { emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE)); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else - emitcode ("xrl", "%s,a", - aopGet (left, offset, FALSE, TRUE)); + emitcode ("xrl", "%s,a", aopGet (left, offset, FALSE, TRUE)); } } } @@ -7039,6 +7543,7 @@ genXor (iCode * ic, iCode * ifx) // if(!size && ifx), conditional oper: if(left ^ right) symbol *tlbl = newiTempLabel (NULL); int sizer = max (AOP_SIZE (left), AOP_SIZE (right)); + if (size) emitcode ("setb", "c"); while (sizer--) @@ -7048,26 +7553,53 @@ genXor (iCode * ic, iCode * ifx) { MOVA (aopGet (left, offset, FALSE, FALSE)); } + else if ((AOP_TYPE(right)==AOP_REG || IS_AOP_PREG(right) || AOP_TYPE(right)==AOP_DIR) + && AOP_TYPE(left)==AOP_ACC) + { + if (offset) + emitcode("mov", "a,b"); + emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } + else if (AOP_TYPE(left)==AOP_ACC) + { + if (!offset) + { + bool pushedB = pushB (); + emitcode("mov", "b,a"); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("xrl", "a,b"); + popB (pushedB); + } + else + { + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("xrl", "a,b"); + } + } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("xrl", "a,b"); + } + else if (aopGetUsesAcc (left, offset)) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } else { - if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) { - if (offset) - emitcode("mov", "a,b"); - emitcode ("xrl", "a,%s", - aopGet (right, offset, FALSE, FALSE)); - } else { - MOVA (aopGet (right, offset, FALSE, FALSE)); - emitcode ("xrl", "a,%s", - aopGet (left, offset, FALSE, FALSE)); - } + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE)); } + emitcode ("jnz", "%05d$", tlbl->key + 100); offset++; } if (size) { CLRC; - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); outBitC (result); } else if (ifx) @@ -7078,7 +7610,7 @@ genXor (iCode * ic, iCode * ifx) for (; (size--); offset++) { // normal case - // result = left & right + // result = left ^ right if (AOP_TYPE (right) == AOP_LIT) { bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL); @@ -7086,34 +7618,60 @@ genXor (iCode * ic, iCode * ifx) { aopPut (result, aopGet (left, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); continue; } } - // faster than result <- left, anl result,right + // faster than result <- left, xrl result,right // and better if result is SFR - if (AOP_TYPE (left) == AOP_ACC) + if ((AOP_TYPE(right)==AOP_REG || IS_AOP_PREG(right) || AOP_TYPE(right)==AOP_DIR) + && AOP_TYPE(left)==AOP_ACC) { if (offset) emitcode("mov", "a,b"); emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE)); } + else if (AOP_TYPE(left)==AOP_ACC) + { + if (!offset) + { + bool pushedB = pushB (); + emitcode("mov", "b,a"); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("xrl", "a,b"); + popB (pushedB); + } + else + { + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode("xrl", "a,b"); + } + } + else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) + { + MOVB (aopGet (left, offset, FALSE, FALSE)); + MOVA (aopGet (right, offset, FALSE, FALSE)); + emitcode ("xrl", "a,b"); + } + else if (aopGetUsesAcc (left, offset)) + { + MOVA (aopGet (left, offset, FALSE, FALSE)); + emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE)); + } else { MOVA (aopGet (right, offset, FALSE, FALSE)); - emitcode ("xrl", "a,%s", - aopGet (left, offset, FALSE, TRUE)); + emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE)); } - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } } } release: + freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE)); - freeAsmop (result, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7124,12 +7682,11 @@ genInline (iCode * ic) { char *buffer, *bp, *bp1; - D(emitcode ("; genInline","")); + 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) @@ -7168,10 +7725,10 @@ static void genRRC (iCode * ic) { operand *left, *result; - int size, offset = 0; + int size, offset; char *l; - D(emitcode ("; genRRC","")); + D (emitcode (";", "genRRC")); /* rotate right with carry */ left = IC_LEFT (ic); @@ -7195,7 +7752,7 @@ genRRC (iCode * ic) MOVA (l); emitcode ("rrc", "a"); if (AOP_SIZE (result) > 1) - aopPut (result, "a", offset--, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset--); } /* now we need to put the carry into the highest order byte of the result */ @@ -7206,9 +7763,9 @@ genRRC (iCode * ic) } emitcode ("mov", "acc.7,c"); release: - aopPut (result, "a", AOP_SIZE (result) - 1, isOperandVolatile (result, FALSE)); - freeAsmop (left, NULL, ic, TRUE); + aopPut (result, "a", AOP_SIZE (result) - 1); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7218,10 +7775,10 @@ static void genRLC (iCode * ic) { operand *left, *result; - int size, offset = 0; + int size, offset; char *l; - D(emitcode ("; genRLC","")); + D (emitcode (";", "genRLC")); /* rotate right with carry */ left = IC_LEFT (ic); @@ -7242,14 +7799,17 @@ genRLC (iCode * ic) } emitcode("rlc","a"); /* bit0 will be written later */ if (AOP_SIZE (result) > 1) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + { + aopPut (result, "a", offset++); + } + while (size--) { l = aopGet (left, offset, FALSE, FALSE); MOVA (l); emitcode ("rlc", "a"); if (AOP_SIZE (result) > 1) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); } } /* now we need to put the carry into the @@ -7261,9 +7821,9 @@ genRLC (iCode * ic) } emitcode ("mov", "acc.0,c"); release: - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); - freeAsmop (left, NULL, ic, TRUE); + aopPut (result, "a", 0); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7274,7 +7834,7 @@ genGetHbit (iCode * ic) { operand *left, *result; - D(emitcode ("; genGetHbit","")); + D (emitcode (";", "genGetHbit")); left = IC_LEFT (ic); result = IC_RESULT (ic); @@ -7295,9 +7855,8 @@ genGetHbit (iCode * ic) outAcc (result); } - - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7309,7 +7868,7 @@ genGetAbit (iCode * ic) operand *left, *right, *result; int shCount; - D(emitcode ("; genGetAbit","")); + D (emitcode (";", "genGetAbit")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -7367,9 +7926,9 @@ genGetAbit (iCode * ic) outAcc (result); } - freeAsmop (left, NULL, ic, TRUE); - freeAsmop (right, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7381,7 +7940,7 @@ genGetByte (iCode * ic) operand *left, *right, *result; int offset; - D(emitcode ("; genGetByte","")); + D (emitcode (";", "genGetByte")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -7393,12 +7952,11 @@ genGetByte (iCode * ic) offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8; aopPut (result, aopGet (left, offset, FALSE, FALSE), - 0, - isOperandVolatile (result, FALSE)); + 0); - freeAsmop (left, NULL, ic, TRUE); - freeAsmop (right, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7410,7 +7968,7 @@ genGetWord (iCode * ic) operand *left, *right, *result; int offset; - D(emitcode ("; genGetWord","")); + D (emitcode (";", "genGetWord")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -7422,16 +7980,14 @@ genGetWord (iCode * ic) offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8; aopPut (result, aopGet (left, offset, FALSE, FALSE), - 0, - isOperandVolatile (result, FALSE)); + 0); aopPut (result, aopGet (left, offset+1, FALSE, FALSE), - 1, - isOperandVolatile (result, FALSE)); + 1); - freeAsmop (left, NULL, ic, TRUE); - freeAsmop (right, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7442,7 +7998,7 @@ genSwap (iCode * ic) { operand *left, *result; - D(emitcode ("; genSwap","")); + D(emitcode (";", "genSwap")); left = IC_LEFT (ic); result = IC_RESULT (ic); @@ -7454,15 +8010,14 @@ genSwap (iCode * ic) case 1: /* swap nibbles in byte */ MOVA (aopGet (left, 0, FALSE, FALSE)); emitcode ("swap", "a"); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); break; case 2: /* swap bytes in word */ if (AOP_TYPE(left) == AOP_REG && sameRegs(AOP(left), AOP(result))) { MOVA (aopGet (left, 0, FALSE, FALSE)); - aopPut (result, aopGet (left, 1, FALSE, FALSE), - 0, isOperandVolatile (result, FALSE)); - aopPut (result, "a", 1, isOperandVolatile (result, FALSE)); + aopPut (result, aopGet (left, 1, FALSE, FALSE), 0); + aopPut (result, "a", 1); } else if (operandsEqu (left, result)) { @@ -7477,30 +8032,26 @@ genSwap (iCode * ic) reg = "b"; leftInB = TRUE; } - aopPut (result, aopGet (left, 1, FALSE, FALSE), - 0, isOperandVolatile (result, FALSE)); - aopPut (result, reg, 1, isOperandVolatile (result, FALSE)); + aopPut (result, aopGet (left, 1, FALSE, FALSE), 0); + aopPut (result, reg, 1); if (leftInB) popB (pushedB); } else { - aopPut (result, aopGet (left, 1, FALSE, FALSE), - 0, isOperandVolatile (result, FALSE)); - aopPut (result, aopGet (left, 0, FALSE, FALSE), - 1, isOperandVolatile (result, FALSE)); + aopPut (result, aopGet (left, 1, FALSE, FALSE), 0); + aopPut (result, aopGet (left, 0, FALSE, FALSE), 1); } break; default: wassertl(FALSE, "unsupported SWAP operand size"); } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } - /*-----------------------------------------------------------------*/ /* AccRol - rotate left accumulator by known count */ /*-----------------------------------------------------------------*/ @@ -7620,7 +8171,7 @@ AccSRsh (int shCount) emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100); emitcode ("orl", "a,#0x%02x", (unsigned char) ~SRMask[shCount]); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } } } @@ -7639,7 +8190,7 @@ shiftR1Left2Result (operand * left, int offl, AccSRsh (shCount); else AccRsh (shCount); - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); } /*-----------------------------------------------------------------*/ @@ -7654,7 +8205,7 @@ shiftL1Left2Result (operand * left, int offl, MOVA (l); /* shift left accumulator */ AccLsh (shCount); - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); } /*-----------------------------------------------------------------*/ @@ -7672,19 +8223,21 @@ movLeft2Result (operand * left, int offl, if (*l == '@' && (IS_AOP_PREG (result))) { emitcode ("mov", "a,%s", l); - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); } else { if (!sign) - aopPut (result, l, offr, isOperandVolatile (result, FALSE)); + { + aopPut (result, l, offr); + } else { /* MSB sign in acc.7 ! */ if (getDataSize (left) == offl + 1) { - emitcode ("mov", "a,%s", l); - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + MOVA (l); + aopPut (result, "a", offr); } } } @@ -7945,7 +8498,7 @@ AccAXRshS (char *x, int shCount) emitcode ("orl", "a,#0x%02x", (unsigned char) ~SRMask[shCount]); // 111AAAAA:BBBCCCCC - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); break; // SSSSAAAA:BBBCCCCC case 6: // AABBBBBB:CCDDDDDD @@ -7966,7 +8519,7 @@ AccAXRshS (char *x, int shCount) emitcode ("orl", "a,#0x%02x", (unsigned char) ~SRMask[shCount]); // 111111AA:BBBBBBCC - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); break; case 7: // ABBBBBBB:CDDDDDDD @@ -7984,7 +8537,7 @@ AccAXRshS (char *x, int shCount) emitcode ("orl", "a,#0x%02x", (unsigned char) ~SRMask[shCount]); // 1111111A:BBBBBBBC - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); break; default: break; @@ -7998,21 +8551,47 @@ static void shiftL2Left2Result (operand * left, int offl, operand * result, int offr, int shCount) { + char * x; + bool pushedB = FALSE; + bool usedB = FALSE; + if (sameRegs (AOP (result), AOP (left)) && ((offl + MSB16) == offr)) { /* don't crash result[offr] */ MOVA (aopGet (left, offl, FALSE, FALSE)); - emitcode ("xch", "a,%s", aopGet (left, offl + MSB16, FALSE, FALSE)); + x = xch_a_aopGet (left, offl + MSB16, FALSE, FALSE); + usedB = !strncmp(x, "b", 1); + } + else if (aopGetUsesAcc (result, offr)) + { + movLeft2Result (left, offl, result, offr, 0); + pushedB = pushB (); + usedB = TRUE; + emitcode ("mov", "b,%s", aopGet (left, offl + MSB16, FALSE, FALSE)); + MOVA (aopGet (result, offr, FALSE, FALSE)); + emitcode ("xch", "a,b"); + x = "b"; } else { movLeft2Result (left, offl, result, offr, 0); MOVA (aopGet (left, offl + MSB16, FALSE, FALSE)); + x = aopGet (result, offr, FALSE, FALSE); + } + /* ax << shCount (x = lsb(result)) */ + AccAXLsh (x, shCount); + if (usedB) + { + emitcode ("xch", "a,b"); + aopPut (result, "a", offr); + aopPut (result, "b", offr + MSB16); + popB (pushedB); + } + else + { + aopPut (result, "a", offr + MSB16); } - /* ax << shCount (x = lsb(result)) */ - AccAXLsh (aopGet (result, offr, FALSE, FALSE), shCount); - aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE)); } @@ -8024,25 +8603,47 @@ shiftR2Left2Result (operand * left, int offl, operand * result, int offr, int shCount, int sign) { + char * x; + bool pushedB = FALSE; + bool usedB = FALSE; + if (sameRegs (AOP (result), AOP (left)) && ((offl + MSB16) == offr)) { /* don't crash result[offr] */ MOVA (aopGet (left, offl, FALSE, FALSE)); - emitcode ("xch", "a,%s", aopGet (left, offl + MSB16, FALSE, FALSE)); + x = xch_a_aopGet (left, offl + MSB16, FALSE, FALSE); + usedB = !strncmp(x, "b", 1); + } + else if (aopGetUsesAcc (result, offr)) + { + movLeft2Result (left, offl, result, offr, 0); + pushedB = pushB (); + usedB = TRUE; + emitcode ("mov", "b,%s", aopGet (result, offr, FALSE, FALSE)); + MOVA (aopGet (left, offl + MSB16, FALSE, FALSE)); + x = "b"; } else { movLeft2Result (left, offl, result, offr, 0); MOVA (aopGet (left, offl + MSB16, FALSE, FALSE)); + x = aopGet (result, offr, FALSE, FALSE); } /* a:x >> shCount (x = lsb(result)) */ if (sign) - AccAXRshS (aopGet (result, offr, FALSE, FALSE), shCount); + AccAXRshS (x, shCount); else - AccAXRsh (aopGet (result, offr, FALSE, FALSE), shCount); + AccAXRsh (x, shCount); + if (usedB) + { + emitcode ("xch", "a,b"); + aopPut (result, "a", offr); + emitcode ("xch", "a,b"); + popB (pushedB); + } if (getDataSize (result) > 1) - aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr + MSB16); } /*-----------------------------------------------------------------*/ @@ -8056,9 +8657,18 @@ shiftLLeftOrResult (operand * left, int offl, /* shift left accumulator */ AccLsh (shCount); /* or with result */ - emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE)); + if (aopGetUsesAcc (result, offr)) + { + emitcode ("xch", "a,b"); + MOVA (aopGet (result, offr, FALSE, FALSE)); + emitcode ("orl", "a,b"); + } + else + { + emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE)); + } /* back to result */ - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); } /*-----------------------------------------------------------------*/ @@ -8072,9 +8682,18 @@ shiftRLeftOrResult (operand * left, int offl, /* shift right accumulator */ AccRsh (shCount); /* or with result */ - emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE)); + if (aopGetUsesAcc(result, offr)) + { + emitcode ("xch", "a,b"); + MOVA (aopGet (result, offr, FALSE, FALSE)); + emitcode ("orl", "a,b"); + } + else + { + emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE)); + } /* back to result */ - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); } /*-----------------------------------------------------------------*/ @@ -8083,7 +8702,7 @@ shiftRLeftOrResult (operand * left, int offl, static void genlshOne (operand * result, operand * left, int shCount) { - D(emitcode ("; genlshOne","")); + D (emitcode (";", "genlshOne")); shiftL1Left2Result (left, LSB, result, LSB, shCount); } @@ -8096,7 +8715,7 @@ genlshTwo (operand * result, operand * left, int shCount) { int size; - D(emitcode ("; genlshTwo","")); + D (emitcode (";", "genlshTwo")); size = getDataSize (result); @@ -8112,7 +8731,7 @@ genlshTwo (operand * result, operand * left, int shCount) else movLeft2Result (left, LSB, result, MSB16, 0); } - aopPut (result, zero, LSB, isOperandVolatile (result, FALSE)); + aopPut (result, zero, LSB); } /* 1 <= shCount <= 7 */ @@ -8142,10 +8761,9 @@ shiftLLong (operand * left, operand * result, int offr) emitcode ("add", "a,acc"); if (sameRegs (AOP (left), AOP (result)) && size >= MSB16 + offr && offr != LSB) - emitcode ("xch", "a,%s", - aopGet (left, LSB + offr, FALSE, FALSE)); + xch_a_aopGet (left, LSB + offr, FALSE, FALSE); else - aopPut (result, "a", LSB + offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", LSB + offr); } if (size >= MSB16 + offr) @@ -8158,10 +8776,9 @@ shiftLLong (operand * left, operand * result, int offr) emitcode ("rlc", "a"); if (sameRegs (AOP (left), AOP (result)) && size >= MSB24 + offr && offr != LSB) - emitcode ("xch", "a,%s", - aopGet (left, MSB16 + offr, FALSE, FALSE)); + xch_a_aopGet (left, MSB16 + offr, FALSE, FALSE); else - aopPut (result, "a", MSB16 + offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", MSB16 + offr); } if (size >= MSB24 + offr) @@ -8174,10 +8791,9 @@ shiftLLong (operand * left, operand * result, int offr) emitcode ("rlc", "a"); if (sameRegs (AOP (left), AOP (result)) && size >= MSB32 + offr && offr != LSB) - emitcode ("xch", "a,%s", - aopGet (left, MSB24 + offr, FALSE, FALSE)); + xch_a_aopGet (left, MSB24 + offr, FALSE, FALSE); else - aopPut (result, "a", MSB24 + offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", MSB24 + offr); } if (size > MSB32 + offr) @@ -8188,10 +8804,10 @@ shiftLLong (operand * left, operand * result, int offr) MOVA (l); } emitcode ("rlc", "a"); - aopPut (result, "a", MSB32 + offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", MSB32 + offr); } if (offr != LSB) - aopPut (result, zero, LSB, isOperandVolatile (result, FALSE)); + aopPut (result, zero, LSB); } /*-----------------------------------------------------------------*/ @@ -8202,7 +8818,7 @@ genlshFour (operand * result, operand * left, int shCount) { int size; - D(emitcode ("; genlshFour","")); + D (emitcode (";", "genlshFour")); size = AOP_SIZE (result); @@ -8216,9 +8832,9 @@ genlshFour (operand * result, operand * left, int shCount) shiftL1Left2Result (left, LSB, result, MSB32, shCount); else movLeft2Result (left, LSB, result, MSB32, 0); - aopPut (result, zero, LSB, isOperandVolatile (result, FALSE)); - aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE)); - aopPut (result, zero, MSB24, isOperandVolatile (result, FALSE)); + aopPut (result, zero, LSB); + aopPut (result, zero, MSB16); + aopPut (result, zero, MSB24); return; } @@ -8235,8 +8851,8 @@ genlshFour (operand * result, operand * left, int shCount) movLeft2Result (left, MSB16, result, MSB32, 0); movLeft2Result (left, LSB, result, MSB24, 0); } - aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE)); - aopPut (result, zero, LSB, isOperandVolatile (result, FALSE)); + aopPut (result, zero, MSB16); + aopPut (result, zero, LSB); return; } @@ -8259,7 +8875,7 @@ genlshFour (operand * result, operand * left, int shCount) movLeft2Result (left, MSB24, result, MSB32, 0); movLeft2Result (left, MSB16, result, MSB24, 0); movLeft2Result (left, LSB, result, MSB16, 0); - aopPut (result, zero, LSB, isOperandVolatile (result, FALSE)); + aopPut (result, zero, LSB); } else if (shCount == 1) shiftLLong (left, result, MSB16); @@ -8268,7 +8884,7 @@ genlshFour (operand * result, operand * left, int shCount) shiftL2Left2Result (left, MSB16, result, MSB24, shCount); shiftL1Left2Result (left, LSB, result, MSB16, shCount); shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount); - aopPut (result, zero, LSB, isOperandVolatile (result, FALSE)); + aopPut (result, zero, LSB); } } } @@ -8301,7 +8917,7 @@ genLeftShiftLiteral (operand * left, int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit); int size; - D(emitcode ("; genLeftShiftLiteral","")); + D (emitcode (";", "genLeftShiftLiteral")); freeAsmop (right, NULL, ic, TRUE); @@ -8323,10 +8939,13 @@ genLeftShiftLiteral (operand * left, movLeft2Result (left, size, result, size, 0); } } - else if (shCount >= (size * 8)) - while (size--) - aopPut (result, zero, size, isOperandVolatile (result, FALSE)); + { + while (size--) + { + aopPut (result, zero, size); + } + } else { switch (size) @@ -8348,8 +8967,8 @@ genLeftShiftLiteral (operand * left, break; } } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -8364,7 +8983,7 @@ genLeftShift (iCode * ic) symbol *tlbl, *tlbl1; bool pushedB; - D(emitcode ("; genLeftShift","")); + D (emitcode (";", "genLeftShift")); right = IC_RIGHT (ic); left = IC_LEFT (ic); @@ -8387,7 +9006,7 @@ genLeftShift (iCode * ic) largest size of an object can be only 32 bits ) */ pushedB = pushB (); - emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE)); + MOVB (aopGet (right, 0, FALSE, FALSE)); emitcode ("inc", "b"); freeAsmop (right, NULL, ic, TRUE); aopOp (left, ic, FALSE); @@ -8407,10 +9026,10 @@ genLeftShift (iCode * ic) { emitcode ("mov", "a,%s", l); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else - aopPut (result, l, offset, isOperandVolatile (result, FALSE)); + aopPut (result, l, offset); offset++; } } @@ -8428,38 +9047,38 @@ genLeftShift (iCode * ic) l = aopGet (left, 0, FALSE, FALSE); MOVA (l); emitcode ("sjmp", "%05d$", tlbl1->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); emitcode ("add", "a,acc"); - emitcode ("", "%05d$:", tlbl1->key + 100); + emitLabel (tlbl1); emitcode ("djnz", "b,%05d$", tlbl->key + 100); popB (pushedB); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); goto release; } reAdjustPreg (AOP (result)); emitcode ("sjmp", "%05d$", tlbl1->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); l = aopGet (result, offset, FALSE, FALSE); MOVA (l); emitcode ("add", "a,acc"); - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); while (--size) { l = aopGet (result, offset, FALSE, FALSE); MOVA (l); emitcode ("rlc", "a"); - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); } reAdjustPreg (AOP (result)); - emitcode ("", "%05d$:", tlbl1->key + 100); + emitLabel (tlbl1); emitcode ("djnz", "b,%05d$", tlbl->key + 100); popB (pushedB); release: - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -8469,7 +9088,7 @@ static void genrshOne (operand * result, operand * left, int shCount, int sign) { - D(emitcode ("; genrshOne","")); + D (emitcode (";", "genrshOne")); shiftR1Left2Result (left, LSB, result, LSB, shCount, sign); } @@ -8481,15 +9100,14 @@ static void genrshTwo (operand * result, operand * left, int shCount, int sign) { - D(emitcode ("; genrshTwo","")); + D (emitcode (";", "genrshTwo")); /* if shCount >= 8 */ if (shCount >= 8) { shCount -= 8; if (shCount) - shiftR1Left2Result (left, MSB16, result, LSB, - shCount, sign); + shiftR1Left2Result (left, MSB16, result, LSB, shCount, sign); else movLeft2Result (left, MSB16, result, LSB, sign); addSign (result, MSB16, sign); @@ -8508,61 +9126,101 @@ static void shiftRLong (operand * left, int offl, operand * result, int sign) { - int isSameRegs=sameRegs(AOP(left),AOP(result)); + bool overlapping = regsInCommon (left, result) || operandsEqu(left, result); - if (isSameRegs && offl>1) { - // we are in big trouble, but this shouldn't happen - werror(E_INTERNAL_ERROR, __FILE__, __LINE__); - } + if (overlapping && offl>1) + { + // we are in big trouble, but this shouldn't happen + werror(E_INTERNAL_ERROR, __FILE__, __LINE__); + } MOVA (aopGet (left, MSB32, FALSE, FALSE)); - if (offl==MSB16) { - // shift is > 8 - if (sign) { - emitcode ("rlc", "a"); - emitcode ("subb", "a,acc"); - if (isSameRegs) - emitcode ("xch", "a,%s", aopGet (left, MSB32, FALSE, FALSE)); - else { - aopPut (result, "a", MSB32, isOperandVolatile (result, FALSE)); - MOVA (aopGet (left, MSB32, FALSE, FALSE)); - } - } else { - aopPut (result, zero, MSB32, isOperandVolatile (result, FALSE)); + if (offl==MSB16) + { + // shift is > 8 + if (sign) + { + emitcode ("rlc", "a"); + emitcode ("subb", "a,acc"); + if (overlapping && sameByte (AOP (left), MSB32, AOP (result), MSB32)) + { + xch_a_aopGet (left, MSB32, FALSE, FALSE); + } + else + { + aopPut (result, "a", MSB32); + MOVA (aopGet (left, MSB32, FALSE, FALSE)); + } + } + else + { + if (aopPutUsesAcc (result, zero, MSB32)) + { + emitcode("xch", "a,b"); + aopPut (result, zero, MSB32); + emitcode("xch", "a,b"); + } + else + { + aopPut (result, zero, MSB32); + } + } } - } - if (!sign) { - emitcode ("clr", "c"); - } else { - emitcode ("mov", "c,acc.7"); - } + if (!sign) + { + emitcode ("clr", "c"); + } + else + { + emitcode ("mov", "c,acc.7"); + } emitcode ("rrc", "a"); - if (isSameRegs && offl==MSB16) { - emitcode ("xch", "a,%s",aopGet (left, MSB24, FALSE, FALSE)); - } else { - aopPut (result, "a", MSB32-offl, isOperandVolatile (result, FALSE)); - MOVA (aopGet (left, MSB24, FALSE, FALSE)); - } + if (overlapping && offl==MSB16 && + sameByte (AOP (left), MSB24, AOP (result), MSB32-offl)) + { + xch_a_aopGet (left, MSB24, FALSE, FALSE); + } + else + { + aopPut (result, "a", MSB32 - offl); + MOVA (aopGet (left, MSB24, FALSE, FALSE)); + } emitcode ("rrc", "a"); - if (isSameRegs && offl==1) { - emitcode ("xch", "a,%s",aopGet (left, MSB16, FALSE, FALSE)); - } else { - aopPut (result, "a", MSB24-offl, isOperandVolatile (result, FALSE)); - MOVA (aopGet (left, MSB16, FALSE, FALSE)); - } - emitcode ("rrc", "a"); - aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE)); + if (overlapping && offl==MSB16 && + sameByte (AOP (left), MSB16, AOP (result), MSB24-offl)) + { + xch_a_aopGet (left, MSB16, FALSE, FALSE); + } + else + { + aopPut (result, "a", MSB24 - offl); + MOVA (aopGet (left, MSB16, FALSE, FALSE)); + } - if (offl == LSB) + emitcode ("rrc", "a"); + if (offl != LSB) + { + aopPut (result, "a", MSB16 - offl); + } + else { - MOVA (aopGet (left, LSB, FALSE, FALSE)); + if (overlapping && + sameByte (AOP (left), LSB, AOP (result), MSB16-offl)) + { + xch_a_aopGet (left, LSB, FALSE, FALSE); + } + else + { + aopPut (result, "a", MSB16 - offl); + MOVA (aopGet (left, LSB, FALSE, FALSE)); + } emitcode ("rrc", "a"); - aopPut (result, "a", LSB, isOperandVolatile (result, FALSE)); + aopPut (result, "a", LSB); } } @@ -8573,7 +9231,7 @@ static void genrshFour (operand * result, operand * left, int shCount, int sign) { - D(emitcode ("; genrshFour","")); + D (emitcode (";", "genrshFour")); /* if shifting more that 3 bytes */ if (shCount >= 24) @@ -8601,7 +9259,9 @@ genrshFour (operand * result, operand * left, { shCount -= 8; if (shCount == 1) - shiftRLong (left, MSB16, result, sign); + { + shiftRLong (left, MSB16, result, sign); + } else if (shCount == 0) { movLeft2Result (left, MSB16, result, LSB, 0); @@ -8619,7 +9279,8 @@ genrshFour (operand * result, operand * left, } } else - { /* 1 <= shCount <= 7 */ + { + /* 1 <= shCount <= 7 */ if (shCount <= 2) { shiftRLong (left, LSB, result, sign); @@ -8648,7 +9309,7 @@ genRightShiftLiteral (operand * left, int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit); int size; - D(emitcode ("; genRightShiftLiteral","")); + D (emitcode (";", "genRightShiftLiteral")); freeAsmop (right, NULL, ic, TRUE); @@ -8673,10 +9334,11 @@ genRightShiftLiteral (operand * left, else if (shCount >= (size * 8)) { - if (sign) { - /* get sign in acc.7 */ - MOVA (aopGet (left, size - 1, FALSE, FALSE)); - } + if (sign) + { + /* get sign in acc.7 */ + MOVA (aopGet (left, size - 1, FALSE, FALSE)); + } addSign (result, LSB, sign); } else @@ -8698,8 +9360,8 @@ genRightShiftLiteral (operand * left, break; } } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -8714,7 +9376,7 @@ genSignedRightShift (iCode * ic) symbol *tlbl, *tlbl1; bool pushedB; - D(emitcode ("; genSignedRightShift","")); + D (emitcode (";", "genSignedRightShift")); /* we do it the hard way put the shift count in b and loop thru preserving the sign */ @@ -8738,7 +9400,7 @@ genSignedRightShift (iCode * ic) largest size of an object can be only 32 bits ) */ pushedB = pushB (); - emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE)); + MOVB (aopGet (right, 0, FALSE, FALSE)); emitcode ("inc", "b"); freeAsmop (right, NULL, ic, TRUE); aopOp (left, ic, FALSE); @@ -8759,10 +9421,10 @@ genSignedRightShift (iCode * ic) { emitcode ("mov", "a,%s", l); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else - aopPut (result, l, offset, isOperandVolatile (result, FALSE)); + aopPut (result, l, offset); offset++; } } @@ -8782,35 +9444,35 @@ genSignedRightShift (iCode * ic) l = aopGet (left, 0, FALSE, FALSE); MOVA (l); emitcode ("sjmp", "%05d$", tlbl1->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); emitcode ("mov", "c,ov"); emitcode ("rrc", "a"); - emitcode ("", "%05d$:", tlbl1->key + 100); + emitLabel (tlbl1); emitcode ("djnz", "b,%05d$", tlbl->key + 100); popB (pushedB); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); goto release; } reAdjustPreg (AOP (result)); emitcode ("sjmp", "%05d$", tlbl1->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); emitcode ("mov", "c,ov"); while (size--) { l = aopGet (result, offset, FALSE, FALSE); MOVA (l); emitcode ("rrc", "a"); - aopPut (result, "a", offset--, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset--); } reAdjustPreg (AOP (result)); - emitcode ("", "%05d$:", tlbl1->key + 100); + emitLabel (tlbl1); emitcode ("djnz", "b,%05d$", tlbl->key + 100); popB (pushedB); release: - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -8826,7 +9488,7 @@ genRightShift (iCode * ic) symbol *tlbl, *tlbl1; bool pushedB; - D(emitcode ("; genRightShift","")); + D (emitcode (";", "genRightShift")); /* if signed then we do it the hard way preserve the sign bit moving it inwards */ @@ -8866,7 +9528,7 @@ genRightShift (iCode * ic) largest size of an object can be only 32 bits ) */ pushedB = pushB (); - emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE)); + MOVB (aopGet (right, 0, FALSE, FALSE)); emitcode ("inc", "b"); freeAsmop (right, NULL, ic, TRUE); aopOp (left, ic, FALSE); @@ -8877,7 +9539,6 @@ genRightShift (iCode * ic) if (!sameRegs (AOP (left), AOP (result)) && AOP_SIZE (result) > 1) { - size = AOP_SIZE (result); offset = 0; while (size--) @@ -8887,10 +9548,10 @@ genRightShift (iCode * ic) { emitcode ("mov", "a,%s", l); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else - aopPut (result, l, offset, isOperandVolatile (result, FALSE)); + aopPut (result, l, offset); offset++; } } @@ -8906,36 +9567,36 @@ genRightShift (iCode * ic) l = aopGet (left, 0, FALSE, FALSE); MOVA (l); emitcode ("sjmp", "%05d$", tlbl1->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); CLRC; emitcode ("rrc", "a"); - emitcode ("", "%05d$:", tlbl1->key + 100); + emitLabel (tlbl1); emitcode ("djnz", "b,%05d$", tlbl->key + 100); popB (pushedB); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "a", 0); goto release; } reAdjustPreg (AOP (result)); emitcode ("sjmp", "%05d$", tlbl1->key + 100); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); CLRC; while (size--) { l = aopGet (result, offset, FALSE, FALSE); MOVA (l); emitcode ("rrc", "a"); - aopPut (result, "a", offset--, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset--); } reAdjustPreg (AOP (result)); - emitcode ("", "%05d$:", tlbl1->key + 100); + emitLabel (tlbl1); emitcode ("djnz", "b,%05d$", tlbl->key + 100); popB (pushedB); release: - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -9038,7 +9699,7 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx) int bstr; /* bitfield starting bit within byte */ char buffer[10]; - D(emitcode ("; genUnpackBits","")); + D(emitcode (";", "genUnpackBits")); etype = getSpec (operandType (result)); rsize = getSize (operandType (result)); @@ -9069,9 +9730,18 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx) if (blen < 8) { emitPtrByteGet (rname, ptype, FALSE); - AccRsh (bstr); + AccRol (8 - bstr); emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (8 - blen)); - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + if (!SPEC_USIGN (etype)) + { + /* signed bitfield */ + symbol *tlbl = newiTempLabel (NULL); + + emitcode ("jnb", "acc.%d,%05d$", blen - 1, tlbl->key + 100); + emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << blen)); + emitLabel (tlbl); + } + aopPut (result, "a", offset++); goto finish; } @@ -9080,7 +9750,7 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx) for (rlen=blen;rlen>=8;rlen-=8) { emitPtrByteGet (rname, ptype, FALSE); - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); if (rlen>8) emitcode ("inc", "%s", rname); } @@ -9090,15 +9760,36 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx) { emitPtrByteGet (rname, ptype, FALSE); emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (8-rlen)); - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + if (!SPEC_USIGN (etype)) + { + /* signed bitfield */ + symbol *tlbl = newiTempLabel (NULL); + + emitcode ("jnb", "acc.%d,%05d$", rlen - 1, tlbl->key + 100); + emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << rlen)); + emitLabel (tlbl); + } + aopPut (result, "a", offset++); } finish: if (offset < rsize) { + char *source; + + if (SPEC_USIGN (etype)) + source = zero; + else + { + /* signed bitfield: sign extension with 0x00 or 0xff */ + emitcode ("rlc", "a"); + emitcode ("subb", "a,acc"); + + source = "a"; + } rsize -= offset; while (rsize--) - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + aopPut (result, source, offset++); } } @@ -9115,24 +9806,29 @@ genDataPointerGet (operand * left, char buffer[256]; int size, offset = 0; - D(emitcode ("; genDataPointerGet","")); + D (emitcode (";", "genDataPointerGet")); aopOp (result, ic, TRUE); /* get the string representation of the name */ l = aopGet (left, 0, FALSE, TRUE); + l++; // remove # size = AOP_SIZE (result); while (size--) { if (offset) - sprintf (buffer, "(%s + %d)", l + 1, offset); + { + SNPRINTF (buffer, sizeof(buffer), "(%s + %d)", l, offset); + } else - sprintf (buffer, "%s", l + 1); - aopPut (result, buffer, offset++, isOperandVolatile (result, FALSE)); + { + SNPRINTF (buffer, sizeof(buffer), "%s", l); + } + aopPut (result, buffer, offset++); } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -9152,7 +9848,7 @@ genNearPointerGet (operand * left, sym_link *ltype = operandType (left); char buffer[80]; - D(emitcode ("; genNearPointerGet","")); + D (emitcode (";", "genNearPointerGet")); rtype = operandType (result); retype = getSpec (rtype); @@ -9224,12 +9920,12 @@ genNearPointerGet (operand * left, emitcode ("mov", "a,@%s", rname); if (!ifx) - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else { - sprintf (buffer, "@%s", rname); - aopPut (result, buffer, offset, isOperandVolatile (result, FALSE)); + SNPRINTF (buffer, sizeof(buffer), "@%s", rname); + aopPut (result, buffer, offset); } offset++; if (size || pi) @@ -9241,7 +9937,7 @@ genNearPointerGet (operand * left, if (aop) /* we had to allocate for this iCode */ { if (pi) { /* post increment present */ - aopPut (left, rname, 0, isOperandVolatile (left, FALSE)); + aopPut (left, rname, 0); } freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE); } @@ -9290,7 +9986,7 @@ genPagedPointerGet (operand * left, char *rname; sym_link *rtype, *retype; - D(emitcode ("; genPagedPointerGet","")); + D (emitcode (";", "genPagedPointerGet")); rtype = operandType (result); retype = getSpec (rtype); @@ -9328,7 +10024,7 @@ genPagedPointerGet (operand * left, emitcode ("movx", "a,@%s", rname); if (!ifx) - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); offset++; @@ -9340,7 +10036,8 @@ genPagedPointerGet (operand * left, /* now some housekeeping stuff */ if (aop) /* we had to allocate for this iCode */ { - if (pi) aopPut (left, rname, 0, isOperandVolatile (left, FALSE)); + if (pi) + aopPut (left, rname, 0); freeAsmop (NULL, aop, ic, TRUE); } else @@ -9368,10 +10065,9 @@ genPagedPointerGet (operand * left, } /* done */ - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); if (pi) pi->generated = 1; - } /*--------------------------------------------------------------------*/ @@ -9393,7 +10089,7 @@ loadDptrFromOperand (operand *op, bool loadBToo) 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: @@ -9435,7 +10131,7 @@ loadDptrFromOperand (operand *op, bool loadBToo) } /*-----------------------------------------------------------------*/ -/* genFarPointerGet - gget value from far space */ +/* genFarPointerGet - get value from far space */ /*-----------------------------------------------------------------*/ static void genFarPointerGet (operand * left, @@ -9444,7 +10140,7 @@ genFarPointerGet (operand * left, int size, offset; sym_link *retype = getSpec (operandType (result)); - D(emitcode ("; genFarPointerGet","")); + D (emitcode (";", "genFarPointerGet")); aopOp (left, ic, FALSE); loadDptrFromOperand (left, FALSE); @@ -9464,7 +10160,7 @@ genFarPointerGet (operand * left, { emitcode ("movx", "a,@dptr"); if (!ifx) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); if (size || pi) emitcode ("inc", "dptr"); } @@ -9472,22 +10168,22 @@ genFarPointerGet (operand * left, if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR) { - aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE)); - aopPut (left, "dph", 1, isOperandVolatile (left, FALSE)); - pi->generated = 1; - } + aopPut (left, "dpl", 0); + aopPut (left, "dph", 1); + pi->generated = 1; + } if (ifx && !ifx->generated) { genIfxJump (ifx, "a", left, NULL, result); } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ -/* genCodePointerGet - gget value from code space */ +/* genCodePointerGet - get value from code space */ /*-----------------------------------------------------------------*/ static void genCodePointerGet (operand * left, @@ -9496,7 +10192,7 @@ genCodePointerGet (operand * left, int size, offset; sym_link *retype = getSpec (operandType (result)); - D(emitcode ("; genCodePointerGet","")); + D (emitcode (";", "genCodePointerGet")); aopOp (left, ic, FALSE); loadDptrFromOperand (left, FALSE); @@ -9514,42 +10210,33 @@ genCodePointerGet (operand * left, while (size--) { - if (pi) - { - emitcode ("clr", "a"); - emitcode ("movc", "a,@a+dptr"); - if (!ifx) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); - emitcode ("inc", "dptr"); - } - else - { - emitcode ("mov", "a,#0x%02x", offset); - emitcode ("movc", "a,@a+dptr"); - if (!ifx) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); - } + emitcode ("clr", "a"); + emitcode ("movc", "a,@a+dptr"); + if (!ifx) + aopPut (result, "a", offset++); + if (size || pi) + emitcode ("inc", "dptr"); } } if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR) { - aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE)); - aopPut (left, "dph", 1, isOperandVolatile (left, FALSE)); - pi->generated = 1; - } + aopPut (left, "dpl", 0); + aopPut (left, "dph", 1); + pi->generated = 1; + } if (ifx && !ifx->generated) { genIfxJump (ifx, "a", left, NULL, result); } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ -/* genGenPointerGet - gget value from generic pointer space */ +/* genGenPointerGet - get value from generic pointer space */ /*-----------------------------------------------------------------*/ static void genGenPointerGet (operand * left, @@ -9558,17 +10245,19 @@ genGenPointerGet (operand * left, int size, offset; sym_link *retype = getSpec (operandType (result)); - D(emitcode ("; genGenPointerGet","")); + D (emitcode (";", "genGenPointerGet")); aopOp (left, ic, FALSE); loadDptrFromOperand (left, TRUE); - /* so dptr know contains the address */ + /* so dptr now contains the address */ aopOp (result, ic, FALSE); /* if bit then unpack */ if (IS_BITFIELD (retype)) - genUnpackBits (result, "dptr", GPOINTER, ifx); + { + genUnpackBits (result, "dptr", GPOINTER, ifx); + } else { size = AOP_SIZE (result); @@ -9578,7 +10267,7 @@ genGenPointerGet (operand * left, { emitcode ("lcall", "__gptrget"); if (!ifx) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); if (size || pi) emitcode ("inc", "dptr"); } @@ -9586,19 +10275,18 @@ genGenPointerGet (operand * left, if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR) { - aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE)); - aopPut (left, "dph", 1, isOperandVolatile (left, FALSE)); - pi->generated = 1; - } + aopPut (left, "dpl", 0); + aopPut (left, "dph", 1); + pi->generated = 1; + } if (ifx && !ifx->generated) { genIfxJump (ifx, "a", left, NULL, result); } - - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -9611,7 +10299,7 @@ genPointerGet (iCode * ic, iCode *pi, iCode *ifx) sym_link *type, *etype; int p_type; - D(emitcode ("; genPointerGet","")); + D (emitcode (";", "genPointerGet")); left = IC_LEFT (ic); result = IC_RESULT (ic); @@ -9634,11 +10322,12 @@ genPointerGet (iCode * ic, iCode *pi, iCode *ifx) /* special case when cast remat */ if (p_type == GPOINTER && OP_SYMBOL(left)->remat && - IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) { - left = IC_RIGHT(OP_SYMBOL(left)->rematiCode); - type = operandType (left); - p_type = DCL_TYPE (type); - } + IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) + { + left = IC_RIGHT(OP_SYMBOL(left)->rematiCode); + type = operandType (left); + p_type = DCL_TYPE (type); + } /* now that we have the pointer type we assign the pointer values */ switch (p_type) @@ -9665,11 +10354,9 @@ genPointerGet (iCode * ic, iCode *pi, iCode *ifx) genGenPointerGet (left, result, ic, pi, ifx); break; } - } - /*-----------------------------------------------------------------*/ /* genPackBits - generates code for packed bit storage */ /*-----------------------------------------------------------------*/ @@ -9685,7 +10372,7 @@ genPackBits (sym_link * etype, 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); @@ -9801,7 +10488,6 @@ genPackBits (sym_link * etype, } emitPtrByteSet (rname, p_type, "a"); } - } @@ -9816,24 +10502,25 @@ genDataPointerSet (operand * right, int size, offset = 0; char *l, buffer[256]; - D(emitcode ("; genDataPointerSet","")); + D (emitcode (";", "genDataPointerSet")); aopOp (right, ic, FALSE); l = aopGet (result, 0, FALSE, TRUE); + l++; //remove # size = AOP_SIZE (right); while (size--) { if (offset) - sprintf (buffer, "(%s + %d)", l + 1, offset); + SNPRINTF (buffer, sizeof(buffer), "(%s + %d)", l, offset); else - sprintf (buffer, "%s", l + 1); + SNPRINTF (buffer, sizeof(buffer), "%s", l); emitcode ("mov", "%s,%s", buffer, aopGet (right, offset++, FALSE, FALSE)); } - freeAsmop (right, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -9851,10 +10538,11 @@ genNearPointerSet (operand * right, sym_link *retype, *letype; sym_link *ptype = operandType (result); - D(emitcode ("; genNearPointerSet","")); + D (emitcode (";", "genNearPointerSet")); retype = getSpec (operandType (right)); letype = getSpec (ptype); + aopOp (result, ic, FALSE); /* if the result is rematerializable & @@ -9914,14 +10602,14 @@ genNearPointerSet (operand * right, genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, rname, POINTER); else { - /* we have can just get the values */ + /* we can just get the values */ int size = AOP_SIZE (right); int offset = 0; while (size--) { l = aopGet (right, offset, FALSE, TRUE); - if (*l == '@') + if ((*l == '@') || (strcmp (l, "acc") == 0)) { MOVA (l); emitcode ("mov", "@%s,a", rname); @@ -9938,7 +10626,7 @@ genNearPointerSet (operand * right, if (aop) /* we had to allocate for this iCode */ { if (pi) - aopPut (result, rname, 0, isOperandVolatile (result, FALSE)); + aopPut (result, rname, 0); freeAsmop (NULL, aop, ic, TRUE); } else @@ -9980,7 +10668,7 @@ genPagedPointerSet (operand * right, char *rname, *l; sym_link *retype, *letype; - D(emitcode ("; genPagedPointerSet","")); + D (emitcode (";", "genPagedPointerSet")); retype = getSpec (operandType (right)); letype = getSpec (operandType (result)); @@ -10016,7 +10704,6 @@ genPagedPointerSet (operand * right, while (size--) { l = aopGet (right, offset, FALSE, TRUE); - MOVA (l); emitcode ("movx", "@%s,a", rname); @@ -10031,7 +10718,7 @@ genPagedPointerSet (operand * right, if (aop) /* we had to allocate for this iCode */ { if (pi) - aopPut (result, rname, 0, isOperandVolatile (result, FALSE)); + aopPut (result, rname, 0); freeAsmop (NULL, aop, ic, TRUE); } else @@ -10056,8 +10743,6 @@ genPagedPointerSet (operand * right, if (pi) pi->generated = 1; freeAsmop (result, NULL, ic, TRUE); freeAsmop (right, NULL, ic, TRUE); - - } /*-----------------------------------------------------------------*/ @@ -10071,12 +10756,12 @@ genFarPointerSet (operand * right, 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); - /* so dptr know contains the address */ + /* so dptr now contains the address */ aopOp (right, ic, FALSE); /* if bit then unpack */ @@ -10097,8 +10782,8 @@ genFarPointerSet (operand * right, } } if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) { - aopPut (result, "dpl", 0, isOperandVolatile (result, FALSE)); - aopPut (result, "dph", 1, isOperandVolatile (result, FALSE)); + aopPut (result, "dpl", 0); + aopPut (result, "dph", 1); pi->generated=1; } freeAsmop (result, NULL, ic, TRUE); @@ -10116,17 +10801,19 @@ genGenPointerSet (operand * right, sym_link *retype = getSpec (operandType (right)); sym_link *letype = getSpec (operandType (result)); - D(emitcode ("; genGenPointerSet","")); + D (emitcode (";", "genGenPointerSet")); aopOp (result, ic, FALSE); loadDptrFromOperand (result, TRUE); - /* so dptr know contains the address */ + /* so dptr now contains the address */ aopOp (right, ic, FALSE); /* if bit then unpack */ if (IS_BITFIELD (retype) || IS_BITFIELD (letype)) - genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, "dptr", GPOINTER); + { + genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, "dptr", GPOINTER); + } else { size = AOP_SIZE (right); @@ -10143,8 +10830,8 @@ genGenPointerSet (operand * right, } if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) { - aopPut (result, "dpl", 0, isOperandVolatile (result, FALSE)); - aopPut (result, "dph", 1, isOperandVolatile (result, FALSE)); + aopPut (result, "dpl", 0); + aopPut (result, "dph", 1); pi->generated=1; } freeAsmop (result, NULL, ic, TRUE); @@ -10161,7 +10848,7 @@ genPointerSet (iCode * ic, iCode *pi) sym_link *type, *etype; int p_type; - D(emitcode ("; genPointerSet","")); + D (emitcode (";", "genPointerSet")); right = IC_RIGHT (ic); result = IC_RESULT (ic); @@ -10188,6 +10875,7 @@ genPointerSet (iCode * ic, iCode *pi) type = operandType (result); p_type = DCL_TYPE (type); } + /* now that we have the pointer type we assign the pointer values */ switch (p_type) @@ -10214,7 +10902,6 @@ genPointerSet (iCode * ic, iCode *pi) werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "genPointerSet: illegal pointer type"); } - } /*-----------------------------------------------------------------*/ @@ -10227,19 +10914,22 @@ genIfx (iCode * ic, iCode * popIc) int isbit = 0; char *dup = NULL; - D(emitcode ("; genIfx","")); + D (emitcode (";", "genIfx")); aopOp (cond, ic, FALSE); /* get the value into acc */ if (AOP_TYPE (cond) != AOP_CRY) - toBoolean (cond); + { + toBoolean (cond); + } else { isbit = 1; if (AOP(cond)->aopu.aop_dir) dup = Safe_strdup(AOP(cond)->aopu.aop_dir); } + /* the result is now in the accumulator or a directly addressable bit */ freeAsmop (cond, NULL, ic, TRUE); @@ -10269,7 +10959,7 @@ genAddrOf (iCode * ic) symbol *sym = OP_SYMBOL (IC_LEFT (ic)); int size, offset; - D(emitcode ("; genAddrOf","")); + D (emitcode (";", "genAddrOf")); aopOp (IC_RESULT (ic), ic, FALSE); @@ -10278,20 +10968,33 @@ genAddrOf (iCode * ic) variable */ if (sym->onStack) { - /* if it has an offset then we need to compute - it */ + /* if it has an offset then we need to compute it */ if (sym->stack) { - emitcode ("mov", "a,%s", SYM_BP (sym)); - emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ? - ((char) (sym->stack - _G.nRegsSaved)) : - ((char) sym->stack)) & 0xff); - aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE)); + int stack_offset = ((sym->stack < 0) ? + ((char) (sym->stack - _G.nRegsSaved)) : + ((char) sym->stack)) & 0xff; + if ((abs(stack_offset) == 1) && + !AOP_NEEDSACC(IC_RESULT (ic)) && + !isOperandVolatile (IC_RESULT (ic), FALSE)) + { + aopPut (IC_RESULT (ic), SYM_BP (sym), 0); + if (stack_offset > 0) + emitcode ("inc", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)); + else + emitcode ("dec", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)); + } + else + { + emitcode ("mov", "a,%s", SYM_BP (sym)); + emitcode ("add", "a,#0x%02x", stack_offset & 0xff); + aopPut (IC_RESULT (ic), "a", 0); + } } else { /* we can just move _bp */ - aopPut (IC_RESULT (ic), SYM_BP (sym), 0, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), SYM_BP (sym), 0); } /* fill the result with zero */ size = AOP_SIZE (IC_RESULT (ic)) - 1; @@ -10299,9 +11002,8 @@ genAddrOf (iCode * ic) offset = 1; while (size--) { - aopPut (IC_RESULT (ic), zero, offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), zero, offset++); } - goto release; } @@ -10317,8 +11019,8 @@ genAddrOf (iCode * ic) sym->rname, offset * 8); else - sprintf (s, "#%s", sym->rname); - aopPut (IC_RESULT (ic), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + SNPRINTF (s, sizeof(s), "#%s", sym->rname); + aopPut (IC_RESULT (ic), s, offset++); } release: @@ -10336,7 +11038,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic) int offset = 0; char *l; - D(emitcode ("; genFarFarAssign","")); + D (emitcode (";", "genFarFarAssign")); /* first push the right side on to the stack */ while (size--) @@ -10353,10 +11055,9 @@ genFarFarAssign (operand * result, operand * right, iCode * ic) while (size--) { emitcode ("pop", "acc"); - aopPut (result, "a", --offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", --offset); } freeAsmop (result, NULL, ic, FALSE); - } /*-----------------------------------------------------------------*/ @@ -10369,7 +11070,7 @@ genAssign (iCode * ic) int size, offset; unsigned long lit = 0L; - D(emitcode("; genAssign","")); + D (emitcode (";", "genAssign")); result = IC_RESULT (ic); right = IC_RIGHT (ic); @@ -10387,7 +11088,6 @@ genAssign (iCode * ic) IS_TRUE_SYMOP (result) && isOperandInFarSpace (result)) { - genFarFarAssign (result, right, ic); return; } @@ -10403,29 +11103,7 @@ genAssign (iCode * ic) /* 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, isOperandVolatile (result, FALSE)); - else - aopPut (result, zero, 0, isOperandVolatile (result, FALSE)); - 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, isOperandVolatile (result, FALSE)); - goto release; - } - - /* we need to or */ - toBoolean (right); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + assignBit (result, right); goto release; } @@ -10435,6 +11113,7 @@ genAssign (iCode * ic) offset = 0; if (AOP_TYPE (right) == AOP_LIT) lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + if ((size > 1) && (AOP_TYPE (result) != AOP_REG) && (AOP_TYPE (right) == AOP_LIT) && @@ -10445,16 +11124,19 @@ genAssign (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); lit >>= 8; offset++; size--; } - emitcode ("clr", "a"); + /* And now fill the rest with zeros. */ + if (size) + { + emitcode ("clr", "a"); + } while (size--) { - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); offset++; } } @@ -10464,15 +11146,14 @@ genAssign (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } } release: - freeAsmop (right, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -10485,7 +11166,7 @@ genJumpTab (iCode * ic) char *l; unsigned int count; - D(emitcode ("; genJumpTab","")); + D (emitcode (";", "genJumpTab")); count = elementsInSet( IC_JTLABELS (ic) ); @@ -10494,21 +11175,30 @@ genJumpTab (iCode * ic) /* this algorithm needs 9 cycles and 7 + 3*n bytes if the switch argument is in a register. (8 cycles and 6+2*n bytes if peepholes can change ljmp to sjmp) */ - /* (MB) What if peephole converts ljmp to sjmp or ret ??? - How will multiply by three be updated ???*/ + /* Peephole may not convert ljmp to sjmp or ret + labelIsReturnOnly & labelInRange must check + currPl->ic->op != JUMPTABLE */ aopOp (IC_JTCOND (ic), ic, FALSE); /* get the condition into accumulator */ l = aopGet (IC_JTCOND (ic), 0, FALSE, FALSE); MOVA (l); /* multiply by three */ - emitcode ("add", "a,acc"); - emitcode ("add", "a,%s", aopGet (IC_JTCOND (ic), 0, FALSE, FALSE)); + if (aopGetUsesAcc (IC_JTCOND (ic), 0)) + { + emitcode ("mov", "b,#3"); + emitcode ("mul", "ab"); + } + else + { + emitcode ("add", "a,acc"); + emitcode ("add", "a,%s", aopGet (IC_JTCOND (ic), 0, FALSE, FALSE)); + } freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE); jtab = newiTempLabel (NULL); emitcode ("mov", "dptr,#%05d$", jtab->key + 100); emitcode ("jmp", "@a+dptr"); - emitcode ("", "%05d$:", jtab->key + 100); + emitLabel (jtab); /* now generate the jump labels */ for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab; jtab = setNextItem (IC_JTLABELS (ic))) @@ -10564,13 +11254,13 @@ genJumpTab (iCode * ic) emitcode ("ret", ""); /* now generate jump table, LSB */ - emitcode ("", "%05d$:", jtablo->key + 100); + emitLabel (jtablo); for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab; jtab = setNextItem (IC_JTLABELS (ic))) emitcode (".db", "%05d$", jtab->key + 100); /* now generate jump table, MSB */ - emitcode ("", "%05d$:", jtabhi->key + 100); + emitLabel (jtabhi); for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab; jtab = setNextItem (IC_JTLABELS (ic))) emitcode (".db", "%05d$>>8", jtab->key + 100); @@ -10589,7 +11279,7 @@ genCast (iCode * ic) operand *right = IC_RIGHT (ic); int size, offset; - D(emitcode("; genCast","")); + D (emitcode (";", "genCast")); /* if they are equivalent then do nothing */ if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic))) @@ -10599,37 +11289,12 @@ genCast (iCode * ic) aopOp (result, ic, FALSE); /* if the result is a bit (and not a bitfield) */ - // if (AOP_TYPE (result) == AOP_CRY) - if (IS_BITVAR (OP_SYMBOL (result)->type) - && !IS_BITFIELD (OP_SYMBOL (result)->type) ) + 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, isOperandVolatile (result, FALSE)); - else - aopPut (result, zero, 0, isOperandVolatile (result, FALSE)); - - 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, isOperandVolatile (result, FALSE)); - goto release; - } - - /* we need to or */ - toBoolean (right); - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + assignBit (result, right); goto release; } - /* if they are the same size : or less */ if (AOP_SIZE (result) <= AOP_SIZE (right)) { @@ -10645,14 +11310,12 @@ genCast (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } goto release; } - /* if the result is of type pointer */ if (IS_PTR (ctype)) { @@ -10665,7 +11328,9 @@ genCast (iCode * ic) if (IS_GENPTR (ctype)) { if (IS_PTR (type)) - p_type = DCL_TYPE (type); + { + p_type = DCL_TYPE (type); + } else { if (SPEC_SCLS(etype)==S_REGISTER) { @@ -10684,8 +11349,7 @@ genCast (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } /* the last byte depending on type */ @@ -10700,7 +11364,7 @@ genCast (iCode * ic) } sprintf(gpValStr, "#0x%x", gpVal); - aopPut (result, gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE)); + aopPut (result, gpValStr, GPTRSIZE - 1); } goto release; } @@ -10712,8 +11376,7 @@ genCast (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } goto release; @@ -10728,8 +11391,7 @@ genCast (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } @@ -10739,7 +11401,7 @@ genCast (iCode * ic) if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE(right)==AOP_CRY) { while (size--) - aopPut (result, zero, offset++, isOperandVolatile (result, FALSE)); + aopPut (result, zero, offset++); } else { @@ -10750,15 +11412,14 @@ genCast (iCode * ic) emitcode ("rlc", "a"); emitcode ("subb", "a,acc"); while (size--) - aopPut (result, "a", offset++, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset++); } /* we are done hurray !!!! */ release: - freeAsmop (right, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); - + freeAsmop (right, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -10771,15 +11432,12 @@ genDjnz (iCode * ic, iCode * ifx) if (!ifx) return 0; - D(emitcode ("; genDjnz","")); - /* 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 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; @@ -10793,6 +11451,9 @@ genDjnz (iCode * ic, iCode * ifx) return 0; /* otherwise we can save BIG */ + + D (emitcode (";", "genDjnz")); + lbl = newiTempLabel (NULL); lbl1 = newiTempLabel (NULL); @@ -10818,7 +11479,7 @@ genDjnz (iCode * ic, iCode * ifx) return 0; } emitcode ("dec", "%s", rByte); - aopPut (IC_RESULT (ic), rByte, 0, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), rByte, 0); emitcode ("jnz", "%05d$", lbl->key + 100); } else if (IS_AOP_PREG (IC_RESULT (ic))) @@ -10826,6 +11487,8 @@ genDjnz (iCode * ic, iCode * ifx) emitcode ("dec", "%s", aopGet (IC_RESULT (ic), 0, FALSE, FALSE)); MOVA (aopGet (IC_RESULT (ic), 0, FALSE, FALSE)); + freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + ifx->generated = 1; emitcode ("jnz", "%05d$", lbl->key + 100); } else @@ -10834,11 +11497,12 @@ genDjnz (iCode * ic, iCode * ifx) lbl->key + 100); } emitcode ("sjmp", "%05d$", lbl1->key + 100); - emitcode ("", "%05d$:", lbl->key + 100); + emitLabel (lbl); emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100); - emitcode ("", "%05d$:", lbl1->key + 100); + emitLabel (lbl1); - freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); + if (!ifx->generated) + freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); ifx->generated = 1; return 1; } @@ -10852,11 +11516,12 @@ genReceive (iCode * ic) int size = getSize (operandType (IC_RESULT (ic))); int offset = 0; - D(emitcode ("; genReceive","")); + D (emitcode (";", "genReceive")); if (ic->argreg == 1) { /* first parameter */ - if (isOperandInFarSpace (IC_RESULT (ic)) && + if ((isOperandInFarSpace (IC_RESULT (ic)) || + isOperandInPagedSpace (IC_RESULT (ic))) && (OP_SYMBOL (IC_RESULT (ic))->isspilt || IS_TRUE_SYMOP (IC_RESULT (ic)))) { @@ -10878,11 +11543,9 @@ genReceive (iCode * ic) _G.accInUse++; aopOp (IC_RESULT (ic), ic, FALSE); _G.accInUse--; - aopPut (IC_RESULT (ic), "a", offset, - isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", offset); for (offset = 1; offsetname, offset, - isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset); goto release; } } @@ -10894,8 +11557,7 @@ genReceive (iCode * ic) emitcode("mov","%s,%s", tempRegs[offset]->name, fReturn[offset]); aopOp (IC_RESULT (ic), ic, FALSE); for (offset = 0; offsetname, offset, - isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset); goto release; } } @@ -10913,7 +11575,7 @@ genReceive (iCode * ic) while (size--) { emitcode ("pop", "acc"); - aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), "a", offset++); } } else @@ -10940,7 +11602,7 @@ genReceive (iCode * ic) rb1off = ic->argreg; while (size--) { - aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++, isOperandVolatile (IC_RESULT (ic), FALSE)); + aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++); } } @@ -10957,7 +11619,7 @@ genDummyRead (iCode * ic) operand *op; int size, offset; - D(emitcode("; genDummyRead","")); + D (emitcode(";", "genDummyRead")); op = IC_RIGHT (ic); if (op && IS_SYMOP (op)) @@ -11016,15 +11678,15 @@ genCritical (iCode *ic) { symbol *tlbl = newiTempLabel (NULL); - D(emitcode("; genCritical","")); + D (emitcode(";", "genCritical")); if (IC_RESULT (ic)) { aopOp (IC_RESULT (ic), ic, TRUE); - aopPut (IC_RESULT (ic), one, 0, 0); + aopPut (IC_RESULT (ic), one, 0); /* save old ea in an operand */ emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */ - aopPut (IC_RESULT (ic), zero, 0, 0); - emitcode ("", "%05d$:", (tlbl->key + 100)); + aopPut (IC_RESULT (ic), zero, 0); + emitLabel (tlbl); freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); } else @@ -11032,7 +11694,7 @@ genCritical (iCode *ic) emitcode ("setb", "c"); emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */ emitcode ("clr", "c"); - emitcode ("", "%05d$:", (tlbl->key + 100)); + emitLabel (tlbl); emitcode ("push", "psw"); /* save old ea via c in psw on top of stack*/ } } @@ -11043,7 +11705,7 @@ genCritical (iCode *ic) static void genEndCritical (iCode *ic) { - D(emitcode("; genEndCritical","")); + D(emitcode(";", "genEndCritical")); if (IC_RIGHT (ic)) { @@ -11084,7 +11746,7 @@ gen51Code (iCode * lic) /* print the allocation information */ if (allocInfo && currFunc) - printAllocInfo (currFunc, codeOutFile); + printAllocInfo (currFunc, codeOutBuf); /* if debug information required */ if (options.debug && currFunc) { @@ -11108,7 +11770,7 @@ gen51Code (iCode * lic) debugFile->writeCLine (ic); } if (!options.noCcodeInAsm) { - emitcode ("", ";%s:%d: %s", ic->filename, ic->lineno, + emitcode (";", "%s:%d: %s", ic->filename, ic->lineno, printCLine(ic->filename, ic->lineno)); } cln = ic->lineno; @@ -11116,20 +11778,33 @@ gen51Code (iCode * lic) #if 0 if (ic->seqPoint && ic->seqPoint != cseq) { - emitcode ("", "; sequence point %d", ic->seqPoint); + emitcode (";", "sequence point %d", ic->seqPoint); cseq = ic->seqPoint; } #endif if (options.iCodeInAsm) { char regsInUse[80]; int i; + char *iLine; + #if 0 for (i=0; i<8; i++) { sprintf (®sInUse[i], - "%c", ic->riu & (1<riu & (1<seq, printILine(ic)); + #else + strcpy (regsInUse, "--------"); + for (i=0; i < 8; i++) { + if (bitVectBitValue (ic->rMask, i)) + { + int offset = regs8051[i].offset; + regsInUse[offset] = offset + '0'; /* show rMask */ + } + #endif + } + iLine = printILine(ic); + emitcode(";", "[%s] ic:%d: %s", regsInUse, ic->seq, iLine); + dbuf_free(iLine); } /* if the result is marked as spilt and rematerializable or code for @@ -11234,7 +11909,7 @@ gen51Code (iCode * lic) case NE_OP: /* note these two are xlated by algebraic equivalence - during parsing SDCC.y */ + in decorateType() in SDCCast.c */ werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "got '>=' or '<=' shouldn't have come here"); break; @@ -11308,7 +11983,9 @@ gen51Code (iCode * lic) case '=': if (POINTER_SET (ic)) - genPointerSet (ic, hasInc (IC_RESULT(ic),ic,getSize(operandType(IC_RIGHT(ic))))); + genPointerSet (ic, + hasInc (IC_RESULT (ic), ic, + getSize (operandType (IC_RIGHT (ic))))); else genAssign (ic); break; @@ -11366,6 +12043,6 @@ gen51Code (iCode * lic) peepHole (&lineHead); /* now do the actual printing */ - printLine (lineHead, codeOutFile); + printLine (lineHead, codeOutBuf); return; }