X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fmcs51%2Fgen.c;h=9375087a431f1cae78da365a154314d34869efed;hb=b1a10c8ec5142594ec5698fa241d7433873ce710;hp=2dfdd90de4ebc44b3b7c2b966d1b154fe96dac7b;hpb=88d9c4b9337566e3403ed661bdb97ba3e61f1fc2;p=fw%2Fsdcc diff --git a/src/mcs51/gen.c b/src/mcs51/gen.c index 2dfdd90d..9375087a 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); @@ -472,6 +507,7 @@ newAsmop (short type) aop = Safe_calloc (1, sizeof (asmop)); aop->type = type; + aop->allocated = 1; return aop; } @@ -507,7 +543,7 @@ leftRightUseAcc(iCode *ic) if (ic->op == IFX) { op = IC_COND (ic); - if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse) + if (IS_OP_ACCUSE (op)) { accuse = 1; size = getSize (OP_SYMBOL (op)->type); @@ -518,7 +554,7 @@ leftRightUseAcc(iCode *ic) else if (ic->op == JUMPTABLE) { op = IC_JTCOND (ic); - if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse) + if (IS_OP_ACCUSE (op)) { accuse = 1; size = getSize (OP_SYMBOL (op)->type); @@ -529,7 +565,7 @@ leftRightUseAcc(iCode *ic) else { op = IC_LEFT (ic); - if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse) + if (IS_OP_ACCUSE (op)) { accuse = 1; size = getSize (OP_SYMBOL (op)->type); @@ -537,7 +573,7 @@ leftRightUseAcc(iCode *ic) accuseSize = size; } op = IC_RIGHT (ic); - if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse) + if (IS_OP_ACCUSE (op)) { accuse = 1; size = getSize (OP_SYMBOL (op)->type); @@ -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; } @@ -672,7 +712,7 @@ aopForSym (iCode * ic, symbol * sym, bool result) } /*-----------------------------------------------------------------*/ -/* aopForRemat - rematerialzes an object */ +/* aopForRemat - rematerializes an object */ /*-----------------------------------------------------------------*/ static asmop * aopForRemat (symbol * sym) @@ -688,33 +728,39 @@ aopForRemat (symbol * sym) val += (int) operandLitValue (IC_RIGHT (ic)); else if (ic->op == '-') val -= (int) operandLitValue (IC_RIGHT (ic)); - else if (IS_CAST_ICODE(ic)) { - sym_link *from_type = operandType(IC_RIGHT(ic)); - aop->aopu.aop_immd.from_cast_remat = 1; - ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode; - ptr_type = pointerTypeToGPByte (DCL_TYPE(from_type), NULL, NULL); - continue; - } else break; + else if (IS_CAST_ICODE(ic)) + { + sym_link *from_type = operandType(IC_RIGHT(ic)); + aop->aopu.aop_immd.from_cast_remat = 1; + ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode; + ptr_type = pointerTypeToGPByte (DCL_TYPE(from_type), NULL, NULL); + continue; + } + else break; ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode; } 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 +851,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 +893,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 +922,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 +956,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,16 +970,15 @@ aopOp (operand * op, iCode * ic, bool result) /* rematerialize it NOW */ if (sym->remat) { - sym->aop = op->aop = aop = - aopForRemat (sym); - aop->size = getSize (sym->type); + sym->aop = op->aop = aop = aopForRemat (sym); + aop->size = operandSize (op); return; } if (sym->accuse) { int i; - aop = op->aop = sym->aop = newAsmop (AOP_ACC); + sym->aop = op->aop = aop = newAsmop (AOP_ACC); aop->size = getSize (sym->type); for (i = 0; i < 2; i++) aop->aopu.aop_str[i] = accUse[i]; @@ -920,7 +989,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 +998,20 @@ 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); + 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; } @@ -965,7 +1041,7 @@ aopOp (operand * op, iCode * ic, bool result) /*-----------------------------------------------------------------*/ /* freeAsmop - free up the asmop given to an operand */ -/*----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ static void freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop) { @@ -979,13 +1055,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 +1087,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 +1133,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 +1174,7 @@ freeForBranchAsmop (operand * op) if (!aop) return; - if (aop->freed) + if (!aop->allocated) return; switch (aop->type) @@ -1206,14 +1282,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 +1323,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 +1357,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 +1413,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"); @@ -1398,11 +1488,12 @@ aopPutUsesAcc (operand * oper, const char *s, int offset) /* 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)) { @@ -1422,17 +1513,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: @@ -1448,11 +1554,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; @@ -1518,71 +1628,97 @@ 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; @@ -1630,7 +1766,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) @@ -1651,15 +1787,13 @@ reAdjustPreg (asmop * aop) } /*-----------------------------------------------------------------*/ -/* opIsGptr: returns non-zero if the passed operand is */ -/* a generic pointer type. */ +/* opIsGptr: returns non-zero if the passed operand is */ +/* a generic pointer type. */ /*-----------------------------------------------------------------*/ static int opIsGptr (operand * op) { - sym_link *type = operandType (op); - - if ((AOP_SIZE (op) == GPTRSIZE) && IS_GENPTR (type)) + if (op && IS_GENPTR (operandType (op)) && (AOP_SIZE (op) == GPTRSIZE)) { return 1; } @@ -1672,8 +1806,8 @@ opIsGptr (operand * op) static int getDataSize (operand * op) { - int size; - size = AOP_SIZE (op); + int size = AOP_SIZE (op); + if (size == GPTRSIZE) { sym_link *type = operandType (op); @@ -1698,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++); } } } @@ -1717,8 +1851,11 @@ outBitC (operand * result) { /* if the result is bit */ if (AOP_TYPE (result) == AOP_CRY) - aopPut (result, "c", 0, isOperandVolatile (result, FALSE)); - else + { + if (!IS_OP_RUONLY (result)) + aopPut (result, "c", 0); + } + else if (AOP_TYPE (result) != AOP_DUMMY) { emitcode ("clr", "a"); emitcode ("rlc", "a"); @@ -1762,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 */ @@ -1776,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); @@ -1792,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)); } @@ -1804,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)); } @@ -1860,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; } @@ -1871,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)); } /*-----------------------------------------------------------------*/ @@ -1890,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 */ @@ -1900,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); } /*-----------------------------------------------------------------*/ @@ -1920,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); @@ -1942,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)) @@ -1954,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); @@ -1963,7 +2172,7 @@ genUminus (iCode * ic) if (offset == 0) SETC; emitcode ("cpl", "a"); - emitcode ("addc", "a,#0"); + emitcode ("addc", "a,#0x00"); } else { @@ -1972,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 */ @@ -1982,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)); } /*-----------------------------------------------------------------*/ @@ -2017,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 @@ -2029,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); @@ -2050,30 +2270,19 @@ 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"); - emitcode ("add", "a,#%d", count); + emitcode ("add", "a,#0x%02x", count); emitcode ("mov", "%s,a", spname); for (i = 0; i < mcs51_nRegs; i++) { if (bitVectBitValue (rsave, i)) { - regs * reg = mcs51_regWithIdx (i); + regs * reg = REG_WITH_INDEX (i); if (i == R0_IDX) { emitcode ("pop", "acc"); @@ -2096,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); } } } @@ -2111,6 +2320,7 @@ saveRegisters (iCode * lic) } } } + freeBitVect (rsave); } /*-----------------------------------------------------------------*/ @@ -2129,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"); @@ -2149,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) @@ -2200,6 +2410,7 @@ unsaveRegisters (iCode * ic) } } } + freeBitVect (rsave); } @@ -2207,9 +2418,29 @@ unsaveRegisters (iCode * ic) /* pushSide - */ /*-----------------------------------------------------------------*/ static void -pushSide (operand * oper, int size) +pushSide (operand * oper, int size, iCode * ic) { int offset = 0; + int nPushed = _G.r0Pushed + _G.r1Pushed; + + aopOp (oper, ic, FALSE); + + if (nPushed != _G.r0Pushed + _G.r1Pushed) + { + while (offset < size) + { + char *l = aopGet (oper, offset, FALSE, TRUE); + emitcode ("mov", "%s,%s", fReturn[offset++], l); + } + freeAsmop (oper, NULL, ic, TRUE); + offset = 0; + while (offset < size) + { + emitcode ("push", "%s", fReturn[offset++]); + } + return; + } + while (size--) { char *l = aopGet (oper, offset++, FALSE, TRUE); @@ -2225,6 +2456,8 @@ pushSide (operand * oper, int size) emitcode ("push", "%s", l); } } + + freeAsmop (oper, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -2253,7 +2486,7 @@ assignResultValue (operand * oper, operand * func) { if ((offset == 3) && pushedA) emitcode ("pop", "acc"); - accuse |= aopPut (oper, fReturn[offset], offset, isOperandVolatile (oper, FALSE)); + accuse |= aopPut (oper, fReturn[offset], offset); offset++; } return accuse; @@ -2270,7 +2503,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); @@ -2289,7 +2522,7 @@ genXpush (iCode * ic) // allocate space first emitcode ("mov", "%s,%s", r->name, spname); MOVA (r->name); - emitcode ("add", "a,#%d", size); + emitcode ("add", "a,#0x%02x", size); emitcode ("mov", "%s,a", spname); while (size--) @@ -2314,7 +2547,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 */ @@ -2364,8 +2597,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); @@ -2389,7 +2621,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) @@ -2399,43 +2631,60 @@ 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); } /*-----------------------------------------------------------------*/ -/* saveRBank - saves an entire register bank on the stack */ +/* popForBranch - recover the spilt registers for a branch */ +/*-----------------------------------------------------------------*/ +static void +popForBranch (iCode * ic, bool markGenerated) +{ + while (ic && ic->op == IPOP) + { + genIpop (ic); + if (markGenerated) + ic->generated = 1; /* mark the icode as generated */ + ic = ic->next; + } +} + +/*-----------------------------------------------------------------*/ +/* saveRBank - saves an entire register bank on the stack */ /*-----------------------------------------------------------------*/ 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); - emitcode ("add", "a,#%d", count); + emitcode ("add", "a,#0x%02x", count); emitcode ("mov", "%s,a", spname); } - for (i = 0; i < mcs51_nRegs; i++) + for (i = 0; i < 8; i++) { if (options.useXstack) { @@ -2456,7 +2705,6 @@ saveRBank (int bank, iCode * ic, bool pushPsw) { emitcode ("mov", "a,psw"); emitcode ("movx", "@%s,a", r->name); - } else { @@ -2472,9 +2720,9 @@ saveRBank (int bank, iCode * ic, bool pushPsw) } if (ic) - { - ic->bankSaved = 1; - } + { + ic->bankSaved = 1; + } } /*-----------------------------------------------------------------*/ @@ -2492,7 +2740,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 { @@ -2516,7 +2764,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) { @@ -2555,12 +2803,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) @@ -2570,30 +2818,26 @@ 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) + if (options.useXstack || bit_count) { saveRegisters (setFirstItem (sendSet)); + } + + if (bit_count) + { emitcode ("mov", "bits,b"); } @@ -2601,30 +2845,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); } } @@ -2660,8 +2909,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); @@ -2673,7 +2923,6 @@ genCall (iCode * ic) } else { genSend(_G.sendSet); } - _G.sendSet = NULL; } @@ -2693,8 +2942,7 @@ genCall (iCode * ic) if (swapBanks) { - emitcode ("mov", "psw,#0x%02x", - ((FUNC_REGBANK(dtype)) << 3) & 0xff); + emitcode ("mov", "psw,#0x%02x", ((FUNC_REGBANK(dtype)) << 3) & 0xff); } /* make the call */ @@ -2742,6 +2990,7 @@ genCall (iCode * ic) _G.accInUse--; accuse = assignResultValue (IC_RESULT (ic), IC_LEFT (ic)); + assignResultGenerated = TRUE; freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); } @@ -2758,7 +3007,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; @@ -2797,7 +3047,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"); @@ -2812,7 +3062,7 @@ genCall (iCode * ic) } /*-----------------------------------------------------------------*/ -/* -10l - generates a call by pointer statement */ +/* genPcall - generates a call by pointer statement */ /*-----------------------------------------------------------------*/ static void genPcall (iCode * ic) @@ -2824,7 +3074,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); @@ -2835,7 +3085,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)) { @@ -2845,7 +3095,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) @@ -2857,12 +3107,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); } @@ -2883,9 +3133,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); } @@ -2895,6 +3145,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)); @@ -2919,14 +3170,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)); @@ -2934,14 +3185,10 @@ genPcall (iCode * ic) emitcode ("mov", "a,#(%05d$ >> 8)", (rlbl->key + 100)); emitcode ("push", "acc"); - /* now push the calling address */ - aopOp (IC_LEFT (ic), ic, FALSE); - - pushSide (IC_LEFT (ic), FPTRSIZE); + /* now push the function address */ + pushSide (IC_LEFT (ic), FPTRSIZE, ic); - freeAsmop (IC_LEFT (ic), NULL, ic, TRUE); - - /* if send set is not empty the assign */ + /* if send set is not empty then assign */ if (_G.sendSet) { genSend(reverseSet(_G.sendSet)); @@ -2951,17 +3198,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 */ @@ -3001,7 +3280,6 @@ genPcall (iCode * ic) else for (i = 0; i < ic->parmBytes; i++) emitcode ("dec", "%s", spname); - } // /* if register bank was saved then unsave them */ @@ -3009,7 +3287,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)))) @@ -3042,12 +3320,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 */ /*-----------------------------------------------------------------*/ @@ -3091,6 +3363,7 @@ genFunction (iCode * ic) emitcode (";", "-----------------------------------------"); emitcode ("", "%s:", sym->rname); + lineCurr->isLabel = 1; ftype = operandType (IC_LEFT (ic)); _G.currentFunc = sym; @@ -3128,6 +3401,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"); @@ -3142,42 +3424,40 @@ 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]); + saveRBank (0, ic, FALSE); + if (options.parms_in_bank1) + { + for (i=0; i < 8 ; i++ ) + { + emitcode ("push","%s",rb1regs[i]); } } } } - else + else { /* This ISR uses a non-zero bank. * @@ -3307,7 +3587,6 @@ genFunction (iCode * ic) } } - if (fReentrant) { if (options.useXstack) @@ -3363,7 +3642,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")) @@ -3388,7 +3667,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]); @@ -3424,11 +3703,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 */ @@ -3457,14 +3736,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"); } @@ -3482,7 +3761,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 */ } } @@ -3546,7 +3825,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"); } } @@ -3554,7 +3834,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 @@ -3566,6 +3846,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 @@ -3573,40 +3854,39 @@ 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-- ) { + if (options.parms_in_bank1) + { + 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); } } - else + else { /* This ISR uses a non-zero bank. * @@ -3642,6 +3922,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) { @@ -3664,13 +3949,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); } } @@ -3779,7 +4064,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); @@ -3794,7 +4079,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" */ @@ -3806,41 +4091,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: @@ -3863,7 +4147,7 @@ genLabel (iCode * ic) if (IC_LABEL (ic) == entryLabel) return; - emitcode ("", "%05d$:", (IC_LABEL (ic)->key + 100)); + emitLabel (IC_LABEL (ic)); } /*-----------------------------------------------------------------*/ @@ -3922,12 +4206,14 @@ genPlusIncr (iCode * ic) if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT) return FALSE; - icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); + icount = (unsigned int) ulFromVal (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) && @@ -3936,6 +4222,7 @@ genPlusIncr (iCode * ic) symbol *tlbl; int emitTlbl; int labelRange; + char *l; /* If the next instruction is a goto and the goto target * is < 10 instructions previous to this, we can generate @@ -3945,7 +4232,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; } @@ -3954,54 +4241,63 @@ genPlusIncr (iCode * ic) tlbl = newiTempLabel (NULL); emitTlbl = 1; } - emitcode ("inc", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)); + l = aopGet (IC_RESULT (ic), LSB, FALSE, FALSE); + emitcode ("inc", "%s", l); if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || IS_AOP_PREG (IC_RESULT (ic))) - emitcode ("cjne", "%s,#0x00,%05d$", - aopGet (IC_RESULT (ic), LSB, FALSE, FALSE), - tlbl->key + 100); + { + emitcode ("cjne", "%s,#0x00,%05d$", l, tlbl->key + 100); + } else { emitcode ("clr", "a"); - emitcode ("cjne", "a,%s,%05d$", - aopGet (IC_RESULT (ic), LSB, FALSE, FALSE), - tlbl->key + 100); + emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100); } - emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE)); + l = aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE); + emitcode ("inc", "%s", l); if (size > 2) { - if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || - IS_AOP_PREG (IC_RESULT (ic))) - emitcode ("cjne", "%s,#0x00,%05d$", - aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE), - tlbl->key + 100); + if (!strcmp(l, "acc")) + { + emitcode("jnz", "!tlabel", tlbl->key + 100); + } + else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || + IS_AOP_PREG (IC_RESULT (ic))) + { + emitcode ("cjne", "%s,#0x00,%05d$", l, tlbl->key + 100); + } else - emitcode ("cjne", "a,%s,%05d$", - aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE), - tlbl->key + 100); + { + emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100); + } - emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE)); + l = aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE); + emitcode ("inc", "%s", l); } if (size > 3) { - if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || - IS_AOP_PREG (IC_RESULT (ic))) - emitcode ("cjne", "%s,#0x00,%05d$", - aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE), - tlbl->key + 100); + if (!strcmp(l, "acc")) + { + emitcode("jnz", "!tlabel", tlbl->key + 100); + } + else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || + IS_AOP_PREG (IC_RESULT (ic))) + { + emitcode ("cjne", "%s,#0x00,%05d$", l, tlbl->key + 100); + } else { - emitcode ("cjne", "a,%s,%05d$", - aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE), - tlbl->key + 100); + emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100); } - emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE)); + + l = aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE); + emitcode ("inc", "%s", l); } if (emitTlbl) { - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } return TRUE; } @@ -4021,8 +4317,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"); @@ -4044,23 +4340,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; } @@ -4074,13 +4378,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); } } @@ -4091,24 +4395,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)); } } @@ -4127,16 +4430,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 && @@ -4146,7 +4447,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 @@ -4157,35 +4458,58 @@ adjustArithmeticResult (iCode * ic) static void adjustArithmeticResult (iCode * ic) { - if (opIsGptr (IC_RESULT (ic)) && - opIsGptr (IC_LEFT (ic)) && - !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)))) + if (opIsGptr (IC_RESULT (ic))) { - aopPut (IC_RESULT (ic), - aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE), - GPTRSIZE - 1, - isOperandVolatile (IC_RESULT (ic), FALSE)); - } + char buffer[10]; - if (opIsGptr (IC_RESULT (ic)) && - opIsGptr (IC_RIGHT (ic)) && - !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic)))) - { - aopPut (IC_RESULT (ic), - aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE), - GPTRSIZE - 1, - isOperandVolatile (IC_RESULT (ic), FALSE)); - } + if (opIsGptr (IC_LEFT (ic))) + { + if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)))) + { + aopPut (IC_RESULT (ic), + aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE), + GPTRSIZE - 1); + } + return; + } - if (opIsGptr (IC_RESULT (ic)) && - AOP_SIZE (IC_LEFT (ic)) < GPTRSIZE && - AOP_SIZE (IC_RIGHT (ic)) < GPTRSIZE && - !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (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)); + if (opIsGptr (IC_RIGHT (ic))) + { + if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic)))) + { + aopPut (IC_RESULT (ic), + aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE), + GPTRSIZE - 1); + } + return; + } + + if (IC_LEFT (ic) && AOP_SIZE (IC_LEFT (ic)) < GPTRSIZE && + IC_RIGHT (ic) && AOP_SIZE (IC_RIGHT (ic)) < GPTRSIZE && + !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))) && + !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic)))) + { + SNPRINTF (buffer, sizeof(buffer), + "#0x%02x", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL)); + aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1); + return; + } + if (IC_LEFT (ic) && AOP_SIZE (IC_LEFT (ic)) < GPTRSIZE && + !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic)))) + { + SNPRINTF (buffer, sizeof(buffer), + "#0x%02x", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL)); + aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1); + return; + } + if (IC_RIGHT (ic) && AOP_SIZE (IC_RIGHT (ic)) < GPTRSIZE && + !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic)))) + { + SNPRINTF (buffer, sizeof(buffer), + "#0x%02x", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_RIGHT (ic)))), NULL, NULL)); + aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1); + return; + } } } #endif @@ -4199,12 +4523,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); @@ -4220,6 +4545,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 @@ -4239,7 +4565,7 @@ genPlus (iCode * ic) /* if result in bit space */ if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY) { - if ((unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) != 0L) + if (ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) != 0L) emitcode ("cpl", "c"); outBitC (IC_RESULT (ic)); } @@ -4249,8 +4575,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; @@ -4264,7 +4590,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 */ @@ -4276,24 +4602,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; } @@ -4301,13 +4625,13 @@ genPlus (iCode * ic) /* if the lower bytes of a literal are zero skip the addition */ if (AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT ) { - while ((0 == ((unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) & (0xff << skip_bytes*8))) && + while ((0 == ((unsigned int) ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) & (0xff << skip_bytes*8))) && (skip_bytes+1 < size)) { skip_bytes++; } if (skip_bytes) - D(emitcode ("; genPlus shortcut","")); + D(emitcode (";", "genPlus shortcut")); } while (size--) @@ -4334,7 +4658,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 @@ -4345,8 +4669,7 @@ genPlus (iCode * ic) /* just move */ aopPut (IC_RESULT (ic), aopGet (leftOp, offset, FALSE, FALSE), - offset, - isOperandVolatile (IC_RESULT (ic), FALSE)); + offset); } } offset++; @@ -4355,9 +4678,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)); + } } /*-----------------------------------------------------------------*/ @@ -4377,20 +4708,23 @@ genMinusDec (iCode * ic) /* if the literal value of the right hand side is greater than 4 then it is not worth it */ - if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4) + if ((icount = (unsigned int) ulFromVal (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)) { symbol *tlbl; - int emitTlbl; - int labelRange; + int emitTlbl; + int labelRange; + char *l; /* If the next instruction is a goto and the goto target * is <= 10 instructions previous to this, we can generate @@ -4400,7 +4734,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; } @@ -4410,53 +4744,60 @@ genMinusDec (iCode * ic) emitTlbl = 1; } - emitcode ("dec", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)); + l = aopGet (IC_RESULT (ic), LSB, FALSE, FALSE); + emitcode ("dec", "%s", l); + if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || IS_AOP_PREG (IC_RESULT (ic))) - emitcode ("cjne", "%s,#0xff,%05d$" - ,aopGet (IC_RESULT (ic), LSB, FALSE, FALSE) - ,tlbl->key + 100); + { + emitcode ("cjne", "%s,#0xff,%05d$", l, tlbl->key + 100); + } else { emitcode ("mov", "a,#0xff"); - emitcode ("cjne", "a,%s,%05d$" - ,aopGet (IC_RESULT (ic), LSB, FALSE, FALSE) - ,tlbl->key + 100); + emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100); } - emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE)); + l = aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE); + emitcode ("dec", "%s", l); if (size > 2) { - if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || - IS_AOP_PREG (IC_RESULT (ic))) - emitcode ("cjne", "%s,#0xff,%05d$" - ,aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE) - ,tlbl->key + 100); + if (!strcmp(l, "acc")) + { + emitcode("jnz", "!tlabel", tlbl->key + 100); + } + else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || + IS_AOP_PREG (IC_RESULT (ic))) + { + emitcode ("cjne", "%s,#0xff,%05d$", l, tlbl->key + 100); + } else { - emitcode ("cjne", "a,%s,%05d$" - ,aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE) - ,tlbl->key + 100); + emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100); } - emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE)); + l = aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE); + emitcode ("dec", "%s", l); } if (size > 3) { - if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || - IS_AOP_PREG (IC_RESULT (ic))) - emitcode ("cjne", "%s,#0xff,%05d$" - ,aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE) - ,tlbl->key + 100); + if (!strcmp(l, "acc")) + { + emitcode("jnz", "!tlabel", tlbl->key + 100); + } + else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG || + IS_AOP_PREG (IC_RESULT (ic))) + { + emitcode ("cjne", "%s,#0xff,%05d$", l, tlbl->key + 100); + } else { - emitcode ("cjne", "a,%s,%05d$" - ,aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE) - ,tlbl->key + 100); + emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100); } - emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE)); + l = aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE); + emitcode ("dec", "%s", l); } if (emitTlbl) { - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } return TRUE; } @@ -4471,16 +4812,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, isOperandVolatile (IC_RESULT (ic), FALSE)); + 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; } @@ -4498,11 +4860,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++); + } + } } } @@ -4514,14 +4882,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 @@ -4530,8 +4898,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))))); } } @@ -4544,7 +4912,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); @@ -4572,14 +4940,14 @@ genMinus (iCode * ic) unsigned long lit = 0L; bool useCarry = FALSE; - lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); + lit = ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); lit = -(long) lit; while (size--) { 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"); @@ -4596,7 +4964,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 { @@ -4604,7 +4972,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++; } @@ -4635,7 +5003,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)); @@ -4652,17 +5020,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)); } @@ -4674,7 +5041,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); @@ -4694,7 +5061,7 @@ genMultOneByte (operand * left, bool runtimeSign, compiletimeSign; bool lUnsigned, rUnsigned, pushedB; - D(emitcode ("; genMultOneByte","")); + D (emitcode (";", "genMultOneByte")); if (size < 1 || size > 2) { @@ -4740,7 +5107,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 { @@ -4749,9 +5116,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; @@ -4773,7 +5140,7 @@ genMultOneByte (operand * left, if (AOP_TYPE(left) == AOP_LIT) { /* signed literal */ - signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit); if (val < 0) compiletimeSign = TRUE; } @@ -4787,7 +5154,7 @@ genMultOneByte (operand * left, if (AOP_TYPE(right) == AOP_LIT) { /* signed literal */ - signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (right)->aopu.aop_lit); if (val < 0) compiletimeSign ^= TRUE; } @@ -4808,7 +5175,7 @@ genMultOneByte (operand * left, /* save the signs of the operands */ if (AOP_TYPE(right) == AOP_LIT) { - signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (right)->aopu.aop_lit); if (!rUnsigned && val < 0) emitcode ("mov", "b,#0x%02x", -val); @@ -4818,7 +5185,6 @@ genMultOneByte (operand * left, else /* ! literal */ { if (rUnsigned) /* emitcode (";", "signed"); */ - emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE)); else { @@ -4828,14 +5194,14 @@ 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"); } } if (AOP_TYPE(left) == AOP_LIT) { - signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit); if (!lUnsigned && val < 0) emitcode ("mov", "a,#0x%02x", -val); @@ -4851,9 +5217,9 @@ genMultOneByte (operand * left, lbl = newiTempLabel (NULL); emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100)); emitcode ("cpl", "F0"); /* complement sign flag */ - emitcode ("cpl", "a"); /* 2's complement */ + emitcode ("cpl", "a"); /* 2's complement */ emitcode ("inc", "a"); - emitcode ("", "%05d$:", (lbl->key + 100)); + emitLabel (lbl); } } @@ -4869,17 +5235,17 @@ genMultOneByte (operand * left, emitcode ("inc", "a"); /* inc doesn't set carry flag */ else { - emitcode ("add", "a,#1"); /* this sets carry flag */ + emitcode ("add", "a,#0x01"); /* this sets carry flag */ emitcode ("xch", "a,b"); emitcode ("cpl", "a"); /* msb 2's complement */ - emitcode ("addc", "a,#0"); + emitcode ("addc", "a,#0x00"); 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); } @@ -4894,7 +5260,7 @@ genMult (iCode * ic) operand *right = IC_RIGHT (ic); operand *result = IC_RESULT (ic); - D(emitcode ("; genMult","")); + D (emitcode (";", "genMult")); /* assign the asmops */ aopOp (left, ic, FALSE); @@ -4944,7 +5310,7 @@ genDivbits (operand * left, char *l; bool pushedB; - D(emitcode ("; genDivbits","")); + D(emitcode (";", "genDivbits")); pushedB = pushB (); @@ -4959,7 +5325,7 @@ genDivbits (operand * left, popB (pushedB); - aopPut (result, "c", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "c", 0); } /*-----------------------------------------------------------------*/ @@ -4977,7 +5343,7 @@ genDivOneByte (operand * left, 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: @@ -5016,12 +5382,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; @@ -5042,7 +5408,7 @@ genDivOneByte (operand * left, if (AOP_TYPE(left) == AOP_LIT) { /* signed literal */ - signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit); if (val < 0) compiletimeSign = TRUE; } @@ -5056,7 +5422,7 @@ genDivOneByte (operand * left, if (AOP_TYPE(right) == AOP_LIT) { /* signed literal */ - signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (right)->aopu.aop_lit); if (val < 0) compiletimeSign ^= TRUE; } @@ -5077,7 +5443,7 @@ genDivOneByte (operand * left, /* save the signs of the operands */ if (AOP_TYPE(right) == AOP_LIT) { - signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (right)->aopu.aop_lit); if (!rUnsigned && val < 0) emitcode ("mov", "b,#0x%02x", -val); @@ -5096,14 +5462,14 @@ 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"); } } if (AOP_TYPE(left) == AOP_LIT) { - signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit); if (!lUnsigned && val < 0) emitcode ("mov", "a,#0x%02x", -val); @@ -5121,7 +5487,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); } } @@ -5135,9 +5501,9 @@ 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); - accuse = aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + accuse = aopPut (result, "a", 0); if (size > 0) { /* msb is 0x00 or 0xff depending on the sign */ @@ -5151,25 +5517,25 @@ genDivOneByte (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 */ { - if (aopPutUsesAcc (result, "#0xFF", offset)) + if (aopPutUsesAcc (result, "#0xff", offset)) { emitcode ("push", "acc"); pushedA = TRUE; } while (size--) - aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE)); + 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) @@ -5187,9 +5553,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); @@ -5214,9 +5580,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); } /*-----------------------------------------------------------------*/ @@ -5230,7 +5596,7 @@ genModbits (operand * left, char *l; bool pushedB; - D(emitcode ("; genModbits","")); + D (emitcode (";", "genModbits")); pushedB = pushB (); @@ -5246,7 +5612,7 @@ genModbits (operand * left, popB (pushedB); - aopPut (result, "c", 0, isOperandVolatile (result, FALSE)); + aopPut (result, "c", 0); } /*-----------------------------------------------------------------*/ @@ -5262,7 +5628,7 @@ genModOneByte (operand * left, symbol *lbl; int size, offset; - D(emitcode ("; genModOneByte","")); + D (emitcode (";", "genModOneByte")); size = AOP_SIZE (result) - 1; offset = 1; @@ -5303,19 +5669,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; @@ -5330,12 +5696,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; @@ -5366,7 +5732,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"); } } @@ -5380,7 +5746,7 @@ genModOneByte (operand * left, /* sign adjust left side */ if (AOP_TYPE(left) == AOP_LIT) { - signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit); + signed char val = (char) ulFromVal (AOP (left)->aopu.aop_lit); if (!lUnsigned && val < 0) { @@ -5404,7 +5770,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); } } @@ -5419,29 +5785,29 @@ 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 */ if (runtimeSign) { - emitcode ("mov", "c,F0"); + 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); @@ -5457,7 +5823,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); @@ -5485,22 +5851,25 @@ 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); } /*-----------------------------------------------------------------*/ /* genIfxJump :- will create a jump depending on the ifx */ /*-----------------------------------------------------------------*/ static void -genIfxJump (iCode * ic, char *jval, operand *left, operand *right, operand *result) +genIfxJump (iCode * ic, char *jval, operand *left, operand *right, operand *result, iCode *popIc) { symbol *jlbl; symbol *tlbl = newiTempLabel (NULL); char *inst; - D(emitcode ("; genIfxJump","")); + /* if there is something to be popped then do it first */ + popForBranch (popIc, TRUE); + + D (emitcode (";", "genIfxJump")); /* if true label then we jump if condition supplied is true */ @@ -5525,7 +5894,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; @@ -5542,7 +5911,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 && @@ -5567,13 +5936,13 @@ 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 { if (AOP_TYPE (right) == AOP_LIT) { - lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + lit = ulFromVal (AOP (right)->aopu.aop_lit); /* optimize if(x < 0) or if(x >= 0) */ if (lit == 0L) { @@ -5586,14 +5955,43 @@ genCmp (operand * left, operand * right, MOVA (aopGet (left, AOP_SIZE (left) - 1, FALSE, FALSE)); if (!(AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) && ifx) { - genIfxJump (ifx, "acc.7", left, right, result); + genIfxJump (ifx, "acc.7", left, right, result, ic->next); freeAsmop (right, NULL, ic, TRUE); freeAsmop (left, NULL, ic, TRUE); return; } else - emitcode ("rlc", "a"); + { + 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; } @@ -5612,24 +6010,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 { @@ -5658,9 +6046,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, ic->next); + } else - outBitC (result); + { + outBitC (result); + } /* leave the result in acc */ } } @@ -5675,7 +6067,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); @@ -5685,10 +6077,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); @@ -5705,7 +6097,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); @@ -5715,10 +6107,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); @@ -5735,11 +6127,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; @@ -5748,7 +6143,7 @@ gencjneshort (operand * left, operand * right, symbol * lbl) } if (AOP_TYPE (right) == AOP_LIT) - lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + lit = ulFromVal (AOP (right)->aopu.aop_lit); /* if the right side is a literal then anything goes */ if (AOP_TYPE (right) == AOP_LIT && @@ -5792,12 +6187,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++; @@ -5809,17 +6201,25 @@ gencjneshort (operand * left, operand * right, symbol * lbl) /* gencjne - compare and jump if not equal */ /*-----------------------------------------------------------------*/ static void -gencjne (operand * left, operand * right, symbol * lbl) +gencjne (operand * left, operand * right, symbol * lbl, bool useCarry) { symbol *tlbl = newiTempLabel (NULL); + D (emitcode (";", "gencjne")); + gencjneshort (left, right, lbl); - emitcode ("mov", "a,%s", one); + if (useCarry) + SETC; + else + MOVA (one); emitcode ("sjmp", "%05d$", tlbl->key + 100); - emitcode ("", "%05d$:", lbl->key + 100); - emitcode ("clr", "a"); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (lbl); + if (useCarry) + CLRC; + else + MOVA (zero); + emitLabel (tlbl); } /*-----------------------------------------------------------------*/ @@ -5828,9 +6228,11 @@ gencjne (operand * left, operand * right, symbol * lbl) static void genCmpEq (iCode * ic, iCode * ifx) { + bool swappedLR = FALSE; operand *left, *right, *result; + iCode * popIc = ic->next; - D(emitcode ("; genCmpEq","")); + D (emitcode (";", "genCmpEq")); aopOp ((left = IC_LEFT (ic)), ic, FALSE); aopOp ((right = IC_RIGHT (ic)), ic, FALSE); @@ -5845,6 +6247,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)) @@ -5856,7 +6259,7 @@ genCmpEq (iCode * ic, iCode * ifx) { if (AOP_TYPE (right) == AOP_LIT) { - unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); + unsigned long lit = ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); if (lit == 0L) { emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir); @@ -5878,7 +6281,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 */ @@ -5889,6 +6292,7 @@ genCmpEq (iCode * ic, iCode * ifx) freeForBranchAsmop (result); freeForBranchAsmop (right); freeForBranchAsmop (left); + popForBranch (popIc, FALSE); emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100); } else @@ -5897,9 +6301,10 @@ genCmpEq (iCode * ic, iCode * ifx) freeForBranchAsmop (result); freeForBranchAsmop (right); freeForBranchAsmop (left); + popForBranch (popIc, FALSE); emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100); } - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } else { @@ -5910,19 +6315,21 @@ genCmpEq (iCode * ic, iCode * ifx) freeForBranchAsmop (result); freeForBranchAsmop (right); freeForBranchAsmop (left); + popForBranch (popIc, FALSE); 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); + popForBranch (popIc, FALSE); emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100); - emitcode ("", "%05d$:", lbl->key + 100); + emitLabel (lbl); } } /* mark the icode as generated */ @@ -5936,7 +6343,7 @@ genCmpEq (iCode * ic, iCode * ifx) { if (AOP_TYPE (right) == AOP_LIT) { - unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); + unsigned long lit = ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); if (lit == 0L) { emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir); @@ -5958,7 +6365,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)) @@ -5968,7 +6375,7 @@ genCmpEq (iCode * ic, iCode * ifx) } if (ifx) { - genIfxJump (ifx, "c", left, right, result); + genIfxJump (ifx, "c", left, right, result, popIc); goto release; } /* if the result is used in an arithmetic operation @@ -5977,15 +6384,16 @@ genCmpEq (iCode * ic, iCode * ifx) } else { - gencjne (left, right, newiTempLabel (NULL)); if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) { - aopPut (result, "a", 0, isOperandVolatile (result, FALSE)); + gencjne (left, right, newiTempLabel (NULL), TRUE); + aopPut (result, "c", 0); goto release; } + gencjne (left, right, newiTempLabel (NULL), FALSE); if (ifx) { - genIfxJump (ifx, "a", left, right, result); + genIfxJump (ifx, "a", left, right, result, popIc); goto release; } /* if the result is used in an arithmetic operation @@ -5996,9 +6404,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)); + } } /*-----------------------------------------------------------------*/ @@ -6007,18 +6423,21 @@ release: static iCode * ifxForOp (operand * op, iCode * ic) { + iCode *ifxIc; + /* if true symbol then needs to be assigned */ if (IS_TRUE_SYMOP (op)) return NULL; /* if this has register type condition and + while skipping ipop's (see bug 1509084), the next instruction is ifx with the same operand and live to of the operand is upto the ifx only then */ - if (ic->next && - ic->next->op == IFX && - IC_COND (ic->next)->key == op->key && - OP_SYMBOL (op)->liveTo <= ic->next->seq) - return ic->next; + for (ifxIc = ic->next; ifxIc && ifxIc->op == IPOP; ifxIc = ifxIc->next); + if (ifxIc && ifxIc->op == IFX && + IC_COND (ifxIc)->key == op->key && + OP_SYMBOL (op)->liveTo <= ifxIc->seq) + return ifxIc; return NULL; } @@ -6027,7 +6446,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); @@ -6041,22 +6460,25 @@ hasInc (operand *op, iCode *ic,int osize) if (IS_AGGREGATE(type->next)) return NULL; if (osize != (isize = getSize(type->next))) return NULL; - while (lic) { - /* if operand of the form op = op + */ - if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) && - isOperandEqual(IC_RESULT(lic),op) && - isOperandLiteral(IC_RIGHT(lic)) && - operandLitValue(IC_RIGHT(lic)) == isize) { - return lic; - } - /* if the operand used or deffed */ - if (bitVectBitValue(OP_USES(op),lic->key) || lic->defKey == op->key) { - return NULL; + while (lic) + { + /* if operand of the form op = op + */ + if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) && + isOperandEqual(IC_RESULT(lic),op) && + isOperandLiteral(IC_RIGHT(lic)) && + operandLitValue(IC_RIGHT(lic)) == isize) + { + return lic; + } + /* if the operand used or deffed */ + if (bitVectBitValue(OP_USES(op),lic->key) || lic->defKey == op->key) + { + return NULL; + } + /* if GOTO or IFX */ + if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break; + lic = lic->next; } - /* if GOTO or IFX */ - if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break; - lic = lic->next; - } return NULL; } @@ -6069,7 +6491,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 @@ -6092,13 +6514,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); } @@ -6111,7 +6533,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 @@ -6134,13 +6556,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); } /*-----------------------------------------------------------------*/ @@ -6198,12 +6620,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 { @@ -6211,7 +6633,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; } @@ -6228,17 +6650,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 @@ -6269,7 +6691,7 @@ genAnd (iCode * ic, iCode * ifx) left = tmp; } if (AOP_TYPE (right) == AOP_LIT) - lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + lit = ulFromVal (AOP (right)->aopu.aop_lit); size = AOP_SIZE (result); @@ -6308,8 +6730,15 @@ genAnd (iCode * ic, iCode * ifx) if (AOP_TYPE (right) == AOP_CRY) { // c = bit & bit; - emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir); - emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir); + if (IS_OP_ACCUSE (left)) + { + emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir); + } + else + { + emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir); + emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir); + } } else { @@ -6326,7 +6755,7 @@ genAnd (iCode * ic, iCode * ifx) outBitC (result); // if(bit & ...) else if ((AOP_TYPE (result) == AOP_CRY) && ifx) - genIfxJump (ifx, "c", left, right, result); + genIfxJump (ifx, "c", left, right, result, ic->next); goto release; } @@ -6362,11 +6791,11 @@ genAnd (iCode * ic, iCode * ifx) { SNPRINTF (buffer, sizeof(buffer), "acc.%d", posbit & 0x07); - genIfxJump (ifx, buffer, left, right, result); + genIfxJump (ifx, buffer, left, right, result, ic->next); } 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; } @@ -6399,7 +6828,7 @@ genAnd (iCode * ic, iCode * ifx) if (size) { emitcode ("clr", "c"); - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } // if(left & literal) else @@ -6407,7 +6836,7 @@ genAnd (iCode * ic, iCode * ifx) if (ifx) jmpTrueOrFalse (ifx, tlbl, left, right, result); else - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); goto release; } } @@ -6433,13 +6862,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", @@ -6456,16 +6885,16 @@ genAnd (iCode * ic, iCode * ifx) } else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) { - emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE)); + MOVB (aopGet (left, offset, FALSE, FALSE)); MOVA (aopGet (right, offset, FALSE, FALSE)); emitcode ("anl", "a,b"); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + 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, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else { @@ -6473,11 +6902,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)); } } } @@ -6501,43 +6929,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 { @@ -6552,8 +6991,7 @@ genAnd (iCode * ic, iCode * ifx) { aopPut (result, aopGet (left, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); continue; } else if (bytelit == 0) @@ -6561,7 +6999,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) @@ -6569,28 +7007,45 @@ 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)) { - emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE)); + MOVB (aopGet (left, offset, FALSE, FALSE)); MOVA (aopGet (right, offset, FALSE, FALSE)); emitcode ("anl", "a,b"); } @@ -6604,15 +7059,15 @@ genAnd (iCode * ic, iCode * ifx) MOVA (aopGet (right, 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); } /*-----------------------------------------------------------------*/ @@ -6626,17 +7081,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 @@ -6667,7 +7122,7 @@ genOr (iCode * ic, iCode * ifx) left = tmp; } if (AOP_TYPE (right) == AOP_LIT) - lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + lit = ulFromVal (AOP (right)->aopu.aop_lit); size = AOP_SIZE (result); @@ -6704,28 +7159,33 @@ genOr (iCode * ic, iCode * ifx) if (AOP_TYPE (right) == AOP_CRY) { // c = bit | bit; - emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir); - emitcode ("orl", "c,%s", AOP (left)->aopu.aop_dir); + if (IS_OP_ACCUSE (left)) + { + emitcode ("orl", "c,%s", AOP (right)->aopu.aop_dir); + } + else + { + emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir); + emitcode ("orl", "c,%s", AOP (left)->aopu.aop_dir); + } } else { // c = bit | val; - symbol *tlbl = newiTempLabel (NULL); - if (!((AOP_TYPE (result) == AOP_CRY) && ifx)) - emitcode ("setb", "c"); - emitcode ("jb", "%s,%05d$", - AOP (left)->aopu.aop_dir, tlbl->key + 100); - toBoolean (right); - emitcode ("jnz", "%05d$", tlbl->key + 100); if ((AOP_TYPE (result) == AOP_CRY) && ifx) { + symbol *tlbl = newiTempLabel (NULL); + emitcode ("jb", "%s,%05d$", + AOP (left)->aopu.aop_dir, tlbl->key + 100); + toBoolean (right); + emitcode ("jnz", "%05d$", tlbl->key + 100); jmpTrueOrFalse (ifx, tlbl, left, right, result); goto release; } else { - CLRC; - emitcode ("", "%05d$:", tlbl->key + 100); + toCarry (right); + emitcode ("orl", "c,%s", AOP (left)->aopu.aop_dir); } } } @@ -6735,7 +7195,7 @@ genOr (iCode * ic, iCode * ifx) outBitC (result); // if(bit | ...) else if ((AOP_TYPE (result) == AOP_CRY) && ifx) - genIfxJump (ifx, "c", left, right, result); + genIfxJump (ifx, "c", left, right, result, ic->next); goto release; } @@ -6750,7 +7210,7 @@ genOr (iCode * ic, iCode * ifx) // result = 1 if (size) emitcode ("setb", "%s", AOP (result)->aopu.aop_dir); - else + else if(ifx) continueIfTrue (ifx); goto release; } @@ -6765,11 +7225,11 @@ genOr (iCode * ic, iCode * ifx) symbol *tlbl = newiTempLabel (NULL); emitcode ("jnz", "%05d$", tlbl->key + 100); CLRC; - emitcode ("", "%05d$:", tlbl->key + 100); + emitLabel (tlbl); } else - { - genIfxJump (ifx, "a", left, right, result); + { /* FIXME, thats pretty fishy, check for ifx!=0, testcase .. */ + genIfxJump (ifx, "a", left, right, result, ic->next); goto release; } } @@ -6795,13 +7255,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 { @@ -6820,16 +7280,16 @@ genOr (iCode * ic, iCode * ifx) } else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) { - emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE)); + MOVB (aopGet (left, offset, FALSE, FALSE)); MOVA (aopGet (right, offset, FALSE, FALSE)); emitcode ("orl", "a,b"); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + 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, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else { @@ -6837,12 +7297,11 @@ genOr (iCode * ic, iCode * ifx) 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)); } } } @@ -6862,29 +7321,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 { @@ -6899,8 +7388,7 @@ genOr (iCode * ic, iCode * ifx) { aopPut (result, aopGet (left, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); continue; } else if (bytelit == 0x0FF) @@ -6908,21 +7396,38 @@ 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)) { - emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE)); + MOVB (aopGet (left, offset, FALSE, FALSE)); MOVA (aopGet (right, offset, FALSE, FALSE)); emitcode ("orl", "a,b"); } @@ -6936,15 +7441,15 @@ genOr (iCode * ic, iCode * ifx) MOVA (aopGet (right, 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); } /*-----------------------------------------------------------------*/ @@ -6958,17 +7463,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 @@ -6999,8 +7504,9 @@ genXor (iCode * ic, iCode * ifx) right = left; left = tmp; } + if (AOP_TYPE (right) == AOP_LIT) - lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + lit = ulFromVal (AOP (right)->aopu.aop_lit); size = AOP_SIZE (result); @@ -7049,7 +7555,6 @@ genXor (iCode * ic, iCode * ifx) } } } - } else { @@ -7058,37 +7563,33 @@ genXor (iCode * ic, iCode * ifx) if (AOP_TYPE (right) == AOP_CRY) { // c = bit ^ bit; - emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir); + if (IS_OP_ACCUSE (left)) + {// left already is in the carry + operand *tmp = right; + right = left; + left = tmp; + } + else + { + toCarry (right); + } } else { - int sizer = AOP_SIZE (right); // c = bit ^ val - // if val>>1 != 0, result = 1 - emitcode ("setb", "c"); - while (sizer) - { - MOVA (aopGet (right, sizer - 1, FALSE, FALSE)); - if (sizer == 1) - // test the msb of the lsb - emitcode ("anl", "a,#0xfe"); - emitcode ("jnz", "%05d$", tlbl->key + 100); - sizer--; - } - // val = (0,1) - emitcode ("rrc", "a"); + toCarry (right); } emitcode ("jnb", "%s,%05d$", AOP (left)->aopu.aop_dir, (tlbl->key + 100)); emitcode ("cpl", "c"); - 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); + genIfxJump (ifx, "c", left, right, result, ic->next); goto release; } @@ -7112,7 +7613,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 { @@ -7131,16 +7632,16 @@ genXor (iCode * ic, iCode * ifx) } else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset)) { - emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE)); + MOVB (aopGet (left, offset, FALSE, FALSE)); MOVA (aopGet (right, offset, FALSE, FALSE)); emitcode ("xrl", "a,b"); - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + 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, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); } else { @@ -7148,11 +7649,10 @@ genXor (iCode * ic, iCode * ifx) 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)); } } } @@ -7167,6 +7667,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--) @@ -7176,26 +7677,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) @@ -7206,7 +7734,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); @@ -7214,22 +7742,38 @@ 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)) { - emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE)); + MOVB (aopGet (left, offset, FALSE, FALSE)); MOVA (aopGet (right, offset, FALSE, FALSE)); emitcode ("xrl", "a,b"); } @@ -7243,15 +7787,15 @@ genXor (iCode * ic, iCode * ifx) MOVA (aopGet (right, offset, FALSE, FALSE)); 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); } /*-----------------------------------------------------------------*/ @@ -7261,41 +7805,51 @@ static void genInline (iCode * ic) { char *buffer, *bp, *bp1; + bool inComment = FALSE; - 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) { - if (*bp == '\n') + switch (*bp) { + case ';': + inComment = TRUE; + ++bp; + break; + + case '\n': + inComment = FALSE; *bp++ = '\0'; emitcode (bp1, ""); bp1 = bp; - } - else - { + break; + + default: /* Add \n for labels, not dirs such as c:\mydir */ - if ( (*bp == ':') && (isspace((unsigned char)bp[1])) ) + if (!inComment && (*bp == ':') && (isspace((unsigned char)bp[1]))) { - bp++; + ++bp; *bp = '\0'; - bp++; + ++bp; emitcode (bp1, ""); bp1 = bp; } else - bp++; + ++bp; + break; } } if (bp1 != bp) emitcode (bp1, ""); - /* emitcode("",buffer); */ + + Safe_free (buffer); + _G.inLine -= (!options.asmpeep); } @@ -7306,10 +7860,10 @@ static void genRRC (iCode * ic) { operand *left, *result; - int size, offset = 0; - char *l; + int size, offset; + char *l; - D(emitcode ("; genRRC","")); + D (emitcode (";", "genRRC")); /* rotate right with carry */ left = IC_LEFT (ic); @@ -7333,7 +7887,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 */ @@ -7344,9 +7898,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); } /*-----------------------------------------------------------------*/ @@ -7356,10 +7910,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); @@ -7380,14 +7934,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 @@ -7399,9 +7956,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); } /*-----------------------------------------------------------------*/ @@ -7412,7 +7969,7 @@ genGetHbit (iCode * ic) { operand *left, *result; - D(emitcode ("; genGetHbit","")); + D (emitcode (";", "genGetHbit")); left = IC_LEFT (ic); result = IC_RESULT (ic); @@ -7433,9 +7990,8 @@ genGetHbit (iCode * ic) outAcc (result); } - - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -7447,7 +8003,7 @@ genGetAbit (iCode * ic) operand *left, *right, *result; int shCount; - D(emitcode ("; genGetAbit","")); + D (emitcode (";", "genGetAbit")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -7456,7 +8012,7 @@ genGetAbit (iCode * ic) aopOp (right, ic, FALSE); aopOp (result, ic, FALSE); - shCount = (int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); + shCount = (int) ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit); /* get the needed byte into a */ MOVA (aopGet (left, shCount / 8, FALSE, FALSE)); @@ -7505,9 +8061,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); } /*-----------------------------------------------------------------*/ @@ -7519,7 +8075,7 @@ genGetByte (iCode * ic) operand *left, *right, *result; int offset; - D(emitcode ("; genGetByte","")); + D (emitcode (";", "genGetByte")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -7528,15 +8084,14 @@ genGetByte (iCode * ic) aopOp (right, ic, FALSE); aopOp (result, ic, FALSE); - offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8; + offset = (int) ulFromVal (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); } /*-----------------------------------------------------------------*/ @@ -7548,7 +8103,7 @@ genGetWord (iCode * ic) operand *left, *right, *result; int offset; - D(emitcode ("; genGetWord","")); + D (emitcode (";", "genGetWord")); left = IC_LEFT (ic); right = IC_RIGHT (ic); @@ -7557,19 +8112,17 @@ genGetWord (iCode * ic) aopOp (right, ic, FALSE); aopOp (result, ic, FALSE); - offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8; + offset = (int) ulFromVal (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); } /*-----------------------------------------------------------------*/ @@ -7580,7 +8133,7 @@ genSwap (iCode * ic) { operand *left, *result; - D(emitcode ("; genSwap","")); + D(emitcode (";", "genSwap")); left = IC_LEFT (ic); result = IC_RESULT (ic); @@ -7592,15 +8145,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)) { @@ -7615,30 +8167,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 */ /*-----------------------------------------------------------------*/ @@ -7758,7 +8306,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); } } } @@ -7777,7 +8325,7 @@ shiftR1Left2Result (operand * left, int offl, AccSRsh (shCount); else AccRsh (shCount); - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); } /*-----------------------------------------------------------------*/ @@ -7792,7 +8340,7 @@ shiftL1Left2Result (operand * left, int offl, MOVA (l); /* shift left accumulator */ AccLsh (shCount); - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); } /*-----------------------------------------------------------------*/ @@ -7810,19 +8358,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) { MOVA (l); - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); } } } @@ -7884,16 +8434,16 @@ AccAXLsh (char *x, int shCount) break; case 3: case 4: - case 5: // AAAAABBB:CCCCCDDD + case 5: // AAAAABBB:CCCCCDDD - AccRol (shCount); // BBBAAAAA:CCCCCDDD + AccRol (shCount); // BBBAAAAA:CCCCCDDD emitcode ("anl", "a,#0x%02x", SLMask[shCount]); // BBB00000:CCCCCDDD emitcode ("xch", "a,%s", x); // CCCCCDDD:BBB00000 - AccRol (shCount); // DDDCCCCC:BBB00000 + AccRol (shCount); // DDDCCCCC:BBB00000 emitcode ("xch", "a,%s", x); // BBB00000:DDDCCCCC @@ -7909,14 +8459,14 @@ AccAXLsh (char *x, int shCount) emitcode ("xrl", "a,%s", x); // BBBCCCCC:DDD00000 break; - case 6: // AAAAAABB:CCCCCCDD + case 6: // AAAAAABB:CCCCCCDD emitcode ("anl", "a,#0x%02x", SRMask[shCount]); // 000000BB:CCCCCCDD emitcode ("mov", "c,acc.0"); // c = B emitcode ("xch", "a,%s", x); // CCCCCCDD:000000BB #if 0 // REMOVE ME - AccAXRrl1 (x); // BCCCCCCD:D000000B - AccAXRrl1 (x); // BBCCCCCC:DD000000 + AccAXRrl1 (x); // BCCCCCCD:D000000B + AccAXRrl1 (x); // BBCCCCCC:DD000000 #else emitcode("rrc","a"); emitcode("xch","a,%s", x); @@ -7930,7 +8480,7 @@ AccAXLsh (char *x, int shCount) emitcode("xch","a,%s", x); #endif break; - case 7: // a:x <<= 7 + case 7: // a:x <<= 7 emitcode ("anl", "a,#0x%02x", SRMask[shCount]); // 0000000B:CCCCCCCD @@ -7939,7 +8489,7 @@ AccAXLsh (char *x, int shCount) emitcode ("xch", "a,%s", x); // CCCCCCCD:0000000B - AccAXRrl1 (x); // BCCCCCCC:D0000000 + AccAXRrl1 (x); // BCCCCCCC:D0000000 break; default: @@ -7959,26 +8509,26 @@ AccAXRsh (char *x, int shCount) break; case 1: CLRC; - AccAXRrl1 (x); // 0->a:x + AccAXRrl1 (x); // 0->a:x break; case 2: CLRC; - AccAXRrl1 (x); // 0->a:x + AccAXRrl1 (x); // 0->a:x CLRC; - AccAXRrl1 (x); // 0->a:x + AccAXRrl1 (x); // 0->a:x break; case 3: case 4: - case 5: // AAAAABBB:CCCCCDDD = a:x + case 5: // AAAAABBB:CCCCCDDD = a:x - AccRol (8 - shCount); // BBBAAAAA:DDDCCCCC + AccRol (8 - shCount); // BBBAAAAA:DDDCCCCC emitcode ("xch", "a,%s", x); // CCCCCDDD:BBBAAAAA - AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA + AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA emitcode ("anl", "a,#0x%02x", SRMask[shCount]); // 000CCCCC:BBBAAAAA @@ -7997,13 +8547,13 @@ AccAXRsh (char *x, int shCount) emitcode ("xch", "a,%s", x); // 000AAAAA:BBBCCCCC break; - case 6: // AABBBBBB:CCDDDDDD + case 6: // AABBBBBB:CCDDDDDD emitcode ("mov", "c,acc.7"); - AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA + AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA emitcode ("mov", "c,acc.7"); - AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA + AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC @@ -8011,11 +8561,11 @@ AccAXRsh (char *x, int shCount) SRMask[shCount]); // 000000AA:BBBBBBCC break; - case 7: // ABBBBBBB:CDDDDDDD + case 7: // ABBBBBBB:CDDDDDDD emitcode ("mov", "c,acc.7"); // c = A - AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA + AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA emitcode ("xch", "a,%s", x); // DDDDDDDA:BBBBBBCC @@ -8041,27 +8591,27 @@ AccAXRshS (char *x, int shCount) break; case 1: emitcode ("mov", "c,acc.7"); - AccAXRrl1 (x); // s->a:x + AccAXRrl1 (x); // s->a:x break; case 2: emitcode ("mov", "c,acc.7"); - AccAXRrl1 (x); // s->a:x + AccAXRrl1 (x); // s->a:x emitcode ("mov", "c,acc.7"); - AccAXRrl1 (x); // s->a:x + AccAXRrl1 (x); // s->a:x break; case 3: case 4: - case 5: // AAAAABBB:CCCCCDDD = a:x + case 5: // AAAAABBB:CCCCCDDD = a:x tlbl = newiTempLabel (NULL); - AccRol (8 - shCount); // BBBAAAAA:CCCCCDDD + AccRol (8 - shCount); // BBBAAAAA:CCCCCDDD emitcode ("xch", "a,%s", x); // CCCCCDDD:BBBAAAAA - AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA + AccRol (8 - shCount); // DDDCCCCC:BBBAAAAA emitcode ("anl", "a,#0x%02x", SRMask[shCount]); // 000CCCCC:BBBAAAAA @@ -8083,17 +8633,17 @@ AccAXRshS (char *x, int shCount) emitcode ("orl", "a,#0x%02x", (unsigned char) ~SRMask[shCount]); // 111AAAAA:BBBCCCCC - emitcode ("", "%05d$:", tlbl->key + 100); - break; // SSSSAAAA:BBBCCCCC + emitLabel (tlbl); + break; // SSSSAAAA:BBBCCCCC - case 6: // AABBBBBB:CCDDDDDD + case 6: // AABBBBBB:CCDDDDDD tlbl = newiTempLabel (NULL); emitcode ("mov", "c,acc.7"); - AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA + AccAXLrl1 (x); // ABBBBBBC:CDDDDDDA emitcode ("mov", "c,acc.7"); - AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA + AccAXLrl1 (x); // BBBBBBCC:DDDDDDAA emitcode ("xch", "a,%s", x); // DDDDDDAA:BBBBBBCC @@ -8104,14 +8654,14 @@ 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 + case 7: // ABBBBBBB:CDDDDDDD tlbl = newiTempLabel (NULL); emitcode ("mov", "c,acc.7"); // c = A - AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA + AccAXLrl1 (x); // BBBBBBBC:DDDDDDDA emitcode ("xch", "a,%s", x); // DDDDDDDA:BBBBBBCC @@ -8122,7 +8672,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; @@ -8145,8 +8695,8 @@ shiftL2Left2Result (operand * left, int offl, { /* don't crash result[offr] */ MOVA (aopGet (left, offl, FALSE, FALSE)); - emitcode ("xch", "a,%s", aopGet (left, offl + MSB16, FALSE, FALSE)); - x = aopGet (result, offr, FALSE, FALSE); + x = xch_a_aopGet (left, offl + MSB16, FALSE, FALSE); + usedB = !strncmp(x, "b", 1); } else if (aopGetUsesAcc (result, offr)) { @@ -8169,13 +8719,13 @@ shiftL2Left2Result (operand * left, int offl, if (usedB) { emitcode ("xch", "a,b"); - aopPut (result, "a", offr, isOperandVolatile (result, FALSE)); - aopPut (result, "b", offr + MSB16, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr); + aopPut (result, "b", offr + MSB16); popB (pushedB); } else { - aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offr + MSB16); } } @@ -8197,17 +8747,16 @@ shiftR2Left2Result (operand * left, int offl, { /* don't crash result[offr] */ MOVA (aopGet (left, offl, FALSE, FALSE)); - emitcode ("xch", "a,%s", aopGet (left, offl + MSB16, FALSE, FALSE)); - x = aopGet (result, offr, 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"); + emitcode ("mov", "b,%s", aopGet (result, offr, FALSE, FALSE)); + MOVA (aopGet (left, offl + MSB16, FALSE, FALSE)); x = "b"; } else @@ -8223,11 +8772,13 @@ shiftR2Left2Result (operand * left, int offl, AccAXRsh (x, shCount); if (usedB) { - aopPut (result, "b", offr, isOperandVolatile (result, FALSE)); + 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); } /*-----------------------------------------------------------------*/ @@ -8241,9 +8792,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); } /*-----------------------------------------------------------------*/ @@ -8257,9 +8817,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); } /*-----------------------------------------------------------------*/ @@ -8268,7 +8837,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); } @@ -8281,7 +8850,7 @@ genlshTwo (operand * result, operand * left, int shCount) { int size; - D(emitcode ("; genlshTwo","")); + D (emitcode (";", "genlshTwo")); size = getDataSize (result); @@ -8293,11 +8862,15 @@ genlshTwo (operand * result, operand * left, int shCount) if (size > 1) { if (shCount) - shiftL1Left2Result (left, LSB, result, MSB16, shCount); + { + shiftL1Left2Result (left, LSB, result, MSB16, shCount); + } else - movLeft2Result (left, LSB, result, MSB16, 0); + { + movLeft2Result (left, LSB, result, MSB16, 0); + } } - aopPut (result, zero, LSB, isOperandVolatile (result, FALSE)); + aopPut (result, zero, LSB); } /* 1 <= shCount <= 7 */ @@ -8327,10 +8900,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) @@ -8343,10 +8915,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) @@ -8359,10 +8930,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) @@ -8373,10 +8943,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); } /*-----------------------------------------------------------------*/ @@ -8387,7 +8957,7 @@ genlshFour (operand * result, operand * left, int shCount) { int size; - D(emitcode ("; genlshFour","")); + D (emitcode (";", "genlshFour")); size = AOP_SIZE (result); @@ -8401,9 +8971,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; } @@ -8420,8 +8990,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; } @@ -8444,7 +9014,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); @@ -8453,7 +9023,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); } } } @@ -8483,10 +9053,10 @@ genLeftShiftLiteral (operand * left, operand * result, iCode * ic) { - int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit); + int shCount = (int) ulFromVal (AOP (right)->aopu.aop_lit); int size; - D(emitcode ("; genLeftShiftLiteral","")); + D (emitcode (";", "genLeftShiftLiteral")); freeAsmop (right, NULL, ic, TRUE); @@ -8508,10 +9078,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) @@ -8533,8 +9106,8 @@ genLeftShiftLiteral (operand * left, break; } } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -8549,7 +9122,7 @@ genLeftShift (iCode * ic) symbol *tlbl, *tlbl1; bool pushedB; - D(emitcode ("; genLeftShift","")); + D (emitcode (";", "genLeftShift")); right = IC_RIGHT (ic); left = IC_LEFT (ic); @@ -8572,7 +9145,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); @@ -8592,10 +9165,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++; } } @@ -8613,38 +9186,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); } /*-----------------------------------------------------------------*/ @@ -8654,7 +9227,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); } @@ -8666,15 +9239,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); @@ -8693,61 +9265,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) { - MOVA (aopGet (left, LSB, FALSE, FALSE)); + aopPut (result, "a", MSB16 - offl); + } + else + { + 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); } } @@ -8758,7 +9370,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) @@ -8786,7 +9398,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); @@ -8804,7 +9418,8 @@ genrshFour (operand * result, operand * left, } } else - { /* 1 <= shCount <= 7 */ + { + /* 1 <= shCount <= 7 */ if (shCount <= 2) { shiftRLong (left, LSB, result, sign); @@ -8830,10 +9445,10 @@ genRightShiftLiteral (operand * left, iCode * ic, int sign) { - int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit); + int shCount = (int) ulFromVal (AOP (right)->aopu.aop_lit); int size; - D(emitcode ("; genRightShiftLiteral","")); + D (emitcode (";", "genRightShiftLiteral")); freeAsmop (right, NULL, ic, TRUE); @@ -8855,13 +9470,13 @@ genRightShiftLiteral (operand * left, while (size--) movLeft2Result (left, size, result, size, 0); } - 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 @@ -8883,8 +9498,8 @@ genRightShiftLiteral (operand * left, break; } } - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -8899,7 +9514,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 */ @@ -8923,7 +9538,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); @@ -8944,10 +9559,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++; } } @@ -8967,35 +9582,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); } /*-----------------------------------------------------------------*/ @@ -9011,7 +9626,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 */ @@ -9051,7 +9666,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); @@ -9062,7 +9677,6 @@ genRightShift (iCode * ic) if (!sameRegs (AOP (left), AOP (result)) && AOP_SIZE (result) > 1) { - size = AOP_SIZE (result); offset = 0; while (size--) @@ -9072,10 +9686,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++; } } @@ -9091,36 +9705,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); } /*-----------------------------------------------------------------*/ @@ -9212,7 +9826,7 @@ emitPtrByteSet (char *rname, int p_type, char *src) /*-----------------------------------------------------------------*/ /* genUnpackBits - generates code for unpacking bits */ /*-----------------------------------------------------------------*/ -static void +static char* genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx) { int offset = 0; /* result byte offset */ @@ -9221,9 +9835,10 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx) sym_link *etype; /* bitfield type information */ int blen; /* bitfield length */ int bstr; /* bitfield starting bit within byte */ - char buffer[10]; + static char* const accBits[] = {"acc.0", "acc.1", "acc.2", "acc.3", + "acc.4", "acc.5", "acc.6", "acc.7"}; - D(emitcode ("; genUnpackBits","")); + D(emitcode (";", "genUnpackBits")); etype = getSpec (operandType (result)); rsize = getSize (operandType (result)); @@ -9235,18 +9850,15 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx) emitPtrByteGet (rname, ptype, FALSE); if (blen == 1) { - SNPRINTF (buffer, sizeof(buffer), - "acc.%d", bstr); - genIfxJump (ifx, buffer, NULL, NULL, NULL); + return accBits[bstr];; } else { if (blen < 8) emitcode ("anl", "a,#0x%02x", (((unsigned char) -1) >> (8 - blen)) << bstr); - genIfxJump (ifx, "a", NULL, NULL, NULL); + return "a"; } - return; } wassert (!ifx); @@ -9254,9 +9866,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; } @@ -9265,7 +9886,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); } @@ -9275,16 +9896,38 @@ 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++); } + return NULL; } @@ -9300,24 +9943,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); } /*-----------------------------------------------------------------*/ @@ -9333,11 +9981,11 @@ genNearPointerGet (operand * left, asmop *aop = NULL; regs *preg = NULL; char *rname; + char *ifxCond = "a"; sym_link *rtype, *retype; sym_link *ltype = operandType (left); - char buffer[80]; - D(emitcode ("; genNearPointerGet","")); + D (emitcode (";", "genNearPointerGet")); rtype = operandType (result); retype = getSpec (rtype); @@ -9356,6 +10004,9 @@ genNearPointerGet (operand * left, return; } + //aopOp (result, ic, FALSE); + aopOp (result, ic, result?TRUE:FALSE); + /* if the value is already in a pointer register then don't need anything more */ if (!AOP_INPREG (AOP (left))) @@ -9364,10 +10015,16 @@ genNearPointerGet (operand * left, { // Aha, it is a pointer, just in disguise. rname = aopGet (left, 0, FALSE, FALSE); - if (*rname != '@') + if (strcmp (rname, "a") == 0) { - fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n", - __FILE__, __LINE__); + // It's in pdata or on xstack + rname = AOP (left)->aopu.aop_ptr->name; + emitcode ("mov", "%s,a", rname); + } + else if (*rname != '@') + { + fprintf(stderr, "probable internal error: unexpected rname '%s' @ %s:%d\n", + rname, __FILE__, __LINE__); } else { @@ -9390,12 +10047,9 @@ genNearPointerGet (operand * left, else rname = aopGet (left, 0, FALSE, FALSE); - //aopOp (result, ic, FALSE); - aopOp (result, ic, result?TRUE:FALSE); - /* if bitfield then unpack the bits */ if (IS_BITFIELD (retype)) - genUnpackBits (result, rname, POINTER, ifx); + ifxCond = genUnpackBits (result, rname, POINTER, ifx); else { /* we have can just get the values */ @@ -9409,12 +10063,14 @@ 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)); + char buffer[80]; + + SNPRINTF (buffer, sizeof(buffer), "@%s", rname); + aopPut (result, buffer, offset); } offset++; if (size || pi) @@ -9423,10 +10079,10 @@ genNearPointerGet (operand * left, } /* now some housekeeping stuff */ - if (aop) /* we had to allocate for this iCode */ + 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); } @@ -9451,7 +10107,7 @@ genNearPointerGet (operand * left, if (ifx && !ifx->generated) { - genIfxJump (ifx, "a", left, NULL, result); + genIfxJump (ifx, ifxCond, left, NULL, result, ic->next); } /* done */ @@ -9473,15 +10129,18 @@ genPagedPointerGet (operand * left, asmop *aop = NULL; regs *preg = NULL; char *rname; + char *ifxCond = "a"; sym_link *rtype, *retype; - D(emitcode ("; genPagedPointerGet","")); + D (emitcode (";", "genPagedPointerGet")); rtype = operandType (result); retype = getSpec (rtype); aopOp (left, ic, FALSE); + aopOp (result, ic, FALSE); + /* if the value is already in a pointer register then don't need anything more */ if (!AOP_INPREG (AOP (left))) @@ -9497,11 +10156,9 @@ genPagedPointerGet (operand * left, else rname = aopGet (left, 0, FALSE, FALSE); - aopOp (result, ic, FALSE); - /* if bitfield then unpack the bits */ if (IS_BITFIELD (retype)) - genUnpackBits (result, rname, PPOINTER, ifx); + ifxCond = genUnpackBits (result, rname, PPOINTER, ifx); else { /* we have can just get the values */ @@ -9513,7 +10170,7 @@ genPagedPointerGet (operand * left, emitcode ("movx", "a,@%s", rname); if (!ifx) - aopPut (result, "a", offset, isOperandVolatile (result, FALSE)); + aopPut (result, "a", offset); offset++; @@ -9523,9 +10180,10 @@ genPagedPointerGet (operand * left, } /* now some housekeeping stuff */ - if (aop) /* we had to allocate for this iCode */ + 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 @@ -9549,14 +10207,13 @@ genPagedPointerGet (operand * left, if (ifx && !ifx->generated) { - genIfxJump (ifx, "a", left, NULL, result); + genIfxJump (ifx, ifxCond, left, NULL, result, ic->next); } /* done */ - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); if (pi) pi->generated = 1; - } /*--------------------------------------------------------------------*/ @@ -9578,7 +10235,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: @@ -9620,16 +10277,17 @@ loadDptrFromOperand (operand *op, bool loadBToo) } /*-----------------------------------------------------------------*/ -/* genFarPointerGet - gget value from far space */ +/* genFarPointerGet - get value from far space */ /*-----------------------------------------------------------------*/ static void genFarPointerGet (operand * left, operand * result, iCode * ic, iCode * pi, iCode * ifx) { int size, offset; + char *ifxCond = "a"; sym_link *retype = getSpec (operandType (result)); - D(emitcode ("; genFarPointerGet","")); + D (emitcode (";", "genFarPointerGet")); aopOp (left, ic, FALSE); loadDptrFromOperand (left, FALSE); @@ -9639,7 +10297,7 @@ genFarPointerGet (operand * left, /* if bit then unpack */ if (IS_BITFIELD (retype)) - genUnpackBits (result, "dptr", FPOINTER, ifx); + ifxCond = genUnpackBits (result, "dptr", FPOINTER, ifx); else { size = AOP_SIZE (result); @@ -9649,7 +10307,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"); } @@ -9657,31 +10315,32 @@ 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); + genIfxJump (ifx, ifxCond, left, NULL, result, ic->next); } - 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, operand * result, iCode * ic, iCode *pi, iCode *ifx) { int size, offset; + char *ifxCond = "a"; sym_link *retype = getSpec (operandType (result)); - D(emitcode ("; genCodePointerGet","")); + D (emitcode (";", "genCodePointerGet")); aopOp (left, ic, FALSE); loadDptrFromOperand (left, FALSE); @@ -9691,7 +10350,7 @@ genCodePointerGet (operand * left, /* if bit then unpack */ if (IS_BITFIELD (retype)) - genUnpackBits (result, "dptr", CPOINTER, ifx); + ifxCond = genUnpackBits (result, "dptr", CPOINTER, ifx); else { size = AOP_SIZE (result); @@ -9699,61 +10358,55 @@ 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); + genIfxJump (ifx, ifxCond, left, NULL, result, ic->next); } - 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, operand * result, iCode * ic, iCode *pi, iCode *ifx) { int size, offset; + char *ifxCond = "a"; 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); + { + ifxCond = genUnpackBits (result, "dptr", GPOINTER, ifx); + } else { size = AOP_SIZE (result); @@ -9763,7 +10416,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"); } @@ -9771,19 +10424,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); + genIfxJump (ifx, ifxCond, left, NULL, result, ic->next); } - - freeAsmop (left, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (left, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -9796,7 +10448,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); @@ -9810,7 +10462,9 @@ genPointerGet (iCode * ic, iCode *pi, iCode *ifx) etype = getSpec (type); /* if left is of type of pointer then it is simple */ if (IS_PTR (type) && !IS_FUNC (type->next)) - p_type = DCL_TYPE (type); + { + p_type = DCL_TYPE (type); + } else { /* we have to go by the storage class */ @@ -9819,11 +10473,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) @@ -9850,11 +10505,9 @@ genPointerGet (iCode * ic, iCode *pi, iCode *ifx) genGenPointerGet (left, result, ic, pi, ifx); break; } - } - /*-----------------------------------------------------------------*/ /* genPackBits - generates code for packed bit storage */ /*-----------------------------------------------------------------*/ @@ -9870,7 +10523,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); @@ -9885,7 +10538,7 @@ genPackBits (sym_link * etype, { /* Case with a bitfield length <8 and literal source */ - litval = (int) floatFromVal (AOP (right)->aopu.aop_lit); + litval = (int) ulFromVal (AOP (right)->aopu.aop_lit); litval <<= bstr; litval &= (~mask) & 0xff; emitPtrByteGet (rname, p_type, FALSE); @@ -9956,7 +10609,7 @@ genPackBits (sym_link * etype, { /* Case with partial byte and literal source */ - litval = (int) floatFromVal (AOP (right)->aopu.aop_lit); + litval = (int) ulFromVal (AOP (right)->aopu.aop_lit); litval >>= (blen-rlen); litval &= (~mask) & 0xff; emitPtrByteGet (rname, p_type, FALSE); @@ -9986,7 +10639,6 @@ genPackBits (sym_link * etype, } emitPtrByteSet (rname, p_type, "a"); } - } @@ -10001,18 +10653,19 @@ 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); - size = AOP_SIZE (right); + l++; //remove # + size = max (AOP_SIZE (right), 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); + SNPRINTF (buffer, sizeof(buffer), "%s", l); emitcode ("mov", "%s,%s", buffer, aopGet (right, offset++, FALSE, FALSE)); } @@ -10022,7 +10675,7 @@ genDataPointerSet (operand * right, } /*-----------------------------------------------------------------*/ -/* genNearPointerSet - emitcode for near pointer put */ +/* genNearPointerSet - emitcode for near pointer put */ /*-----------------------------------------------------------------*/ static void genNearPointerSet (operand * right, @@ -10036,10 +10689,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 & @@ -10057,39 +10711,42 @@ genNearPointerSet (operand * right, then don't need anything more */ if (!AOP_INPREG (AOP (result))) { - if ( - //AOP_TYPE (result) == AOP_STK - IS_AOP_PREG(result) - ) + if (IS_AOP_PREG (result)) { - // Aha, it is a pointer, just in disguise. - rname = aopGet (result, 0, FALSE, FALSE); - if (*rname != '@') + // Aha, it is a pointer, just in disguise. + rname = aopGet (result, 0, FALSE, FALSE); + if (strcmp (rname, "a") == 0) { - fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n", - __FILE__, __LINE__); + // It's in pdata or on xstack + rname = AOP (result)->aopu.aop_ptr->name; + emitcode ("mov", "%s,a", rname); } - else + else if (*rname != '@') + { + fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n", + __FILE__, __LINE__); + } + else { - // Expected case. - emitcode ("mov", "a%s,%s", rname + 1, rname); - rname++; // skip the '@'. + // Expected case. + emitcode ("mov", "a%s,%s", rname + 1, rname); + rname++; // skip the '@'. } } - else + else { - /* otherwise get a free pointer register */ - aop = newAsmop (0); - preg = getFreePtr (ic, &aop, FALSE); - emitcode ("mov", "%s,%s", - preg->name, - aopGet (result, 0, FALSE, TRUE)); - rname = preg->name; + /* otherwise get a free pointer register */ + aop = newAsmop (0); + preg = getFreePtr (ic, &aop, FALSE); + emitcode ("mov", "%s,%s", + preg->name, + aopGet (result, 0, FALSE, TRUE)); + rname = preg->name; } } - else + else { - rname = aopGet (result, 0, FALSE, FALSE); + rname = aopGet (result, 0, FALSE, FALSE); } aopOp (right, ic, FALSE); @@ -10099,14 +10756,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); @@ -10120,10 +10777,10 @@ genNearPointerSet (operand * right, } /* now some housekeeping stuff */ - if (aop) /* we had to allocate for this iCode */ + 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 @@ -10146,9 +10803,10 @@ genNearPointerSet (operand * right, } /* done */ - if (pi) pi->generated = 1; - freeAsmop (result, NULL, ic, TRUE); + if (pi) + pi->generated = 1; freeAsmop (right, NULL, ic, TRUE); + freeAsmop (result, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -10165,7 +10823,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)); @@ -10176,16 +10834,37 @@ genPagedPointerSet (operand * right, then don't need anything more */ if (!AOP_INPREG (AOP (result))) { - /* otherwise get a free pointer register */ - aop = newAsmop (0); - preg = getFreePtr (ic, &aop, FALSE); - emitcode ("mov", "%s,%s", - preg->name, - aopGet (result, 0, FALSE, TRUE)); - rname = preg->name; + if (IS_AOP_PREG (result)) + { + // Aha, it is a pointer, just in disguise. + rname = aopGet (result, 0, FALSE, FALSE); + if (*rname != '@') + { + fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n", + __FILE__, __LINE__); + } + else + { + // Expected case. + emitcode ("mov", "a%s,%s", rname + 1, rname); + rname++; // skip the '@'. + } + } + else + { + /* otherwise get a free pointer register */ + aop = newAsmop (0); + preg = getFreePtr (ic, &aop, FALSE); + emitcode ("mov", "%s,%s", + preg->name, + aopGet (result, 0, FALSE, TRUE)); + rname = preg->name; + } } else - rname = aopGet (result, 0, FALSE, FALSE); + { + rname = aopGet (result, 0, FALSE, FALSE); + } aopOp (right, ic, FALSE); @@ -10194,20 +10873,17 @@ genPagedPointerSet (operand * right, genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, rname, PPOINTER); 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); - MOVA (l); emitcode ("movx", "@%s,a", rname); - if (size || pi) emitcode ("inc", "%s", rname); - offset++; } } @@ -10216,7 +10892,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 @@ -10228,8 +10904,8 @@ genPagedPointerSet (operand * right, belongs */ if (AOP_SIZE (right) > 1 && !OP_SYMBOL (result)->remat && - (OP_SYMBOL (result)->liveTo > ic->seq || - ic->depth)) + (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth) && + !pi) { int size = AOP_SIZE (right) - 1; while (size--) @@ -10238,11 +10914,10 @@ genPagedPointerSet (operand * right, } /* done */ - if (pi) pi->generated = 1; - freeAsmop (result, NULL, ic, TRUE); + if (pi) + pi->generated = 1; freeAsmop (right, NULL, ic, TRUE); - - + freeAsmop (result, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -10256,12 +10931,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 */ @@ -10282,8 +10957,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); @@ -10301,17 +10976,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); @@ -10328,8 +11005,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); @@ -10346,7 +11023,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); @@ -10373,6 +11050,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) @@ -10399,7 +11077,6 @@ genPointerSet (iCode * ic, iCode *pi) werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "genPointerSet: illegal pointer type"); } - } /*-----------------------------------------------------------------*/ @@ -10412,35 +11089,34 @@ 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); - /* if there was something to be popped then do it */ - if (popIc) - genIpop (popIc); - /* if the condition is a bit variable */ if (isbit && dup) - genIfxJump(ic, dup, NULL, NULL, NULL); + genIfxJump(ic, dup, NULL, NULL, NULL, popIc); else if (isbit && IS_ITEMP (cond) && SPIL_LOC (cond)) - genIfxJump (ic, SPIL_LOC (cond)->rname, NULL, NULL, NULL); + genIfxJump (ic, SPIL_LOC (cond)->rname, NULL, NULL, NULL, popIc); else if (isbit && !IS_ITEMP (cond)) - genIfxJump (ic, OP_SYMBOL (cond)->rname, NULL, NULL, NULL); + genIfxJump (ic, OP_SYMBOL (cond)->rname, NULL, NULL, NULL, popIc); else - genIfxJump (ic, "a", NULL, NULL, NULL); + genIfxJump (ic, "a", NULL, NULL, NULL, popIc); ic->generated = 1; } @@ -10454,7 +11130,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); @@ -10463,20 +11139,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; @@ -10484,31 +11173,40 @@ 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; } /* object not on stack then we need the name */ - size = AOP_SIZE (IC_RESULT (ic)); + size = getDataSize (IC_RESULT (ic)); offset = 0; while (size--) { char s[SDCC_NAME_MAX]; if (offset) - sprintf (s, "#(%s >> %d)", - sym->rname, - offset * 8); + { + sprintf (s, "#(%s >> %d)", + 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++); + } + if (opIsGptr (IC_RESULT (ic))) + { + char buffer[10]; + SNPRINTF (buffer, sizeof(buffer), + "#0x%02x", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL)); + aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1); } release: freeAsmop (IC_RESULT (ic), NULL, ic, TRUE); - } /*-----------------------------------------------------------------*/ @@ -10521,7 +11219,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--) @@ -10538,10 +11236,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); - } /*-----------------------------------------------------------------*/ @@ -10554,7 +11251,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); @@ -10572,7 +11269,6 @@ genAssign (iCode * ic) IS_TRUE_SYMOP (result) && isOperandInFarSpace (result)) { - genFarFarAssign (result, right, ic); return; } @@ -10588,38 +11284,17 @@ 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; } /* bit variables done */ /* general case */ - size = AOP_SIZE (result); + size = getDataSize (result); offset = 0; if (AOP_TYPE (right) == AOP_LIT) - lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit); + lit = ulFromVal (AOP (right)->aopu.aop_lit); + if ((size > 1) && (AOP_TYPE (result) != AOP_REG) && (AOP_TYPE (right) == AOP_LIT) && @@ -10630,16 +11305,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++; } } @@ -10649,15 +11327,15 @@ genAssign (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } } + adjustArithmeticResult (ic); release: - freeAsmop (right, NULL, ic, TRUE); freeAsmop (result, NULL, ic, TRUE); + freeAsmop (right, NULL, ic, TRUE); } /*-----------------------------------------------------------------*/ @@ -10670,7 +11348,7 @@ genJumpTab (iCode * ic) char *l; unsigned int count; - D(emitcode ("; genJumpTab","")); + D (emitcode (";", "genJumpTab")); count = elementsInSet( IC_JTLABELS (ic) ); @@ -10679,21 +11357,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,#0x03"); + 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))) @@ -10749,13 +11436,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); @@ -10774,7 +11461,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))) @@ -10784,37 +11471,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)) { @@ -10830,18 +11492,15 @@ 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)) { - int p_type; sym_link *type = operandType (right); sym_link *etype = getSpec (type); @@ -10850,7 +11509,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) { @@ -10869,8 +11530,7 @@ genCast (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } /* the last byte depending on type */ @@ -10884,8 +11544,8 @@ genCast (iCode * ic) exit(1); } - sprintf(gpValStr, "#0x%x", gpVal); - aopPut (result, gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE)); + sprintf(gpValStr, "#0x%02x", gpVal); + aopPut (result, gpValStr, GPTRSIZE - 1); } goto release; } @@ -10897,8 +11557,7 @@ genCast (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } goto release; @@ -10913,8 +11572,7 @@ genCast (iCode * ic) { aopPut (result, aopGet (right, offset, FALSE, FALSE), - offset, - isOperandVolatile (result, FALSE)); + offset); offset++; } @@ -10924,7 +11582,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 { @@ -10935,15 +11593,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); } /*-----------------------------------------------------------------*/ @@ -10956,15 +11613,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; @@ -10978,6 +11632,9 @@ genDjnz (iCode * ic, iCode * ifx) return 0; /* otherwise we can save BIG */ + + D (emitcode (";", "genDjnz")); + lbl = newiTempLabel (NULL); lbl1 = newiTempLabel (NULL); @@ -11003,7 +11660,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))) @@ -11011,6 +11668,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 @@ -11019,11 +11678,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; } @@ -11037,7 +11697,7 @@ 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 */ @@ -11064,11 +11724,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; } } @@ -11080,8 +11738,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; } } @@ -11099,7 +11756,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 @@ -11112,7 +11769,10 @@ genReceive (iCode * ic) } else if (ic->argreg > 12) { /* bit parameters */ - if (OP_SYMBOL (IC_RESULT (ic))->regs[0]->rIdx != ic->argreg-5) + regs *reg = OP_SYMBOL (IC_RESULT (ic))->regs[0]; + + BitBankUsed = 1; + if (!reg || reg->rIdx != ic->argreg-5) { aopOp (IC_RESULT (ic), ic, FALSE); emitcode ("mov", "c,%s", rb1regs[ic->argreg-5]); @@ -11126,7 +11786,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++); } } @@ -11143,7 +11803,7 @@ genDummyRead (iCode * ic) operand *op; int size, offset; - D(emitcode("; genDummyRead","")); + D (emitcode(";", "genDummyRead")); op = IC_RIGHT (ic); if (op && IS_SYMOP (op)) @@ -11202,15 +11862,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 @@ -11218,7 +11878,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*/ } } @@ -11229,7 +11889,7 @@ genCritical (iCode *ic) static void genEndCritical (iCode *ic) { - D(emitcode("; genEndCritical","")); + D(emitcode(";", "genEndCritical")); if (IC_RIGHT (ic)) { @@ -11270,7 +11930,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) { @@ -11294,7 +11954,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; @@ -11302,20 +11962,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; + const 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 @@ -11344,18 +12017,25 @@ gen51Code (iCode * lic) break; case IPOP: - /* IPOP happens only when trying to restore a - spilt live range, if there is an ifx statement - following this pop then the if statement might - be using some of the registers being popped which - would destory the contents of the register so - we need to check for this condition and handle it */ - if (ic->next && - ic->next->op == IFX && - regsInCommon (IC_LEFT (ic), IC_COND (ic->next))) - genIfx (ic->next, ic); - else - genIpop (ic); + { + iCode *ifxIc, *popIc; + bool CommonRegs = FALSE; + + /* IPOP happens only when trying to restore a + spilt live range, if there is an ifx statement + following this pop (or several) then the if statement might + be using some of the registers being popped which + would destory the contents of the register so + we need to check for this condition and handle it */ + for (ifxIc = ic->next; ifxIc && ifxIc->op == IPOP; ifxIc = ifxIc->next); + for (popIc = ic; popIc && popIc->op == IPOP; popIc = popIc->next) + CommonRegs |= (ifxIc && ifxIc->op == IFX && !ifxIc->generated && + regsInCommon (IC_LEFT (popIc), IC_COND (ifxIc))); + if (CommonRegs) + genIfx (ifxIc, ic); + else + genIpop (ic); + } break; case CALL: @@ -11420,7 +12100,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; @@ -11494,7 +12174,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; @@ -11552,6 +12234,6 @@ gen51Code (iCode * lic) peepHole (&lineHead); /* now do the actual printing */ - printLine (lineHead, codeOutFile); + printLine (lineHead, codeOutBuf); return; }