X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fmcs51%2Fgen.c;h=9375087a431f1cae78da365a154314d34869efed;hb=b1a10c8ec5142594ec5698fa241d7433873ce710;hp=97218f070241d2f0df1932673f844f14ac87d3b1;hpb=6a370e6ab695babec796a8f30b7a03a6bc9dc77d;p=fw%2Fsdcc

diff --git a/src/mcs51/gen.c b/src/mcs51/gen.c
index 97218f07..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 <stdio.h>
 #include <stdlib.h>
@@ -41,9 +40,12 @@
 #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);
 extern int allocInfo;
 
 /* this is the down and dirty file with all kinds of
@@ -64,6 +66,29 @@ 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))
+
+#define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY ||  \
+                         AOP_TYPE(x) == AOP_DPTR || \
+                         AOP(x)->paged))
+
+#define AOP_INPREG(x) (x && (x->type == AOP_REG &&                        \
+                       (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")
+
+#define R0INB   _G.bu.bs.r0InB
+#define R1INB   _G.bu.bs.r1InB
+#define OPINB   _G.bu.bs.OpInB
+#define BINUSE  _G.bu.BInUse
+
 static struct
   {
     short r0Pushed;
@@ -75,9 +100,9 @@ static struct
             short r0InB : 2;//2 so we can see it overflow
             short r1InB : 2;//2 so we can see it overflow
             short OpInB : 2;//2 so we can see it overflow
-          } ;
+          } bs;
         short BInUse;
-      } ;
+      } bu;
     short accInUse;
     short inLine;
     short debugLine;
@@ -89,19 +114,19 @@ static struct
 _G;
 
 static char *rb1regs[] = {
-    "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7"
+    "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7",
+    "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")
 
@@ -123,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);
+    }
 
-  while (isspace (*lbp))
+  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;
 }
 
 /*-----------------------------------------------------------------*/
@@ -179,7 +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);
+}
+
+/*-----------------------------------------------------------------*/
+/* movb - moves specified value into register b                    */
+/*-----------------------------------------------------------------*/
+static void
+movb (const char *x)
+{
+  /* 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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -190,7 +265,7 @@ pushB (void)
 {
   bool pushedB = FALSE;
 
-  if (_G.BInUse)
+  if (BINUSE)
     {
       emitcode ("push", "b");
 //    printf("B was in use !\n");
@@ -198,7 +273,7 @@ pushB (void)
     }
   else
     {
-      _G.OpInB++;
+      OPINB++;
     }
   return pushedB;
 }
@@ -215,8 +290,44 @@ popB (bool pushedB)
     }
   else
     {
-      _G.OpInB--;
+      OPINB--;
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* pushReg - saves register                                        */
+/*-----------------------------------------------------------------*/
+static bool
+pushReg (int index, bool bits_pushed)
+{
+  regs * reg = REG_WITH_INDEX (index);
+  if (reg->type == REG_BIT)
+    {
+      if (!bits_pushed)
+        emitcode ("push", "%s", reg->base);
+      return TRUE;
+    }
+  else
+    emitcode ("push", "%s", reg->dname);
+  return bits_pushed;
+}
+
+/*-----------------------------------------------------------------*/
+/* popReg - restores register                                      */
+/*-----------------------------------------------------------------*/
+static bool
+popReg (int index, bool bits_popped)
+{
+  regs * reg = REG_WITH_INDEX (index);
+  if (reg->type == REG_BIT)
+    {
+      if (!bits_popped)
+        emitcode ("pop", "%s", reg->base);
+      return TRUE;
     }
+  else
+    emitcode ("pop", "%s", reg->dname);
+  return bits_popped;
 }
 
 /*-----------------------------------------------------------------*/
@@ -248,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 */
@@ -257,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 */
@@ -267,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);
-          _G.r0InB++;
+          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 */
@@ -291,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);
-          _G.r1InB++;
+          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__,
@@ -372,7 +484,7 @@ getTempRegs(regs **tempRegs, int size, iCode *ic)
   for (i=0; i<freeRegs->size; i++)
     {
       if (bitVectBitValue(freeRegs,i))
-        tempRegs[offset++] = mcs51_regWithIdx(i);
+        tempRegs[offset++] = REG_WITH_INDEX(i);
       if (offset>=size)
         {
           freeBitVect(freeRegs);
@@ -381,7 +493,7 @@ getTempRegs(regs **tempRegs, int size, iCode *ic)
     }
 
   freeBitVect(freeRegs);
-  return 1;
+  return 0;
 }
 
 
@@ -395,6 +507,7 @@ newAsmop (short type)
 
   aop = Safe_calloc (1, sizeof (asmop));
   aop->type = type;
+  aop->allocated = 1;
   return aop;
 }
 
@@ -430,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);
@@ -441,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);
@@ -452,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);
@@ -460,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);
@@ -483,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");
@@ -491,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 */
@@ -506,27 +623,45 @@ aopForSym (iCode * ic, symbol * sym, bool result)
          the pointer register */
       if (aop->type != AOP_STK)
         {
-
           if (sym->onStack)
             {
-              if (_G.accInUse || leftRightUseAcc (ic))
-                emitcode ("push", "acc");
-
-              emitcode ("mov", "a,_bp");
-              emitcode ("add", "a,#0x%02x",
-                        ((sym->stack < 0) ?
-                         ((char) (sym->stack - _G.nRegsSaved)) :
-                         ((char) sym->stack)) & 0xff);
-              emitcode ("mov", "%s,a",
-                        aop->aopu.aop_ptr->name);
+              signed char offset = ((sym->stack < 0) ?
+                         ((signed char) (sym->stack - _G.nRegsSaved)) :
+                         ((signed char) sym->stack)) & 0xff;
 
-              if (_G.accInUse || leftRightUseAcc (ic))
-                emitcode ("pop", "acc");
+              if ((abs(offset) <= 3) ||
+                  (accuse && (abs(offset) <= 7)))
+                {
+                  emitcode ("mov", "%s,%s",
+                            aop->aopu.aop_ptr->name, SYM_BP (sym));
+                  while (offset < 0)
+                    {
+                      emitcode ("dec", aop->aopu.aop_ptr->name);
+                      offset++;
+                    }
+                  while (offset > 0)
+                    {
+                      emitcode ("inc", aop->aopu.aop_ptr->name);
+                      offset--;
+                    }
+                }
+              else
+                {
+                  if (accuse)
+                    emitcode ("push", "acc");
+                  emitcode ("mov", "a,%s", SYM_BP (sym));
+                  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
@@ -558,9 +693,8 @@ 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->size = FPTRSIZE;
+      aop->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname);
+      aop->size = getSize (sym->type);
       return aop;
     }
 
@@ -578,7 +712,7 @@ aopForSym (iCode * ic, symbol * sym, bool result)
 }
 
 /*-----------------------------------------------------------------*/
-/* aopForRemat - rematerialzes an object                           */
+/* aopForRemat - rematerializes an object                          */
 /*-----------------------------------------------------------------*/
 static asmop *
 aopForRemat (symbol * sym)
@@ -594,37 +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 = DCL_TYPE(from_type);
-              if (ptr_type == IPOINTER) {
-                // bug #481053
-                ptr_type = POINTER;
-              }
-              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;
 }
@@ -693,8 +829,9 @@ operandsEqu (operand * op1, operand * op2)
     return TRUE;
 
   /* if they have the same rname */
-  if (sym1->rname[0] && sym2->rname[0]
-      && strcmp (sym1->rname, sym2->rname) == 0)
+  if (sym1->rname[0] && sym2->rname[0] &&
+      strcmp (sym1->rname, sym2->rname) == 0 &&
+      !(IS_PARM (op2) && IS_ITEMP (op1)))
     return TRUE;
 
   /* if left is a tmp & right is not */
@@ -714,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                   */
 /*-----------------------------------------------------------------*/
@@ -725,16 +883,17 @@ sameRegs (asmop * aop1, asmop * aop2)
   if (aop1 == aop2)
     return TRUE;
 
-  if (aop1->type != AOP_REG ||
-      aop2->type != AOP_REG)
+  if (aop1->type != AOP_REG && aop1->type != AOP_CRY)
+    return FALSE;
+
+  if (aop1->type != aop2->type)
     return FALSE;
 
   if (aop1->size != aop2->size)
     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;
@@ -763,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;
     }
 
@@ -781,7 +944,7 @@ aopOp (operand * op, iCode * ic, bool result)
     }
 
   /* this is a temporary : this has
-     only four choices :
+     only five choices :
      a) register
      b) spillocation
      c) rematerialize
@@ -793,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;
     }
 
@@ -807,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];
@@ -827,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];
@@ -836,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;
         }
@@ -853,6 +1022,16 @@ aopOp (operand * op, iCode * ic, bool result)
       return;
     }
 
+  /* if the type is a bit register */
+  if (sym->regType == REG_BIT)
+    {
+      sym->aop = op->aop = aop = newAsmop (AOP_CRY);
+      aop->size = sym->nRegs;//1???
+      aop->aopu.aop_reg[0] = sym->regs[0];
+      aop->aopu.aop_dir = sym->regs[0]->name;
+      return;
+    }
+
   /* must be in a register */
   sym->aop = op->aop = aop = newAsmop (AOP_REG);
   aop->size = sym->nRegs;
@@ -862,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)
 {
@@ -876,20 +1055,20 @@ 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:
-      if (_G.r0InB)
+      if (R0INB)
         {
           emitcode ("mov", "r0,b");
-          _G.r0InB--;
+          R0INB--;
         }
       else if (_G.r0Pushed)
         {
@@ -903,12 +1082,12 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
       break;
 
     case AOP_R1:
-      if (_G.r1InB)
+      if (R1INB)
         {
           emitcode ("mov", "r1,b");
-          _G.r1InB--;
+          R1INB--;
         }
-      if (_G.r1Pushed)
+      else if (_G.r1Pushed)
         {
           if (pop)
             {
@@ -954,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:
@@ -995,13 +1174,13 @@ freeForBranchAsmop (operand * op)
   if (!aop)
     return;
 
-  if (aop->freed)
+  if (!aop->allocated)
     return;
 
   switch (aop->type)
     {
     case AOP_R0:
-      if (_G.r0InB)
+      if (R0INB)
         {
           emitcode ("mov", "r0,b");
         }
@@ -1012,7 +1191,7 @@ freeForBranchAsmop (operand * op)
       break;
 
     case AOP_R1:
-      if (_G.r1InB)
+      if (R1INB)
         {
           emitcode ("mov", "r1,b");
         }
@@ -1058,8 +1237,10 @@ freeForBranchAsmop (operand * op)
 /*                 clobber the accumulator                         */
 /*-----------------------------------------------------------------*/
 static bool
-aopGetUsesAcc (asmop *aop, int offset)
+aopGetUsesAcc (operand * oper, int offset)
 {
+  asmop * aop = AOP (oper);
+
   if (offset > (aop->size - 1))
     return FALSE;
 
@@ -1083,6 +1264,8 @@ aopGetUsesAcc (asmop *aop, int offset)
     case AOP_CRY:
       return TRUE;
     case AOP_ACC:
+      if (offset)
+        return FALSE;
       return TRUE;
     case AOP_LIT:
       return FALSE;
@@ -1099,14 +1282,13 @@ aopGetUsesAcc (asmop *aop, int offset)
     }
 }
 
-/*-----------------------------------------------------------------*/
-/* aopGet - for fetching value of the aop                          */
-/*-----------------------------------------------------------------*/
+/*-------------------------------------------------------------------*/
+/* aopGet - for fetching value of the aop                            */
+/*-------------------------------------------------------------------*/
 static char *
-aopGet (asmop * aop, int offset, bool bit16, bool dname)
+aopGet (operand * oper, int offset, bool bit16, bool dname)
 {
-  char *s = buffer;
-  char *rs;
+  asmop * aop = AOP (oper);
 
   /* offset is greater than
      size then zero */
@@ -1141,10 +1323,8 @@ aopGet (asmop * aop, 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) {
@@ -1177,33 +1357,54 @@ aopGet (asmop * aop, 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 (offset)
-        sprintf (s, "(%s + %d)",
-                 aop->aopu.aop_dir,
-                 offset);
+      if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset)
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "(%s >> %d)",
+                    aop->aopu.aop_dir, offset * 8);
+        }
+      else if (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)
@@ -1212,8 +1413,8 @@ aopGet (asmop * aop, 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");
 
@@ -1239,13 +1440,60 @@ aopGet (asmop * aop, int offset, bool bit16, bool dname)
           "aopget got unsupported aop->type");
   exit (1);
 }
+
 /*-----------------------------------------------------------------*/
-/* aopPut - puts a string for a aop                                */
+/* aopPutUsesAcc - indicates ahead of time whether aopPut() will   */
+/*                 clobber the accumulator                         */
 /*-----------------------------------------------------------------*/
-static void
-aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
+static bool
+aopPutUsesAcc (operand * oper, const char *s, int offset)
+{
+  asmop * aop = AOP (oper);
+
+  if (offset > (aop->size - 1))
+    return FALSE;
+
+  switch (aop->type)
+    {
+    case AOP_DUMMY:
+      return TRUE;
+    case AOP_DIR:
+      return FALSE;
+    case AOP_REG:
+      wassert(strcmp(aop->aopu.aop_reg[offset]->name, "a"));
+      return FALSE;
+    case AOP_DPTR:
+      return TRUE;
+    case AOP_R0:
+    case AOP_R1:
+      return ((aop->paged) || (*s == '@'));
+    case AOP_STK:
+      return (*s == '@');
+    case AOP_CRY:
+      return (!aop->aopu.aop_dir || strcmp(s, aop->aopu.aop_dir));
+    case AOP_STR:
+      return FALSE;
+    case AOP_IMMD:
+      return FALSE;
+    case AOP_ACC:
+      return FALSE;
+    default:
+      /* Error case --- will have been caught already */
+      wassert(0);
+      return FALSE;
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* aopPut - puts a string for a aop and indicates if acc is in use */
+/*-----------------------------------------------------------------*/
+static bool
+aopPut (operand * result, const char *s, int offset)
 {
-  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))
     {
@@ -1260,19 +1508,37 @@ aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
     {
     case AOP_DUMMY:
       MOVA (s);         /* read s in case it was volatile */
+      accuse = TRUE;
       break;
 
     case AOP_DIR:
-      if (offset)
-        sprintf (d, "(%s + %d)",
-                 aop->aopu.aop_dir, offset);
+      if (SPEC_SCLS (getSpec (operandType (result))) == S_SFR && offset)
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "(%s >> %d)",
+                    aop->aopu.aop_dir, offset * 8);
+        }
+      else if (offset)
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "(%s + %d)",
+                    aop->aopu.aop_dir, offset);
+        }
       else
-        sprintf (d, "%s", aop->aopu.aop_dir);
-
-      if (strcmp (d, s) ||
-          bvolatile)
-          emitcode ("mov", "%s,%s", d, s);
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "%s",
+                    aop->aopu.aop_dir);
+        }
 
+      if (strcmp (buffer, s) || bvolatile)
+        {
+          emitcode ("mov", "%s,%s", buffer, s);
+        }
+      if (!strcmp (buffer, "acc"))
+        {
+          accuse = TRUE;
+        }
       break;
 
     case AOP_REG:
@@ -1288,11 +1554,15 @@ aopPut (asmop * aop, 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;
 
@@ -1318,7 +1588,7 @@ aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
 
       aop->coff = offset;
 
-      /* if not in accumulater */
+      /* if not in accumulator */
       MOVA (s);
 
       emitcode ("movx", "@dptr,a");
@@ -1342,7 +1612,6 @@ aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
         {
           MOVA (s);
           emitcode ("movx", "@%s,a", aop->aopu.aop_ptr->name);
-
         }
       else if (*s == '@')
         {
@@ -1359,73 +1628,97 @@ aopPut (asmop * aop, 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=='@') {
-          MOVA(s);
+        {
           emitcode ("push", "acc");
-        } else {
-          emitcode ("push", s);
         }
-
-      break;
-
-    case AOP_CRY:
-      /* if bit variable */
-      if (!aop->aopu.aop_dir)
+      else if (*s=='@')
         {
-          emitcode ("clr", "a");
-          emitcode ("rlc", "a");
+          MOVA(s);
+          emitcode ("push", "acc");
         }
-      else
-        {
-          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, "a"))
-                {
-                  MOVA (s);
-                }
-              {
-                /* set C, if a >= 1 */
-                emitcode ("add", "a,#0xff");
-                emitcode ("mov", "%s,c", aop->aopu.aop_dir);
-              }
+      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:
+      // 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"))
+        {
+          MOVA (s);
+          /* set C, if a >= 1 */
+          emitcode ("add", "a,#0xff");
+          s = "c";
+        }
+      // now source is zero, one or carry
+
+      /* if result no bit variable */
+      if (!d)
+        {
+          if (!strcmp (s, "c"))
+            {
+              /* inefficient: move carry into A and use jz/jnz */
+              emitcode ("clr", "a");
+              emitcode ("rlc", "a");
+              accuse = TRUE;
+            }
+          else
+            {
+              MOVA (s);
+              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;
 
@@ -1435,6 +1728,7 @@ aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
       exit (1);
     }
 
+    return accuse;
 }
 
 
@@ -1472,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)
@@ -1492,30 +1786,14 @@ reAdjustPreg (asmop * aop)
   aop->coff = 0;
 }
 
-#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))
-
-#define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY ||  \
-                        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) )))
-
-
 /*-----------------------------------------------------------------*/
-/* 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;
     }
@@ -1528,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);
@@ -1554,13 +1832,13 @@ outAcc (operand * result)
   size = getDataSize (result);
   if (size)
     {
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);
       size--;
       offset = 1;
       /* unsigned or positive */
       while (size--)
         {
-          aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+          aopPut (result, zero, offset++);
         }
     }
 }
@@ -1573,8 +1851,11 @@ outBitC (operand * result)
 {
   /* if the result is bit */
   if (AOP_TYPE (result) == AOP_CRY)
-    aopPut (AOP (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");
@@ -1595,32 +1876,111 @@ toBoolean (operand * oper)
 
   while (!AccUsed && size--)
     {
-      AccUsed |= aopGetUsesAcc(AOP (oper), offset++);
+      AccUsed |= aopGetUsesAcc(oper, offset++);
     }
 
   size = AOP_SIZE (oper) - 1;
   offset = 1;
-  MOVA (aopGet (AOP (oper), 0, FALSE, FALSE));
-  if (AccUsed && (AOP (oper)->type != AOP_ACC))
+  MOVA (aopGet (oper, 0, FALSE, FALSE));
+  if (size && AccUsed && (AOP (oper)->type != AOP_ACC))
     {
       pushedB = pushB ();
       emitcode("mov", "b,a");
-      while (size--)
+      while (--size)
         {
-          MOVA (aopGet (AOP (oper), offset++, FALSE, FALSE));
+          MOVA (aopGet (oper, offset++, FALSE, FALSE));
           emitcode ("orl", "b,a");
         }
+      MOVA (aopGet (oper, offset++, FALSE, FALSE));
+      emitcode ("orl", "a,b");
       popB (pushedB);
     }
   else
     {
       while (size--)
         {
-          emitcode ("orl", "a,%s", aopGet (AOP (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                          */
@@ -1630,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);
@@ -1639,23 +1999,32 @@ genNot (iCode * ic)
   /* if in bit space then a special case */
   if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
     {
-      emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
-      emitcode ("cpl", "c");
-      outBitC (IC_RESULT (ic));
+      /* if left==result then cpl bit */
+      if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
+        {
+          emitcode ("cpl", "%s", IC_LEFT (ic)->aop->aopu.aop_dir);
+        }
+      else
+        {
+          toCarry (IC_LEFT (ic));
+          emitcode ("cpl", "c");
+          outBitC (IC_RESULT (ic));
+        }
       goto release;
     }
 
   toBoolean (IC_LEFT (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));
 }
 
 
@@ -1668,8 +2037,9 @@ genCpl (iCode * ic)
   int offset = 0;
   int size;
   symbol *tlbl;
+  sym_link *letype = getSpec (operandType (IC_LEFT (ic)));
 
-  D(emitcode (";     genCpl",""));
+  D(emitcode (";", "genCpl"));
 
   /* assign asmOps to operand & result */
   aopOp (IC_LEFT (ic), ic, FALSE);
@@ -1678,29 +2048,33 @@ genCpl (iCode * ic)
   /* special case if in bit space */
   if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
     {
-      if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
+      char *l;
+
+      if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY ||
+          (SPEC_USIGN (letype) && IS_CHAR (letype)))
         {
-          /* promotion rules are responsible for this strange result: */
+          /* promotion rules are responsible for this strange result:
+             bit -> int -> ~int -> bit
+             uchar -> int -> ~int -> bit
+          */
           emitcode ("setb", "%s", IC_RESULT (ic)->aop->aopu.aop_dir);
           goto release;
         }
 
       tlbl=newiTempLabel(NULL);
-      if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC ||
+      l = aopGet (IC_LEFT (ic), offset++, FALSE, FALSE);
+      if ((AOP_TYPE (IC_LEFT (ic)) == AOP_ACC && offset == 0) ||
           AOP_TYPE (IC_LEFT (ic)) == AOP_REG ||
           IS_AOP_PREG (IC_LEFT (ic)))
         {
-          emitcode ("cjne", "%s,#0x01,%05d$",
-                    aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE),
-                    tlbl->key + 100);
+          emitcode ("cjne", "%s,#0xFF,%05d$", l, tlbl->key + 100);
         }
       else
         {
-          char *l = aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE);
           MOVA (l);
-          emitcode ("cjne", "a,#0x01,%05d$", tlbl->key + 100);
+          emitcode ("cjne", "a,#0xFF,%05d$", tlbl->key + 100);
         }
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitLabel (tlbl);
       outBitC (IC_RESULT(ic));
       goto release;
     }
@@ -1708,17 +2082,17 @@ genCpl (iCode * ic)
   size = AOP_SIZE (IC_RESULT (ic));
   while (size--)
     {
-      char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE);
+      char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("cpl", "a");
-      aopPut (AOP (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));
 }
 
 /*-----------------------------------------------------------------*/
@@ -1730,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 */
 
@@ -1738,19 +2112,17 @@ genUminusFloat (operand * op, operand * result)
 
   while (size--)
     {
-      aopPut (AOP (result),
-              aopGet (AOP (op), offset, FALSE, FALSE),
-              offset,
-              isOperandVolatile (result, FALSE));
+      aopPut (result,
+              aopGet (op, offset, FALSE, FALSE),
+              offset);
       offset++;
     }
 
-  l = aopGet (AOP (op), offset, FALSE, FALSE);
-
+  l = aopGet (op, offset, FALSE, FALSE);
   MOVA (l);
 
   emitcode ("cpl", "acc.7");
-  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offset);
 }
 
 /*-----------------------------------------------------------------*/
@@ -1760,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);
@@ -1782,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))
@@ -1794,16 +2164,15 @@ genUminus (iCode * ic)
   /* otherwise subtract from zero */
   size = AOP_SIZE (IC_LEFT (ic));
   offset = 0;
-  //CLRC ;
   while (size--)
     {
-      char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE);
+      char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
       if (!strcmp (l, "a"))
         {
           if (offset == 0)
             SETC;
           emitcode ("cpl", "a");
-          emitcode ("addc", "a,#0");
+          emitcode ("addc", "a,#0x00");
         }
       else
         {
@@ -1812,7 +2181,7 @@ genUminus (iCode * ic)
           emitcode ("clr", "a");
           emitcode ("subb", "a,%s", l);
         }
-      aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), "a", offset++);
     }
 
   /* if any remaining bytes in the result */
@@ -1822,13 +2191,13 @@ genUminus (iCode * ic)
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
-        aopPut (AOP (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));
 }
 
 /*-----------------------------------------------------------------*/
@@ -1857,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
@@ -1869,12 +2238,30 @@ 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)
         {
-          i = bitVectFirstBit (rsave);
-          emitcode ("mov", "a,%s", mcs51_regWithIdx (i)->name);
+          regs * reg = REG_WITH_INDEX (bitVectFirstBit (rsave));
+          if (reg->type == REG_BIT)
+            {
+              emitcode ("mov", "a,%s", reg->base);
+            }
+          else
+            {
+              emitcode ("mov", "a,%s", reg->name);
+            }
           emitcode ("mov", "r0,%s", spname);
           emitcode ("inc", "%s", spname);// allocate before use
           emitcode ("movx", "@r0,a");
@@ -1885,24 +2272,29 @@ saveRegisters (iCode * lic)
         {
           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 = REG_WITH_INDEX (i);
                   if (i == R0_IDX)
                     {
                       emitcode ("pop", "acc");
                       emitcode ("push", "acc");
                     }
+                  else if (reg->type == REG_BIT)
+                    {
+                      emitcode ("mov", "a,%s", reg->base);
+                    }
                   else
                     {
-                      emitcode ("mov", "a,%s", mcs51_regWithIdx (i)->name);
+                      emitcode ("mov", "a,%s", reg->name);
                     }
                   emitcode ("movx", "@r0,a");
                   if (--count)
@@ -1913,16 +2305,22 @@ 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);
             }
         }
     }
   else
-    for (i = 0; i < mcs51_nRegs; i++)
-      {
-        if (bitVectBitValue (rsave, i))
-          emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
-      }
+    {
+      bool bits_pushed = FALSE;
+      for (i = 0; i < mcs51_nRegs; i++)
+        {
+          if (bitVectBitValue (rsave, i))
+            {
+              bits_pushed = pushReg (i, bits_pushed);
+            }
+        }
+    }
+  freeBitVect (rsave);
 }
 
 /*-----------------------------------------------------------------*/
@@ -1941,56 +2339,111 @@ 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 = REG_WITH_INDEX (bitVectFirstBit (rsave));
           emitcode ("mov", "r0,%s", spname);
           emitcode ("dec", "r0");
           emitcode ("movx", "a,@r0");
-          i = bitVectFirstBit (rsave);
-          emitcode ("mov", "%s,a", mcs51_regWithIdx (i)->name);
+          if (reg->type == REG_BIT)
+            {
+              emitcode ("mov", "%s,a", reg->base);
+            }
+          else
+            {
+              emitcode ("mov", "%s,a", reg->name);
+            }
           emitcode ("dec", "%s", spname);
         }
-      else
+      else if (count != 0)
         {
           emitcode ("mov", "r0,%s", spname);
           for (i = mcs51_nRegs; i >= 0; i--)
             {
               if (bitVectBitValue (rsave, i))
                 {
+                  regs * reg = REG_WITH_INDEX (i);
                   emitcode ("dec", "r0");
                   emitcode ("movx", "a,@r0");
-                  if (i != R0_IDX)
-                    emitcode ("mov", "%s,a", mcs51_regWithIdx (i)->name);
+                  if (i == R0_IDX)
+                    {
+                      emitcode ("push", "acc");
+                    }
+                  else if (reg->type == REG_BIT)
+                    {
+                      emitcode ("mov", "%s,a", reg->base);
+                    }
+                  else
+                    {
+                      emitcode ("mov", "%s,a", reg->name);
+                    }
                 }
             }
           emitcode ("mov", "%s,r0", spname);
           if (bitVectBitValue (rsave, R0_IDX))
             {
-              emitcode ("mov", "r0,a");
+              emitcode ("pop", "ar0");
             }
         }
     }
   else
-    for (i = mcs51_nRegs; i >= 0; i--)
-      {
-        if (bitVectBitValue (rsave, i))
-          emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
-      }
+    {
+      bool bits_popped = FALSE;
+      for (i = mcs51_nRegs; i >= 0; i--)
+        {
+          if (bitVectBitValue (rsave, i))
+            {
+              bits_popped = popReg (i, bits_popped);
+            }
+        }
+    }
+  freeBitVect (rsave);
 }
 
 
 /*-----------------------------------------------------------------*/
-/* pushSide -                */
+/* 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 (AOP (oper), offset++, FALSE, TRUE);
+      char *l = aopGet (oper, offset++, FALSE, TRUE);
       if (AOP_TYPE (oper) != AOP_REG &&
           AOP_TYPE (oper) != AOP_DIR &&
           strcmp (l, "a"))
@@ -1999,23 +2452,44 @@ pushSide (operand * oper, int size)
           emitcode ("push", "acc");
         }
       else
+        {
           emitcode ("push", "%s", l);
         }
     }
 
+  freeAsmop (oper, NULL, ic, TRUE);
+}
+
 /*-----------------------------------------------------------------*/
-/* assignResultValue -               */
+/* assignResultValue - also indicates if acc is in use afterwards  */
 /*-----------------------------------------------------------------*/
-static void
-assignResultValue (operand * oper)
+static bool
+assignResultValue (operand * oper, operand * func)
 {
   int offset = 0;
   int size = AOP_SIZE (oper);
+  bool accuse = FALSE;
+  bool pushedA = FALSE;
+
+  if (func && IS_BIT (OP_SYM_ETYPE (func)))
+    {
+      outBitC (oper);
+      return FALSE;
+    }
+
+  if ((size > 3) && aopPutUsesAcc (oper, fReturn[offset], offset))
+    {
+      emitcode ("push", "acc");
+      pushedA = TRUE;
+    }
   while (size--)
     {
-      aopPut (AOP (oper), fReturn[offset], offset, isOperandVolatile (oper, FALSE));
+      if ((offset == 3) && pushedA)
+        emitcode ("pop", "acc");
+      accuse |= aopPut (oper, fReturn[offset], offset);
       offset++;
     }
+  return accuse;
 }
 
 
@@ -2029,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);
@@ -2038,7 +2512,7 @@ genXpush (iCode * ic)
 
   if (size == 1)
     {
-      MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
+      MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
       emitcode ("mov", "%s,%s", r->name, spname);
       emitcode ("inc", "%s", spname); // allocate space first
       emitcode ("movx", "@%s,a", r->name);
@@ -2048,12 +2522,12 @@ 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--)
         {
-          MOVA (aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, FALSE));
+          MOVA (aopGet (IC_LEFT (ic), offset++, FALSE, FALSE));
           emitcode ("movx", "@%s,a", r->name);
           emitcode ("inc", "%s", r->name);
         }
@@ -2064,15 +2538,16 @@ genXpush (iCode * ic)
 }
 
 /*-----------------------------------------------------------------*/
-/* genIpush - genrate code for pushing this gets a little complex  */
+/* genIpush - generate code for pushing this gets a little complex */
 /*-----------------------------------------------------------------*/
 static void
 genIpush (iCode * ic)
 {
   int size, offset = 0;
   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 */
@@ -2088,7 +2563,7 @@ genIpush (iCode * ic)
       /* push it on the stack */
       while (size--)
         {
-          l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE);
+          l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE);
           if (*l == '#')
             {
               MOVA (l);
@@ -2099,7 +2574,7 @@ genIpush (iCode * ic)
       return;
     }
 
-  /* this is a paramter push: in this case we call
+  /* this is a parameter push: in this case we call
      the routine to find the call and save those
      registers that need to be saved */
   saveRegisters (ic);
@@ -2120,16 +2595,19 @@ genIpush (iCode * ic)
 
   while (size--)
     {
-      l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE);
+      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)
         {
-          MOVA (l);
+          if (strcmp (l, prev) || *l == '@')
+            MOVA (l);
           emitcode ("push", "acc");
         }
       else
+        {
           emitcode ("push", "%s", l);
+        }
+      prev = l;
     }
 
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
@@ -2143,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)
@@ -2153,12 +2631,29 @@ genIpop (iCode * ic)
   size = AOP_SIZE (IC_LEFT (ic));
   offset = (size - 1);
   while (size--)
-    emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--,
-                                   FALSE, TRUE));
+    {
+      emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--,
+                                     FALSE, TRUE));
+    }
 
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
 }
 
+/*-----------------------------------------------------------------*/
+/* 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          */
 /*-----------------------------------------------------------------*/
@@ -2166,30 +2661,30 @@ 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)
         {
@@ -2210,7 +2705,6 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
         {
           emitcode ("mov", "a,psw");
           emitcode ("movx", "@%s,a", r->name);
-
         }
       else
         {
@@ -2226,9 +2720,9 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
     }
 
   if (ic)
-  {
-    ic->bankSaved = 1;
-  }
+    {
+      ic->bankSaved = 1;
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -2246,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
         {
@@ -2270,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)
         {
@@ -2302,31 +2796,103 @@ unsaveRBank (int bank, iCode * ic, bool popPsw)
 /*-----------------------------------------------------------------*/
 static void genSend(set *sendSet)
 {
-    iCode *sic;
-    int rb1_count = 0 ;
+  iCode *sic;
+  int bit_count = 0;
+
+  /* first we do all bit parameters */
+  for (sic = setFirstItem (sendSet); sic;
+       sic = setNextItem (sendSet))
+    {
+      if (sic->argreg > 12)
+        {
+          int bit = sic->argreg-13;
+
+          aopOp (IC_LEFT (sic), sic, FALSE);
 
-    for (sic = setFirstItem (sendSet); sic;
-         sic = setNextItem (sendSet)) {
+          /* if left is a literal then
+             we know what the value is */
+          if (AOP_TYPE (IC_LEFT (sic)) == AOP_LIT)
+            {
+              if (((int) operandLitValue (IC_LEFT (sic))))
+                  emitcode ("setb", "b[%d]", bit);
+              else
+                  emitcode ("clr", "b[%d]", bit);
+            }
+          else
+            {
+              /* we need to or */
+              toCarry (IC_LEFT (sic));
+              emitcode ("mov", "b[%d],c", bit);
+            }
+          bit_count++;
+          BitBankUsed = 1;
+
+          freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+        }
+    }
+
+  if (options.useXstack || bit_count)
+    {
+      saveRegisters (setFirstItem (sendSet));
+    }
+
+  if (bit_count)
+    {
+      emitcode ("mov", "bits,b");
+    }
+
+  /* then we do all other parameters */
+  for (sic = setFirstItem (sendSet); sic;
+       sic = setNextItem (sendSet))
+    {
+      if (sic->argreg <= 12)
+        {
           int size, offset = 0;
           aopOp (IC_LEFT (sic), sic, FALSE);
           size = AOP_SIZE (IC_LEFT (sic));
 
-          if (sic->argreg == 1) {
-              while (size--) {
-                  char *l = aopGet (AOP (IC_LEFT (sic)), offset,
-                                    FALSE, FALSE);
+          if (sic->argreg == 1)
+            {
+              while (size--)
+                {
+                  char *l = aopGet (IC_LEFT (sic), offset, FALSE, FALSE);
                   if (strcmp (l, fReturn[offset]))
+                    {
                       emitcode ("mov", "%s,%s", fReturn[offset], l);
+                    }
                   offset++;
-              }
-              rb1_count = 0;
-          } else {
-              while (size--) {
-                  emitcode ("mov","b1_%d,%s",rb1_count++,
-                            aopGet (AOP (IC_LEFT (sic)), offset++,FALSE, FALSE));
-              }
-          }
+                }
+            }
+          else
+            {
+              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);
+        }
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* selectRegBank - emit code to select the register bank           */
+/*-----------------------------------------------------------------*/
+static void
+selectRegBank (short bank, bool keepFlags)
+{
+  /* if f.e. result is in carry */
+  if (keepFlags)
+    {
+      emitcode ("anl", "psw,#0xE7");
+      if (bank)
+        emitcode ("orl", "psw,#0x%02x", (bank << 3) & 0xff);
+    }
+  else
+    {
+      emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0xff);
     }
 }
 
@@ -2337,12 +2903,18 @@ static void
 genCall (iCode * ic)
 {
   sym_link *dtype;
+  sym_link *etype;
 //  bool restoreBank = FALSE;
   bool swapBanks = FALSE;
+  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);
   /* if send set is not empty then assign */
   if (_G.sendSet)
     {
@@ -2351,44 +2923,62 @@ genCall (iCode * ic)
         } else {
             genSend(_G.sendSet);
         }
-
       _G.sendSet = NULL;
     }
 
   /* 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 */
-  dtype = operandType (IC_LEFT (ic));
   if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
       (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
        !IFFUNC_ISISR (dtype))
-  {
+    {
       swapBanks = TRUE;
-  }
+    }
 
   /* if caller saves & we have not saved then */
   if (!ic->regsSaved)
       saveRegisters (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 */
-  emitcode ("lcall", "%s", (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
-                            OP_SYMBOL (IC_LEFT (ic))->rname :
-                            OP_SYMBOL (IC_LEFT (ic))->name));
+  if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT(getSpec(dtype)))
+    {
+      if (IFFUNC_CALLEESAVES(dtype))
+        {
+          werror (E_BANKED_WITH_CALLEESAVES);
+        }
+      else
+        {
+          char *l = (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
+                     OP_SYMBOL (IC_LEFT (ic))->rname :
+                     OP_SYMBOL (IC_LEFT (ic))->name);
+
+          emitcode ("mov", "r0,#%s", l);
+          emitcode ("mov", "r1,#(%s >> 8)", l);
+          emitcode ("mov", "r2,#(%s >> 16)", l);
+          emitcode ("lcall", "__sdcc_banked_call");
+        }
+    }
+  else
+    {
+      emitcode ("lcall", "%s", (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
+                                OP_SYMBOL (IC_LEFT (ic))->rname :
+                                OP_SYMBOL (IC_LEFT (ic))->name));
+    }
 
   if (swapBanks)
-  {
-       emitcode ("mov", "psw,#0x%02x",
-          ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
-  }
+    {
+      selectRegBank (FUNC_REGBANK(currFunc->type), IS_BIT (etype));
+    }
 
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
+       !IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
         OP_SYMBOL (IC_RESULT (ic))->accuse ||
         OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
@@ -2399,49 +2989,95 @@ genCall (iCode * ic)
       aopOp (IC_RESULT (ic), ic, FALSE);
       _G.accInUse--;
 
-      assignResultValue (IC_RESULT (ic));
+      accuse = assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
+      assignResultGenerated = TRUE;
 
       freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
     }
 
-  /* adjust the stack for parameters if
-     required */
+  /* adjust the stack for parameters if required */
   if (ic->parmBytes)
     {
       int i;
       if (ic->parmBytes > 3)
         {
+          if (accuse)
+            {
+              emitcode ("push", "acc");
+              accPushed = TRUE;
+            }
+          if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) &&
+              IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) &&
+              !assignResultGenerated)
+            {
+              emitcode ("mov", "F0,c");
+              resultInF0 = TRUE;
+            }
+
           emitcode ("mov", "a,%s", spname);
           emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
           emitcode ("mov", "%s,a", spname);
+
+          /* unsaveRegisters from xstack needs acc, but */
+          /* unsaveRegisters from stack needs this popped */
+          if (accPushed && !options.useXstack)
+            {
+              emitcode ("pop", "acc");
+              accPushed = FALSE;
+            }
         }
       else
         for (i = 0; i < ic->parmBytes; i++)
           emitcode ("dec", "%s", spname);
     }
 
-  /* if we hade saved some registers then unsave them */
+  /* if we had saved some registers then unsave them */
   if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
-    unsaveRegisters (ic);
+    {
+      if (accuse && !accPushed && options.useXstack)
+        {
+          /* xstack needs acc, but doesn't touch normal stack */
+          emitcode ("push", "acc");
+          accPushed = TRUE;
+        }
+      unsaveRegisters (ic);
+    }
 
 //  /* if register bank was saved then pop them */
 //  if (restoreBank)
 //    unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
+
+  if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) && !assignResultGenerated)
+    {
+      if (resultInF0)
+          emitcode ("mov", "c,F0");
+
+      aopOp (IC_RESULT (ic), ic, FALSE);
+      assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
+      freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+    }
+
+  if (accPushed)
+    emitcode ("pop", "acc");
 }
 
 /*-----------------------------------------------------------------*/
-/* -10l - generates a call by pointer statement                */
+/* genPcall - generates a call by pointer statement                */
 /*-----------------------------------------------------------------*/
 static void
 genPcall (iCode * ic)
 {
   sym_link *dtype;
+  sym_link *etype;
   symbol *rlbl = newiTempLabel (NULL);
 //  bool restoreBank=FALSE;
   bool swapBanks = FALSE;
+  bool resultInF0 = FALSE;
 
-  D(emitcode(";     genPCall",""));
+  D (emitcode (";", "genPcall"));
 
+  dtype = operandType (IC_LEFT (ic))->next;
+  etype = getSpec(dtype);
   /* if caller saves & we have not saved then */
   if (!ic->regsSaved)
     saveRegisters (ic);
@@ -2449,56 +3085,167 @@ 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 */
-  dtype = operandType (IC_LEFT (ic))->next;
-  if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
+  if (currFunc && dtype && !IFFUNC_ISNAKED (dtype) &&
       (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
       !IFFUNC_ISISR (dtype))
-  {
+    {
 //    saveRBank (FUNC_REGBANK (dtype), ic, TRUE);
 //    restoreBank=TRUE;
       swapBanks = TRUE;
       // need caution message to user here
-  }
-
-  /* push the return address on to the stack */
-  emitcode ("mov", "a,#%05d$", (rlbl->key + 100));
-  emitcode ("push", "acc");
-  emitcode ("mov", "a,#(%05d$ >> 8)", (rlbl->key + 100));
-  emitcode ("push", "acc");
+    }
 
-  /* now push the calling address */
-  aopOp (IC_LEFT (ic), ic, FALSE);
+  if (IS_LITERAL (etype))
+    {
+      /* if send set is not empty then assign */
+      if (_G.sendSet)
+        {
+          genSend(reverseSet(_G.sendSet));
+          _G.sendSet = NULL;
+        }
 
-  pushSide (IC_LEFT (ic), FPTRSIZE);
+      if (swapBanks)
+        {
+          emitcode ("mov", "psw,#0x%02x",
+           ((FUNC_REGBANK (dtype)) << 3) & 0xff);
+        }
 
-  freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+      if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT (getSpec(dtype)))
+        {
+          if (IFFUNC_CALLEESAVES (dtype))
+            {
+              werror (E_BANKED_WITH_CALLEESAVES);
+            }
+          else
+            {
+              char *l = aopLiteralLong (OP_VALUE (IC_LEFT (ic)), 0, 2);
 
-  /* if send set is not empty the assign */
-  if (_G.sendSet)
-    {
-        genSend(reverseSet(_G.sendSet));
-        _G.sendSet = NULL;
+              emitcode ("mov", "r0,#%s", l);
+              emitcode ("mov", "r1,#(%s >> 8)", l);
+              emitcode ("mov", "r2,#(%s >> 16)", l);
+              emitcode ("lcall", "__sdcc_banked_call");
+            }
+        }
+      else
+        {
+          emitcode ("lcall", "%s", aopLiteralLong (OP_VALUE (IC_LEFT (ic)), 0, 2));
+        }
     }
+  else
+    {
+      if (IFFUNC_ISBANKEDCALL (dtype) && !SPEC_STAT (getSpec(dtype)))
+        {
+          if (IFFUNC_CALLEESAVES (dtype))
+            {
+              werror (E_BANKED_WITH_CALLEESAVES);
+            }
+          else
+            {
+              aopOp (IC_LEFT (ic), ic, FALSE);
 
-  if (swapBanks)
-  {
-        emitcode ("mov", "psw,#0x%02x",
-           ((FUNC_REGBANK(dtype)) << 3) & 0xff);
-  }
+              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));
+                }
+              else
+                {
+                  int reg = ((FUNC_REGBANK(dtype)) << 3) & 0xff;
+                  emitcode ("mov", "0x%02x,%s", reg++, aopGet(IC_LEFT (ic), 0, FALSE, FALSE));
+                  emitcode ("mov", "0x%02x,%s", reg++, aopGet(IC_LEFT (ic), 1, FALSE, FALSE));
+                  emitcode ("mov", "0x%02x,%s", reg,   aopGet(IC_LEFT (ic), 2, FALSE, FALSE));
+                }
 
-  /* make the call */
-  emitcode ("ret", "");
-  emitcode ("", "%05d$:", (rlbl->key + 100));
+              freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+
+              /* if send set is not empty then assign */
+              if (_G.sendSet)
+                {
+                  genSend(reverseSet(_G.sendSet));
+                  _G.sendSet = NULL;
+                }
+
+              if (swapBanks)
+                {
+                  emitcode ("mov", "psw,#0x%02x",
+                   ((FUNC_REGBANK (dtype)) << 3) & 0xff);
+                }
+
+              /* make the call */
+              emitcode ("lcall", "__sdcc_banked_call");
+            }
+        }
+      else if (_G.sendSet)
+        {
+          /* push the return address on to the stack */
+          emitcode ("mov", "a,#%05d$", (rlbl->key + 100));
+          emitcode ("push", "acc");
+          emitcode ("mov", "a,#(%05d$ >> 8)", (rlbl->key + 100));
+          emitcode ("push", "acc");
+
+          /* now push the function address */
+          pushSide (IC_LEFT (ic), FPTRSIZE, ic);
+
+          /* if send set is not empty then assign */
+          if (_G.sendSet)
+            {
+              genSend(reverseSet(_G.sendSet));
+              _G.sendSet = NULL;
+            }
+
+          if (swapBanks)
+            {
+              emitcode ("mov", "psw,#0x%02x",
+               ((FUNC_REGBANK (dtype)) << 3) & 0xff);
+            }
+
+          /* make the call */
+          emitcode ("ret", "");
+          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)
-  {
-       emitcode ("mov", "psw,#0x%02x",
-          ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
-  }
+    {
+      selectRegBank (FUNC_REGBANK (currFunc->type), IS_BIT (etype));
+    }
 
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
+       !IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
         OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
       IS_TRUE_SYMOP (IC_RESULT (ic)))
@@ -2508,18 +3255,24 @@ genPcall (iCode * ic)
       aopOp (IC_RESULT (ic), ic, FALSE);
       _G.accInUse--;
 
-      assignResultValue (IC_RESULT (ic));
+      assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
 
       freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
     }
 
-  /* adjust the stack for parameters if
-     required */
+  /* adjust the stack for parameters if required */
   if (ic->parmBytes)
     {
       int i;
       if (ic->parmBytes > 3)
         {
+          if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))) &&
+              IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))))
+            {
+              emitcode ("mov", "F0,c");
+              resultInF0 = TRUE;
+            }
+
           emitcode ("mov", "a,%s", spname);
           emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
           emitcode ("mov", "%s,a", spname);
@@ -2527,17 +3280,25 @@ genPcall (iCode * ic)
       else
         for (i = 0; i < ic->parmBytes; i++)
           emitcode ("dec", "%s", spname);
-
     }
 
 //  /* if register bank was saved then unsave them */
 //  if (restoreBank)
 //    unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
 
-  /* if we hade saved some registers then
-     unsave them */
-  if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
+  /* if we had saved some registers then unsave them */
+  if (ic->regsSaved && !IFFUNC_CALLEESAVES (dtype))
     unsaveRegisters (ic);
+
+  if (IS_BIT (OP_SYM_ETYPE (IC_RESULT (ic))))
+    {
+      if (resultInF0)
+          emitcode ("mov", "c,F0");
+
+      aopOp (IC_RESULT (ic), ic, FALSE);
+      assignResultValue (IC_RESULT (ic), IC_LEFT (ic));
+      freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -2559,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   */
 /*-----------------------------------------------------------------*/
@@ -2608,6 +3363,7 @@ genFunction (iCode * ic)
   emitcode (";", "-----------------------------------------");
 
   emitcode ("", "%s:", sym->rname);
+  lineCurr->isLabel = 1;
   ftype = operandType (IC_LEFT (ic));
   _G.currentFunc = sym;
 
@@ -2626,15 +3382,18 @@ genFunction (iCode * ic)
       rbank = FUNC_REGBANK (ftype);
       for (i = 0; i < mcs51_nRegs; i++)
         {
-          if (strcmp (regs8051[i].base, "0") == 0)
-            emitcode ("", "%s = 0x%02x",
-                      regs8051[i].dname,
-                      8 * rbank + regs8051[i].offset);
-          else
-            emitcode ("", "%s = %s + 0x%02x",
-                      regs8051[i].dname,
-                      regs8051[i].base,
-                      8 * rbank + regs8051[i].offset);
+          if (regs8051[i].type != REG_BIT)
+            {
+              if (strcmp (regs8051[i].base, "0") == 0)
+                emitcode ("", "%s = 0x%02x",
+                          regs8051[i].dname,
+                          8 * rbank + regs8051[i].offset);
+              else
+                emitcode ("", "%s = %s + 0x%02x",
+                          regs8051[i].dname,
+                          regs8051[i].base,
+                          8 * rbank + regs8051[i].offset);
+            }
         }
     }
 
@@ -2642,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");
@@ -2656,14 +3424,13 @@ 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)
                 {
@@ -2671,26 +3438,26 @@ genFunction (iCode * ic)
                   for (i = 0; i < sym->regsUsed->size; i++)
                     {
                       if (bitVectBitValue (sym->regsUsed, i))
-                        emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
+                        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.
              *
@@ -2803,6 +3570,7 @@ genFunction (iCode * ic)
           /* if any registers used */
           if (sym->regsUsed)
             {
+              bool bits_pushed = FALSE;
               /* save the registers used */
               for (i = 0; i < sym->regsUsed->size; i++)
                 {
@@ -2811,7 +3579,7 @@ genFunction (iCode * ic)
                       /* remember one saved register for later usage */
                       if (calleesaves_saved_register < 0)
                         calleesaves_saved_register = i;
-                      emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
+                      bits_pushed = pushReg (i, bits_pushed);
                       _G.nRegsSaved++;
                     }
                 }
@@ -2819,24 +3587,34 @@ genFunction (iCode * ic)
         }
     }
 
-
   if (fReentrant)
     {
       if (options.useXstack)
         {
-          emitcode ("mov", "r0,%s", spname);
-          emitcode ("inc", "%s", spname);
-          emitcode ("xch", "a,_bp");
-          emitcode ("movx", "@r0,a");
-          emitcode ("inc", "r0");
-          emitcode ("mov", "a,r0");
-          emitcode ("xch", "a,_bp");
+          if (sym->xstack || FUNC_HASSTACKPARM(sym->type))
+            {
+              emitcode ("mov", "r0,%s", spname);
+              emitcode ("inc", "%s", spname);
+              emitcode ("xch", "a,_bpx");
+              emitcode ("movx", "@r0,a");
+              emitcode ("inc", "r0");
+              emitcode ("mov", "a,r0");
+              emitcode ("xch", "a,_bpx");
+            }
+          if (sym->stack)
+            {
+              emitcode ("push", "_bp");     /* save the callers stack  */
+              emitcode ("mov", "_bp,sp");
+            }
         }
       else
         {
-          /* set up the stack */
-          emitcode ("push", "_bp");     /* save the callers stack  */
-          emitcode ("mov", "_bp,%s", spname);
+          if (sym->stack || FUNC_HASSTACKPARM(sym->type))
+            {
+              /* set up the stack */
+              emitcode ("push", "_bp");     /* save the callers stack  */
+              emitcode ("mov", "_bp,sp");
+            }
         }
     }
 
@@ -2864,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"))
@@ -2889,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]);
@@ -2925,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 */
@@ -2958,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");
         }
@@ -2983,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 */
     }
 }
@@ -2999,7 +3777,6 @@ genEndFunction (iCode * ic)
   bitVect  *regsUsed;
   bitVect  *regsUsedPrologue;
   bitVect  *regsUnneeded;
-  int      accIsFree = sym->recvSize < 4;
   int      idx;
 
   _G.currentFunc = NULL;
@@ -3013,32 +3790,17 @@ genEndFunction (iCode * ic)
 
   if (IFFUNC_ISCRITICAL (sym->type))
     {
-      emitcode ("pop", "psw"); /* restore ea via c in psw */
-      emitcode ("mov", "ea,c");
-    }
-
-  if ((IFFUNC_ISREENT (sym->type) || options.stackAuto) && !options.useXstack)
-    {
-      emitcode ("mov", "%s,_bp", spname);
-    }
-
-  /* if use external stack but some variables were
-     added to the local stack then decrement the
-     local stack */
-  if (options.useXstack && sym->stack)
-    {
-      char count = sym->stack;
-
-      if ((count>3) && accIsFree)
+      if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))))
         {
-          emitcode ("mov", "a,sp");
-          emitcode ("add", "a,#0x%02x", ((char) -count) & 0xff);
-          emitcode ("mov", "sp,a");
+          emitcode ("rlc", "a");   /* save c in a */
+          emitcode ("pop", "psw"); /* restore ea via c in psw */
+          emitcode ("mov", "ea,c");
+          emitcode ("rrc", "a");   /* restore c from a */
         }
       else
         {
-          while (count--)
-            emitcode ("dec", "sp");
+          emitcode ("pop", "psw"); /* restore ea via c in psw */
+          emitcode ("mov", "ea,c");
         }
     }
 
@@ -3046,15 +3808,25 @@ genEndFunction (iCode * ic)
     {
       if (options.useXstack)
         {
-          emitcode ("xch", "a,_bp");
-          emitcode ("mov", "r0,a");
-          emitcode ("dec", "r0");
-          emitcode ("movx", "a,@r0");
-          emitcode ("xch", "a,_bp");
-          emitcode ("mov", "%s,r0", spname); //read before freeing stack space (interrupts)
+          if (sym->stack)
+            {
+              emitcode ("mov", "sp,_bp");
+              emitcode ("pop", "_bp");
+            }
+          if (sym->xstack || FUNC_HASSTACKPARM(sym->type))
+            {
+              emitcode ("xch", "a,_bpx");
+              emitcode ("mov", "r0,a");
+              emitcode ("dec", "r0");
+              emitcode ("movx", "a,@r0");
+              emitcode ("xch", "a,_bpx");
+              emitcode ("mov", "%s,r0", spname); //read before freeing stack space (interrupts)
+            }
         }
-      else
+      else if (sym->stack || FUNC_HASSTACKPARM(sym->type))
         {
+          if (sym->stack)
+            emitcode ("mov", "sp,_bp");
           emitcode ("pop", "_bp");
         }
     }
@@ -3062,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
@@ -3074,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
@@ -3081,13 +3854,12 @@ 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)
                 {
@@ -3095,25 +3867,26 @@ genEndFunction (iCode * ic)
                   for (i = sym->regsUsed->size; i >= 0; i--)
                     {
                       if (bitVectBitValue (sym->regsUsed, i))
-                        emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
+                        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.
              *
@@ -3149,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)
         {
@@ -3171,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);
             }
 
         }
@@ -3188,7 +3966,14 @@ genEndFunction (iCode * ic)
           debugFile->writeEndFunction (currFunc, ic, 1);
         }
 
-      emitcode ("ret", "");
+      if (IFFUNC_ISBANKEDCALL (sym->type) && !SPEC_STAT(getSpec(sym->type)))
+        {
+          emitcode ("ljmp", "__sdcc_banked_ret");
+        }
+      else
+        {
+          emitcode ("ret", "");
+        }
     }
 
   if (!port->peep.getRegsRead || !port->peep.getRegsWritten || options.nopeep)
@@ -3279,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);
@@ -3294,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" */
@@ -3306,28 +4091,31 @@ genRet (iCode * ic)
   aopOp (IC_LEFT (ic), ic, FALSE);
   size = AOP_SIZE (IC_LEFT (ic));
 
-  while (size--)
+  if (IS_BIT(_G.currentFunc->etype))
     {
-      char *l;
-      if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
-        {
-          /* #NOCHANGE */
-          l = aopGet (AOP (IC_LEFT (ic)), offset++,
-                      FALSE, TRUE);
-          emitcode ("push", "%s", l);
-          pushed++;
-        }
-      else
+      if (!IS_OP_RUONLY (IC_LEFT (ic)))
+        toCarry (IC_LEFT (ic));
+    }
+  else
+    {
+      while (size--)
         {
-          l = aopGet (AOP (IC_LEFT (ic)), offset,
-                      FALSE, FALSE);
-          if (strcmp (fReturn[offset], l))
-            emitcode ("mov", "%s,%s", fReturn[offset++], l);
+          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);
+            }
         }
-    }
 
-  if (pushed)
-    {
       while (pushed)
         {
           pushed--;
@@ -3359,7 +4147,7 @@ genLabel (iCode * ic)
   if (IC_LABEL (ic) == entryLabel)
     return;
 
-  emitcode ("", "%05d$:", (IC_LABEL (ic)->key + 100));
+  emitLabel (IC_LABEL (ic));
 }
 
 /*-----------------------------------------------------------------*/
@@ -3418,22 +4206,23 @@ genPlusIncr (iCode * ic)
   if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
     return FALSE;
 
-  /* 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)
-    return FALSE;
+  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) &&
       (icount == 1))
     {
       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
@@ -3443,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;
         }
@@ -3452,58 +4241,95 @@ genPlusIncr (iCode * ic)
           tlbl = newiTempLabel (NULL);
           emitTlbl = 1;
         }
-      emitcode ("inc", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE),
-                    tlbl->key + 100);
+          emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
         }
 
-      emitcode ("inc", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
-                      tlbl->key + 100);
+            {
+              emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
+            }
 
-          emitcode ("inc", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
-                        tlbl->key + 100);
+              emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
             }
-          emitcode ("inc", "%s", aopGet (AOP (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;
     }
 
+  /* if result is dptr */
+  if ((AOP_TYPE (IC_RESULT (ic)) == AOP_STR) &&
+      (AOP_SIZE (IC_RESULT (ic)) == 2) &&
+      !strncmp(AOP (IC_RESULT (ic))->aopu.aop_str[0], "dpl", 4) &&
+      !strncmp(AOP (IC_RESULT (ic))->aopu.aop_str[1], "dph", 4))
+    {
+      if (aopGetUsesAcc (IC_LEFT (ic), 0))
+        return FALSE;
+
+      if (icount > 9)
+        return FALSE;
+
+      if ((AOP_TYPE (IC_LEFT (ic)) != AOP_DIR) && (icount > 5))
+        return 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");
+
+      return TRUE;
+    }
+
+  /* if the literal value of the right hand side
+     is greater than 4 then it is not worth it */
+  if (icount > 4)
+    return FALSE;
+
   /* if the sizes are greater than 1 then we cannot */
   if (AOP_SIZE (IC_RESULT (ic)) > 1 ||
       AOP_SIZE (IC_LEFT (ic)) > 1)
@@ -3514,23 +4340,31 @@ genPlusIncr (iCode * ic)
      same */
   if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
     {
-
       if (icount > 3)
         {
-          MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
+          MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
           emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff);
-          aopPut (AOP (IC_RESULT (ic)), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", 0);
         }
       else
         {
-
           while (icount--)
-            emitcode ("inc", "%s", aopGet (AOP (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;
 }
 
@@ -3544,13 +4378,13 @@ outBitAcc (operand * result)
   /* if the result is a bit */
   if (AOP_TYPE (result) == AOP_CRY)
     {
-      aopPut (AOP (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);
     }
 }
@@ -3561,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));
     }
 }
@@ -3595,18 +4428,16 @@ adjustArithmeticResult (iCode * ic)
   if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
       AOP_SIZE (IC_LEFT (ic)) == 3 &&
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
-    aopPut (AOP (IC_RESULT (ic)),
-            aopGet (AOP (IC_LEFT (ic)), 2, FALSE, FALSE),
-            2,
-            isOperandVolatile (IC_RESULT (ic), FALSE));
+    aopPut (IC_RESULT (ic),
+            aopGet (IC_LEFT (ic)), 2, FALSE, 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 (AOP (IC_RESULT (ic)),
-            aopGet (AOP (IC_RIGHT (ic)), 2, FALSE, FALSE),
-            2,
-            isOperandVolatile (IC_RESULT (ic), FALSE));
+    aopPut (IC_RESULT (ic),
+            aopGet (IC_RIGHT (ic)), 2, FALSE, FALSE),
+            2);
 
   if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
       AOP_SIZE (IC_LEFT (ic)) < 3 &&
@@ -3615,8 +4446,8 @@ adjustArithmeticResult (iCode * ic)
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
     {
       char buffer[5];
-      sprintf (buffer, "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
-      aopPut (AOP (IC_RESULT (ic)), buffer, 2, isOperandVolatile (IC_RESULT (ic), FALSE));
+      sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
+      aopPut (IC_RESULT (ic), buffer, 2);
     }
 }
 #else
@@ -3627,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 (AOP (IC_RESULT (ic)),
-              aopGet (AOP (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 (AOP (IC_RESULT (ic)),
-              aopGet (AOP (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", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
-      aopPut (AOP (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
@@ -3669,12 +4523,13 @@ genPlus (iCode * ic)
   int size, offset = 0;
   int skip_bytes = 0;
   char *add = "add";
-  asmop *leftOp, *rightOp;
+  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);
@@ -3690,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
@@ -3709,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));
         }
@@ -3718,9 +4574,9 @@ genPlus (iCode * ic)
           size = getDataSize (IC_RESULT (ic));
           while (size--)
             {
-              MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
-              emitcode ("addc", "a,#00");
-              aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+              MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE));
+              emitcode ("addc", "a,%s", zero);
+              aopPut (IC_RESULT (ic), "a", offset++);
             }
         }
       goto release;
@@ -3732,9 +4588,9 @@ genPlus (iCode * ic)
     goto release;
 
   size = getDataSize (IC_RESULT (ic));
-  leftOp = AOP(IC_LEFT(ic));
-  rightOp = AOP(IC_RIGHT(ic));
-  op=IC_LEFT(ic);
+  leftOp = IC_LEFT(ic);
+  rightOp = IC_RIGHT(ic);
+  op = IC_LEFT(ic);
 
   /* if this is an add for an array access
      at a 256 byte boundary */
@@ -3746,24 +4602,22 @@ genPlus (iCode * ic)
        && (SPEC_ADDR (OP_SYM_ETYPE (op)) & 0xff) == 0
      )
     {
-      D(emitcode (";     genPlus aligned array",""));
-      aopPut (AOP (IC_RESULT (ic)),
+      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 (AOP (IC_RESULT (ic)),
+          aopPut (IC_RESULT (ic),
                   aopGet (leftOp, 1, FALSE, FALSE),
-                  1,
-                  isOperandVolatile (IC_RESULT (ic), FALSE));
+                  1);
         }
       else
         {
-          MOVA (aopGet (AOP (IC_LEFT (ic)), 1, FALSE, FALSE));
+          MOVA (aopGet (IC_LEFT (ic), 1, FALSE, FALSE));
           emitcode ("add", "a,%s", aopGet (rightOp, 1, FALSE, FALSE));
-          aopPut (AOP (IC_RESULT (ic)), "a", 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", 1);
         }
       goto release;
     }
@@ -3771,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--)
@@ -3804,7 +4658,7 @@ genPlus (iCode * ic)
               MOVA (aopGet (rightOp, offset, FALSE, TRUE));
               emitcode (add, "a,%s", aopGet (leftOp, offset, FALSE, TRUE));
             }
-          aopPut (AOP (IC_RESULT (ic)), "a", offset, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", offset);
           add = "addc";  /* further adds must propagate carry */
         }
       else
@@ -3813,10 +4667,9 @@ genPlus (iCode * ic)
               isOperandVolatile (IC_RESULT (ic), FALSE))
             {
               /* just move */
-              aopPut (AOP (IC_RESULT (ic)),
+              aopPut (IC_RESULT (ic),
                       aopGet (leftOp, offset, FALSE, FALSE),
-                      offset,
-                      isOperandVolatile (IC_RESULT (ic), FALSE));
+                      offset);
             }
         }
       offset++;
@@ -3825,13 +4678,21 @@ 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));
+    }
 }
 
 /*-----------------------------------------------------------------*/
-/* genMinusDec :- does subtraction with deccrement if possible     */
+/* genMinusDec :- does subtraction with decrement if possible      */
 /*-----------------------------------------------------------------*/
 static bool
 genMinusDec (iCode * ic)
@@ -3847,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
@@ -3870,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;
         }
@@ -3880,53 +4744,60 @@ genMinusDec (iCode * ic)
           emitTlbl = 1;
         }
 
-      emitcode ("dec", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE)
-                    ,tlbl->key + 100);
+          emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
         }
-      emitcode ("dec", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE)
-                        ,tlbl->key + 100);
+              emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
             }
-          emitcode ("dec", "%s", aopGet (AOP (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 (AOP (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 (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE)
-                        ,tlbl->key + 100);
+              emitcode ("cjne", "a,%s,%05d$", l, tlbl->key + 100);
             }
-          emitcode ("dec", "%s", aopGet (AOP (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;
     }
@@ -3941,13 +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 (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
+        {
+          emitcode ("dec", "%s", l);
+        }
+
+      if (AOP_NEEDSACC (IC_RESULT (ic)))
+        aopPut (IC_RESULT (ic), "a", 0);
 
       return TRUE;
     }
 
+  if (icount == 1)
+    {
+      MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
+      emitcode ("dec", "a");
+      aopPut (IC_RESULT (ic), "a", 0);
+      return TRUE;
+    }
+
   return FALSE;
 }
 
@@ -3965,11 +4860,17 @@ addSign (operand * result, int offset, int sign)
           emitcode ("rlc", "a");
           emitcode ("subb", "a,acc");
           while (size--)
-            aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+            {
+              aopPut (result, "a", offset++);
+            }
         }
       else
-        while (size--)
-          aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        {
+          while (size--)
+            {
+              aopPut (result, zero, offset++);
+            }
+        }
     }
 }
 
@@ -3981,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
@@ -3997,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 (AOP (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)))));
     }
 }
@@ -4011,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);
@@ -4037,34 +4938,52 @@ genMinus (iCode * ic)
   if (AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT)
     {
       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--)
         {
-          MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
-          /* first add without previous c */
-          if (!offset) {
-            if (!size && lit== (unsigned long) -1) {
-              emitcode ("dec", "a");
-            } else {
-              emitcode ("add", "a,#0x%02x",
-                        (unsigned int) (lit & 0x0FFL));
+          if (useCarry || ((lit >> (offset * 8)) & 0x0FFL))
+            {
+              MOVA (aopGet (IC_LEFT (ic), offset, FALSE, FALSE));
+              if (!offset && !size && lit== (unsigned long) -1)
+                {
+                  emitcode ("dec", "a");
+                }
+              else if (!useCarry)
+                {
+                  /* first add without previous c */
+                  emitcode ("add", "a,#0x%02x",
+                            (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+                  useCarry = TRUE;
+                }
+              else
+                {
+                  emitcode ("addc", "a,#0x%02x",
+                            (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+                }
+              aopPut (IC_RESULT (ic), "a", offset++);
+            }
+          else
+            {
+              /* no need to add zeroes */
+              if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
+                {
+                  aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), offset, FALSE, FALSE),
+                          offset);
+                }
+              offset++;
             }
-          } else {
-            emitcode ("addc", "a,#0x%02x",
-                      (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
-          }
-          aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
         }
     }
   else
     {
-      asmop *leftOp, *rightOp;
+      operand *leftOp, *rightOp;
 
-      leftOp = AOP(IC_LEFT(ic));
-      rightOp = AOP(IC_RIGHT(ic));
+      leftOp = IC_LEFT(ic);
+      rightOp = IC_RIGHT(ic);
 
       while (size--)
         {
@@ -4081,13 +5000,17 @@ genMinus (iCode * ic)
               emitcode ("subb", "a,b");
               popB (pushedB);
             } else {
+              /* reverse subtraction with 2's complement */
+              if (offset == 0)
+                emitcode( "setb", "c");
+              else
+                emitcode( "cpl", "c");
               wassertl(!aopGetUsesAcc(leftOp, offset), "accumulator clash");
               MOVA (aopGet(rightOp, offset, FALSE, TRUE));
-              if (offset == 0) {
-                emitcode( "setb", "c");
-              }
               emitcode("subb", "a,%s", aopGet(leftOp, offset, FALSE, TRUE));
               emitcode("cpl", "a");
+              if (size) /* skip if last byte */
+                emitcode( "cpl", "c");
             }
           } else {
             MOVA (aopGet (leftOp, offset, FALSE, FALSE));
@@ -4097,17 +5020,16 @@ genMinus (iCode * ic)
                       aopGet(rightOp, offset, FALSE, TRUE));
           }
 
-          aopPut (AOP (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));
 }
 
 
@@ -4119,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);
@@ -4139,7 +5061,7 @@ genMultOneByte (operand * left,
   bool runtimeSign, compiletimeSign;
   bool lUnsigned, rUnsigned, pushedB;
 
-  D(emitcode (";     genMultOneByte",""));
+  D (emitcode (";", "genMultOneByte"));
 
   if (size < 1 || size > 2)
     {
@@ -4184,19 +5106,19 @@ genMultOneByte (operand * left,
       if (AOP_TYPE (right) == AOP_LIT)
         {
           /* moving to accumulator first helps peepholes */
-          MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
-          emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+          MOVA (aopGet (left, 0, FALSE, FALSE));
+          MOVB (aopGet (right, 0, FALSE, FALSE));
         }
       else
         {
-          emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-          MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+          emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
+          MOVA (aopGet (left, 0, FALSE, FALSE));
         }
 
       emitcode ("mul", "ab");
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);
       if (size == 2)
-        aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+        aopPut (result, "b", 1);
 
       popB (pushedB);
       return;
@@ -4218,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;
         }
@@ -4232,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;
         }
@@ -4253,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);
@@ -4263,24 +5185,23 @@ genMultOneByte (operand * left,
   else /* ! literal */
     {
       if (rUnsigned)  /* emitcode (";", "signed"); */
-
-        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+        emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       else
         {
-          MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+          MOVA (aopGet (right, 0, FALSE, FALSE));
           lbl = newiTempLabel (NULL);
           emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
           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);
@@ -4289,16 +5210,16 @@ genMultOneByte (operand * left,
     }
   else /* ! literal */
     {
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
 
       if (!lUnsigned)
         {
           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);
         }
     }
 
@@ -4314,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 (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", 0);
   if (size == 2)
-    aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+    aopPut (result, "b", 1);
 
   popB (pushedB);
 }
@@ -4339,9 +5260,9 @@ genMult (iCode * ic)
   operand *right = IC_RIGHT (ic);
   operand *result = IC_RESULT (ic);
 
-  D(emitcode (";     genMult",""));
+  D (emitcode (";", "genMult"));
 
-  /* assign the amsops */
+  /* assign the asmops */
   aopOp (left, ic, FALSE);
   aopOp (right, ic, FALSE);
   aopOp (result, ic, TRUE);
@@ -4389,13 +5310,13 @@ genDivbits (operand * left,
   char *l;
   bool pushedB;
 
-  D(emitcode (";     genDivbits",""));
+  D(emitcode (";", "genDivbits"));
 
   pushedB = pushB ();
 
   /* the result must be bit */
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-  l = aopGet (AOP (left), 0, FALSE, FALSE);
+  emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
+  l = aopGet (left, 0, FALSE, FALSE);
 
   MOVA (l);
 
@@ -4404,7 +5325,7 @@ genDivbits (operand * left,
 
   popB (pushedB);
 
-  aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+  aopPut (result, "c", 0);
 }
 
 /*-----------------------------------------------------------------*/
@@ -4417,10 +5338,12 @@ genDivOneByte (operand * left,
 {
   bool lUnsigned, rUnsigned, pushedB;
   bool runtimeSign, compiletimeSign;
+  bool accuse = FALSE;
+  bool pushedA = FALSE;
   symbol *lbl;
   int size, offset;
 
-  D(emitcode (";     genDivOneByte",""));
+  D(emitcode (";", "genDivOneByte"));
 
   /* Why is it necessary that genDivOneByte() can return an int result?
      Have a look at:
@@ -4459,12 +5382,12 @@ genDivOneByte (operand * left,
   if (lUnsigned && rUnsigned)
     {
       /* unsigned is easy */
-      emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVB (aopGet (right, 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("div", "ab");
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);
 
       popB (pushedB);
       return;
@@ -4485,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;
         }
@@ -4499,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;
         }
@@ -4520,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);
@@ -4530,23 +5453,23 @@ genDivOneByte (operand * left,
   else /* ! literal */
     {
       if (rUnsigned)
-        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+        emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       else
         {
-          MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+          MOVA (aopGet (right, 0, FALSE, FALSE));
           lbl = newiTempLabel (NULL);
           emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
           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);
@@ -4555,7 +5478,7 @@ genDivOneByte (operand * left,
     }
   else /* ! literal */
     {
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
 
       if (!lUnsigned)
         {
@@ -4564,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);
         }
     }
 
@@ -4578,31 +5501,45 @@ genDivOneByte (operand * left,
         emitcode ("jnb", "F0,%05d$", (lbl->key + 100));
       emitcode ("cpl", "a"); /* lsb 2's complement */
       emitcode ("inc", "a");
-      emitcode ("", "%05d$:", (lbl->key + 100));
+      emitLabel (lbl);
 
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      accuse = aopPut (result, "a", 0);
       if (size > 0)
         {
           /* msb is 0x00 or 0xff depending on the sign */
           if (runtimeSign)
             {
+              if (accuse)
+                {
+                  emitcode ("push", "acc");
+                  pushedA = TRUE;
+                }
               emitcode ("mov", "c,F0");
               emitcode ("subb", "a,acc");
               while (size--)
-                aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+                aopPut (result, "a", offset++);
             }
           else /* compiletimeSign */
-            while (size--)
-              aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+            {
+              if (aopPutUsesAcc (result, "#0xff", offset))
+                {
+                  emitcode ("push", "acc");
+                  pushedA = TRUE;
+                }
+              while (size--)
+                aopPut (result, "#0xff", offset++);
+            }
         }
     }
   else
     {
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);
     }
 
+  if (pushedA)
+    emitcode ("pop", "acc");
   popB (pushedB);
 }
 
@@ -4616,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);
@@ -4643,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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -4659,13 +5596,13 @@ genModbits (operand * left,
   char *l;
   bool pushedB;
 
-  D(emitcode (";     genModbits",""));
+  D (emitcode (";", "genModbits"));
 
   pushedB = pushB ();
 
   /* the result must be bit */
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-  l = aopGet (AOP (left), 0, FALSE, FALSE);
+  emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
+  l = aopGet (left, 0, FALSE, FALSE);
 
   MOVA (l);
 
@@ -4675,7 +5612,7 @@ genModbits (operand * left,
 
   popB (pushedB);
 
-  aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+  aopPut (result, "c", 0);
 }
 
 /*-----------------------------------------------------------------*/
@@ -4691,25 +5628,80 @@ genModOneByte (operand * left,
   symbol *lbl;
   int size, offset;
 
-  D(emitcode (";     genModOneByte",""));
+  D (emitcode (";", "genModOneByte"));
 
   size = AOP_SIZE (result) - 1;
   offset = 1;
   lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
   rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
 
+  /* if right is a literal, check it for 2^n */
+  if (AOP_TYPE(right) == AOP_LIT)
+    {
+      unsigned char val = abs((int) operandLitValue(right));
+      symbol *lbl2 = NULL;
+
+      switch (val)
+        {
+          case 1: /* sometimes it makes sense (on tricky code and hardware)... */
+          case 2:
+          case 4:
+          case 8:
+          case 16:
+          case 32:
+          case 64:
+          case 128:
+            if (lUnsigned)
+              werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+                      "modulus of unsigned char by 2^n literal shouldn't be processed here");
+              /* because iCode should have been changed to genAnd  */
+              /* see file "SDCCopt.c", function "convertToFcall()" */
+
+            MOVA (aopGet (left, 0, FALSE, FALSE));
+            emitcode ("mov", "c,acc.7");
+            emitcode ("anl", "a,#0x%02x", val - 1);
+            lbl = newiTempLabel (NULL);
+            emitcode ("jz", "%05d$", (lbl->key + 100));
+            emitcode ("jnc", "%05d$", (lbl->key + 100));
+            emitcode ("orl", "a,#0x%02x", 0xff ^ (val - 1));
+            if (size)
+              {
+                int size2 = size;
+                int offs2 = offset;
+
+                aopPut (result, "a", 0);
+                while (size2--)
+                  aopPut (result, "#0xff", offs2++);
+                lbl2 = newiTempLabel (NULL);
+                emitcode ("sjmp", "%05d$", (lbl2->key + 100));
+              }
+            emitLabel (lbl);
+            aopPut (result, "a", 0);
+            while (size--)
+              aopPut (result, zero, offset++);
+            if (lbl2)
+              {
+                emitLabel (lbl2);
+              }
+            return;
+
+          default:
+            break;
+        }
+    }
+
   pushedB = pushB ();
 
   /* signed or unsigned */
   if (lUnsigned && rUnsigned)
     {
       /* unsigned is easy */
-      emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVB (aopGet (right, 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("div", "ab");
-      aopPut (AOP (result), "b", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "b", 0);
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);
 
       popB (pushedB);
       return;
@@ -4722,7 +5714,7 @@ genModOneByte (operand * left,
   /* modulus: sign of the right operand has no influence on the result! */
   if (AOP_TYPE(right) == AOP_LIT)
     {
-      signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+      signed char val = (char) operandLitValue(right);
 
       if (!rUnsigned && val < 0)
         emitcode ("mov", "b,#0x%02x", -val);
@@ -4732,15 +5724,15 @@ genModOneByte (operand * left,
   else /* not literal */
     {
       if (rUnsigned)
-        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+        emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       else
         {
-          MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+          MOVA (aopGet (right, 0, FALSE, FALSE));
           lbl = newiTempLabel (NULL);
           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");
         }
     }
@@ -4754,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)
         {
@@ -4766,7 +5758,7 @@ genModOneByte (operand * left,
     }
   else /* ! literal */
     {
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
 
       if (!lUnsigned)
         {
@@ -4778,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);
         }
     }
 
@@ -4793,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 (AOP (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 (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+                aopPut (result, "a", offset++);
             }
           else /* compiletimeSign */
             while (size--)
-              aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+              aopPut (result, "#0xff", offset++);
         }
     }
   else
     {
-      aopPut (AOP (result), "b", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "b", 0);
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);
     }
 
   popB (pushedB);
@@ -4831,9 +5823,9 @@ genMod (iCode * ic)
   operand *right = IC_RIGHT (ic);
   operand *result = IC_RESULT (ic);
 
-  D(emitcode (";     genMod",""));
+  D (emitcode (";", "genMod"));
 
-  /* assign the amsops */
+  /* assign the asmops */
   aopOp (left, ic, FALSE);
   aopOp (right, ic, FALSE);
   aopOp (result, ic, TRUE);
@@ -4859,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 */
@@ -4899,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;
@@ -4916,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 &&
@@ -4938,16 +5933,16 @@ genCmp (operand * left, operand * right,
         {
           symbol *lbl = newiTempLabel (NULL);
           emitcode ("cjne", "%s,%s,%05d$",
-                    aopGet (AOP (left), offset, FALSE, FALSE),
-                    aopGet (AOP (right), offset, FALSE, FALSE),
+                    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)
                 {
@@ -4957,17 +5952,46 @@ genCmp (operand * left, operand * right,
                     }
                   else
                     {
-                      MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE));
+                      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;
                 }
@@ -4976,41 +6000,31 @@ genCmp (operand * left, operand * right,
           while (size--)
             {
               bool pushedB = FALSE;
-              rightInB = aopGetUsesAcc(AOP (right), offset);
+              rightInB = aopGetUsesAcc(right, offset);
               if (rightInB)
                 {
                   pushedB = pushB ();
-                  emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+                  emitcode ("mov", "b,%s", aopGet (right, offset, FALSE, FALSE));
                 }
-              MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+              MOVA (aopGet (left, offset, FALSE, FALSE));
               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 (AOP (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
                 {
                   if (rightInB)
                     emitcode ("subb", "a,b");
                   else
-                    emitcode ("subb", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+                    emitcode ("subb", "a,%s", aopGet (right, offset, FALSE, FALSE));
                 }
               if (rightInB)
                 popB (pushedB);
@@ -5032,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 */
     }
 }
@@ -5049,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);
@@ -5059,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);
 
@@ -5079,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);
@@ -5089,12 +6107,12 @@ 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);
+  genCmp (left, right, result, ifx, sign, ic);
 
   freeAsmop (result, NULL, ic, TRUE);
 }
@@ -5109,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;
@@ -5122,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 &&
@@ -5132,8 +6153,8 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
       while (size--)
         {
           emitcode ("cjne", "%s,%s,%05d$",
-                    aopGet (AOP (left), offset, FALSE, FALSE),
-                    aopGet (AOP (right), offset, FALSE, FALSE),
+                    aopGet (left, offset, FALSE, FALSE),
+                    aopGet (right, offset, FALSE, FALSE),
                     lbl->key + 100);
           offset++;
         }
@@ -5150,13 +6171,13 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
     {
       while (size--)
         {
-          MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+          MOVA (aopGet (left, offset, FALSE, FALSE));
           if ((AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) &&
               ((unsigned int) ((lit >> (offset * 8)) & 0x0FFL) == 0))
             emitcode ("jnz", "%05d$", lbl->key + 100);
           else
             emitcode ("cjne", "a,%s,%05d$",
-                      aopGet (AOP (right), offset, FALSE, TRUE),
+                      aopGet (right, offset, FALSE, TRUE),
                       lbl->key + 100);
           offset++;
         }
@@ -5166,13 +6187,10 @@ 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(!_G.BInUse, "B was in use");
-          l = aopGet (AOP (left), offset, FALSE, FALSE);
-          if (strcmp (l, "b"))
-            emitcode ("mov", "b,%s", l);
-          MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+          wassertl(!BINUSE, "B was in use");
+          MOVB (aopGet (left, offset, FALSE, FALSE));
+          MOVA (aopGet (right, offset, FALSE, FALSE));
           emitcode ("cjne", "a,b,%05d$", lbl->key + 100);
           offset++;
         }
@@ -5183,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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -5202,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);
@@ -5219,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))
@@ -5230,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);
@@ -5252,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 */
@@ -5263,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
@@ -5271,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
         {
@@ -5284,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 */
@@ -5310,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);
@@ -5332,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))
@@ -5342,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
@@ -5351,15 +6384,16 @@ genCmpEq (iCode * ic, iCode * ifx)
     }
   else
     {
-      gencjne (left, right, newiTempLabel (NULL));
       if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
         {
-          aopPut (AOP (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
@@ -5370,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));
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -5381,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;
 }
@@ -5401,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);
@@ -5415,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 + <sizeof *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 + <sizeof *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;
 }
 
@@ -5443,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
@@ -5466,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);
 }
 
 
@@ -5485,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
@@ -5508,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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -5572,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
     {
@@ -5585,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;
 }
@@ -5602,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
@@ -5643,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);
 
@@ -5682,13 +6730,20 @@ 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
             {
               // c = bit & val;
-              MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+              MOVA (aopGet (right, 0, FALSE, FALSE));
               // c = lsb
               emitcode ("rrc", "a");
               emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
@@ -5700,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;
     }
 
@@ -5715,10 +6770,20 @@ genAnd (iCode * ic, iCode * ifx)
       if (posbit)
         {
           posbit--;
-          MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE));
+          MOVA (aopGet (left, posbit >> 3, FALSE, FALSE));
           // bit = left & 2^n
           if (size)
-            emitcode ("mov", "c,acc.%d", posbit & 0x07);
+            {
+              switch (posbit & 0x07)
+                {
+                  case 0: emitcode ("rrc", "a");
+                          break;
+                  case 7: emitcode ("rlc", "a");
+                          break;
+                  default: emitcode ("mov", "c,acc.%d", posbit & 0x07);
+                          break;
+                }
+            }
           // if(left &  2^n)
           else
             {
@@ -5726,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;
             }
@@ -5745,7 +6810,7 @@ genAnd (iCode * ic, iCode * ifx)
             {
               if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L)
                 {
-                  MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
                   // byte ==  2^n ?
                   if ((posbit = isLiteralBit (bytelit)) != 0)
                     emitcode ("jb", "acc.%d,%05d$", (posbit - 1) & 0x07, tlbl->key + 100);
@@ -5753,7 +6818,7 @@ genAnd (iCode * ic, iCode * ifx)
                     {
                       if (bytelit != 0x0FFL)
                         emitcode ("anl", "a,%s",
-                                  aopGet (AOP (right), offset, FALSE, TRUE));
+                                  aopGet (right, offset, FALSE, TRUE));
                       emitcode ("jnz", "%05d$", tlbl->key + 100);
                     }
                 }
@@ -5763,7 +6828,7 @@ genAnd (iCode * ic, iCode * ifx)
           if (size)
             {
               emitcode ("clr", "c");
-              emitcode ("", "%05d$:", tlbl->key + 100);
+              emitLabel (tlbl);
             }
           // if(left & literal)
           else
@@ -5771,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;
             }
         }
@@ -5791,40 +6856,56 @@ genAnd (iCode * ic, iCode * ifx)
                 {
                   /* dummy read of volatile operand */
                   if (isOperandVolatile (left, FALSE))
-                    MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+                    MOVA (aopGet (left, offset, FALSE, FALSE));
                   else
                     continue;
                 }
               else if (bytelit == 0)
                 {
-                  aopPut (AOP (result), zero, offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, zero, offset);
                 }
               else if (IS_AOP_PREG (result))
                 {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                  emitcode ("anl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-                  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+                  MOVA (aopGet (left, offset, FALSE, TRUE));
+                  emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset);
                 }
               else
                 emitcode ("anl", "%s,%s",
-                          aopGet (AOP (left), offset, FALSE, TRUE),
-                          aopGet (AOP (right), offset, FALSE, FALSE));
+                          aopGet (left, offset, FALSE, TRUE),
+                          aopGet (right, offset, FALSE, FALSE));
             }
           else
             {
               if (AOP_TYPE (left) == AOP_ACC)
-                emitcode ("anl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+                {
+                  if (offset)
+                    emitcode("mov", "a,b");
+                  emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  MOVB (aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,b");
+                  aopPut (result, "a", offset);
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset);
+                }
               else
                 {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
                   if (IS_AOP_PREG (result))
                     {
-                      emitcode ("anl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-                      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+                      emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, TRUE));
+                      aopPut (result, "a", offset);
                     }
                   else
-                    emitcode ("anl", "%s,a",
-                              aopGet (AOP (left), offset, FALSE, TRUE));
+                    emitcode ("anl", "%s,a", aopGet (left, offset, FALSE, TRUE));
                 }
             }
         }
@@ -5843,35 +6924,59 @@ genAnd (iCode * ic, iCode * ifx)
             emitcode ("setb", "c");
           while (sizer--)
             {
-              if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
-                emitcode ("anl", "a,%s",
-                          aopGet (AOP (right), offset, FALSE, FALSE));
-              } else {
-                if (AOP_TYPE(left)==AOP_ACC) {
-                  bool pushedB = pushB ();
-                  emitcode("mov", "b,a");
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                  emitcode("anl", "a,b");
-                  popB (pushedB);
-                }else {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                  emitcode ("anl", "a,%s",
-                            aopGet (AOP (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 ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
                 }
-              }
+              else if (AOP_TYPE(left)==AOP_ACC)
+                {
+                  if (!offset)
+                    {
+                      bool pushedB = pushB ();
+                      emitcode("mov", "b,a");
+                      MOVA (aopGet (right, offset, FALSE, FALSE));
+                      emitcode("anl", "a,b");
+                      popB (pushedB);
+                    }
+                  else
+                    {
+                      MOVA (aopGet (right, offset, FALSE, FALSE));
+                      emitcode("anl", "a,b");
+                    }
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  MOVB (aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,b");
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else
+                {
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE));
+                }
+
               emitcode ("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
         {
@@ -5884,40 +6989,85 @@ genAnd (iCode * ic, iCode * ifx)
                   bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
                   if (bytelit == 0x0FF)
                     {
-                      aopPut (AOP (result),
-                              aopGet (AOP (left), offset, FALSE, FALSE),
-                              offset,
-                              isOperandVolatile (result, FALSE));
+                      aopPut (result,
+                              aopGet (left, offset, FALSE, FALSE),
+                              offset);
                       continue;
                     }
                   else if (bytelit == 0)
                     {
                       /* dummy read of volatile operand */
                       if (isOperandVolatile (left, FALSE))
-                        MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
-                      aopPut (AOP (result), zero, offset, isOperandVolatile (result, FALSE));
+                        MOVA (aopGet (left, offset, FALSE, FALSE));
+                      aopPut (result, zero, offset);
                       continue;
                     }
+                  else if (AOP_TYPE (left) == AOP_ACC)
+                    {
+                      if (!offset)
+                        {
+                          emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                          aopPut (result, "a", offset);
+                          continue;
+                        }
+                      else
+                        {
+                          emitcode ("anl", "b,%s", aopGet (right, offset, FALSE, 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)
-                emitcode ("anl", "a,%s", aopGet (AOP (right), 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 ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else if (AOP_TYPE(left)==AOP_ACC)
+                {
+                  if (!offset)
+                    {
+                      bool pushedB = pushB ();
+                      emitcode("mov", "b,a");
+                      MOVA (aopGet (right, offset, FALSE, FALSE));
+                      emitcode("anl", "a,b");
+                      popB (pushedB);
+                    }
+                  else
+                    {
+                      MOVA (aopGet (right, offset, FALSE, FALSE));
+                      emitcode("anl", "a,b");
+                    }
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  MOVB (aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,b");
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
               else
                 {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                  emitcode ("anl", "a,%s",
-                            aopGet (AOP (left), offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE));
                 }
-              aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -5931,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
@@ -5972,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);
 
@@ -6009,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);
                 }
             }
         }
@@ -6040,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;
     }
 
@@ -6055,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;
         }
@@ -6070,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;
             }
         }
@@ -6094,43 +7249,59 @@ genOr (iCode * ic, iCode * ifx)
                 {
                   /* dummy read of volatile operand */
                   if (isOperandVolatile (left, FALSE))
-                    MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+                    MOVA (aopGet (left, offset, FALSE, FALSE));
                   else
                     continue;
                 }
               else if (bytelit == 0x0FF)
                 {
-                  aopPut (AOP (result), "#0xFF", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "#0xff", offset);
                 }
               else if (IS_AOP_PREG (left))
                 {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                  emitcode ("orl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-                  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+                  MOVA (aopGet (left, offset, FALSE, TRUE));
+                  emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset);
                 }
               else
                 {
                   emitcode ("orl", "%s,%s",
-                            aopGet (AOP (left), offset, FALSE, TRUE),
-                            aopGet (AOP (right), offset, FALSE, FALSE));
+                            aopGet (left, offset, FALSE, TRUE),
+                            aopGet (right, offset, FALSE, FALSE));
                 }
             }
           else
             {
               if (AOP_TYPE (left) == AOP_ACC)
-                emitcode ("orl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+                {
+                  if (offset)
+                    emitcode("mov", "a,b");
+                  emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  MOVB (aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("orl", "a,b");
+                  aopPut (result, "a", offset);
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset);
+                }
               else
                 {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
                   if (IS_AOP_PREG (left))
                     {
-                      emitcode ("orl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-                      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+                      emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, TRUE));
+                      aopPut (result, "a", offset);
                     }
                   else
                     {
-                      emitcode ("orl", "%s,a",
-                                aopGet (AOP (left), offset, FALSE, TRUE));
+                      emitcode ("orl", "%s,a", aopGet (left, offset, FALSE, TRUE));
                     }
                 }
             }
@@ -6150,27 +7321,59 @@ genOr (iCode * ic, iCode * ifx)
             emitcode ("setb", "c");
           while (sizer--)
             {
-              if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
-                emitcode ("orl", "a,%s",
-                          aopGet (AOP (right), offset, FALSE, FALSE));
-              } else {
-                MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                emitcode ("orl", "a,%s",
-                          aopGet (AOP (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
         {
@@ -6183,40 +7386,70 @@ genOr (iCode * ic, iCode * ifx)
                   bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
                   if (bytelit == 0)
                     {
-                      aopPut (AOP (result),
-                              aopGet (AOP (left), offset, FALSE, FALSE),
-                              offset,
-                              isOperandVolatile (result, FALSE));
+                      aopPut (result,
+                              aopGet (left, offset, FALSE, FALSE),
+                              offset);
                       continue;
                     }
                   else if (bytelit == 0x0FF)
                     {
                       /* dummy read of volatile operand */
                       if (isOperandVolatile (left, FALSE))
-                        MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
-                      aopPut (AOP (result), "#0xFF", offset, isOperandVolatile (result, FALSE));
+                        MOVA (aopGet (left, offset, FALSE, 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)
-                emitcode ("orl", "a,%s", aopGet (AOP (right), 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 (AOP (right), offset, FALSE, FALSE));
-                  emitcode ("orl", "a,%s",
-                            aopGet (AOP (left), offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, FALSE));
                 }
-              aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6230,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
@@ -6271,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);
 
@@ -6321,7 +7555,6 @@ genXor (iCode * ic, iCode * ifx)
                     }
                 }
             }
-
         }
       else
         {
@@ -6330,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 (AOP (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;
     }
 
@@ -6376,38 +7605,54 @@ genXor (iCode * ic, iCode * ifx)
                 {
                   /* dummy read of volatile operand */
                   if (isOperandVolatile (left, FALSE))
-                    MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+                    MOVA (aopGet (left, offset, FALSE, FALSE));
                   else
                     continue;
                 }
               else if (IS_AOP_PREG (left))
                 {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                  emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-                  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+                  MOVA (aopGet (left, offset, FALSE, TRUE));
+                  emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset);
                 }
               else
                 {
                   emitcode ("xrl", "%s,%s",
-                            aopGet (AOP (left), offset, FALSE, TRUE),
-                            aopGet (AOP (right), offset, FALSE, FALSE));
+                            aopGet (left, offset, FALSE, TRUE),
+                            aopGet (right, offset, FALSE, FALSE));
                 }
             }
           else
             {
               if (AOP_TYPE (left) == AOP_ACC)
-                emitcode ("xrl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+                {
+                  if (offset)
+                    emitcode("mov", "a,b");
+                  emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  MOVB (aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("xrl", "a,b");
+                  aopPut (result, "a", offset);
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset);
+                }
               else
                 {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
                   if (IS_AOP_PREG (left))
                     {
-                      emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-                      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+                      emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
+                      aopPut (result, "a", offset);
                     }
                   else
-                    emitcode ("xrl", "%s,a",
-                              aopGet (AOP (left), offset, FALSE, TRUE));
+                    emitcode ("xrl", "%s,a", aopGet (left, offset, FALSE, TRUE));
                 }
             }
         }
@@ -6422,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--)
@@ -6429,26 +7675,55 @@ genXor (iCode * ic, iCode * ifx)
               if ((AOP_TYPE (right) == AOP_LIT) &&
                   (((lit >> (offset * 8)) & 0x0FFL) == 0x00L))
                 {
-                  MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+                  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) {
-                    emitcode ("xrl", "a,%s",
-                              aopGet (AOP (right), offset, FALSE, FALSE));
-                  } else {
-                    MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                    emitcode ("xrl", "a,%s",
-                              aopGet (AOP (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)
@@ -6459,38 +7734,68 @@ 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);
                   if (bytelit == 0)
                     {
-                      aopPut (AOP (result),
-                              aopGet (AOP (left), offset, FALSE, FALSE),
-                              offset,
-                              isOperandVolatile (result, FALSE));
+                      aopPut (result,
+                              aopGet (left, offset, FALSE, 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)
-                emitcode ("xrl", "a,%s", aopGet (AOP (right), 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 ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else if (AOP_TYPE(left)==AOP_ACC)
+                {
+                  if (!offset)
+                    {
+                      bool pushedB = pushB ();
+                      emitcode("mov", "b,a");
+                      MOVA (aopGet (right, offset, FALSE, FALSE));
+                      emitcode("xrl", "a,b");
+                      popB (pushedB);
+                    }
+                  else
+                    {
+                      MOVA (aopGet (right, offset, FALSE, FALSE));
+                      emitcode("xrl", "a,b");
+                    }
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  MOVB (aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("xrl", "a,b");
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
               else
                 {
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                  emitcode ("xrl", "a,%s",
-                            aopGet (AOP (left), offset, FALSE, TRUE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
                 }
-              aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6500,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(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);
 }
 
@@ -6545,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);
@@ -6560,32 +7875,32 @@ genRRC (iCode * ic)
   size = AOP_SIZE (result);
   offset = size - 1;
   if (size == 1) { /* special case for 1 byte */
-      l = aopGet (AOP (left), offset, FALSE, FALSE);
+      l = aopGet (left, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rr", "a");
       goto release;
   }
-  CLRC;
+  /* no need to clear carry, bit7 will be written later */
   while (size--)
     {
-      l = aopGet (AOP (left), offset, FALSE, FALSE);
+      l = aopGet (left, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");
       if (AOP_SIZE (result) > 1)
-        aopPut (AOP (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 */
   if (AOP_SIZE (result) > 1)
     {
-      l = aopGet (AOP (result), AOP_SIZE (result) - 1, FALSE, FALSE);
+      l = aopGet (result, AOP_SIZE (result) - 1, FALSE, FALSE);
       MOVA (l);
     }
   emitcode ("mov", "acc.7,c");
  release:
-  aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6595,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);
@@ -6611,36 +7926,39 @@ genRLC (iCode * ic)
   offset = 0;
   if (size--)
     {
-      l = aopGet (AOP (left), offset, FALSE, FALSE);
+      l = aopGet (left, offset, FALSE, FALSE);
       MOVA (l);
       if (size == 0) { /* special case for 1 byte */
               emitcode("rl","a");
               goto release;
       }
-      emitcode ("add", "a,acc");
+      emitcode("rlc","a"); /* bit0 will be written later */
       if (AOP_SIZE (result) > 1)
-        aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+        {
+          aopPut (result, "a", offset++);
+        }
+
       while (size--)
         {
-          l = aopGet (AOP (left), offset, FALSE, FALSE);
+          l = aopGet (left, offset, FALSE, FALSE);
           MOVA (l);
           emitcode ("rlc", "a");
           if (AOP_SIZE (result) > 1)
-            aopPut (AOP (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 */
   if (AOP_SIZE (result) > 1)
     {
-      l = aopGet (AOP (result), 0, FALSE, FALSE);
+      l = aopGet (result, 0, FALSE, FALSE);
       MOVA (l);
     }
   emitcode ("mov", "acc.0,c");
  release:
-  aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6651,7 +7969,7 @@ genGetHbit (iCode * ic)
 {
   operand *left, *result;
 
-  D(emitcode (";     genGetHbit",""));
+  D (emitcode (";", "genGetHbit"));
 
   left = IC_LEFT (ic);
   result = IC_RESULT (ic);
@@ -6659,7 +7977,7 @@ genGetHbit (iCode * ic)
   aopOp (result, ic, FALSE);
 
   /* get the highest order byte into a */
-  MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE));
+  MOVA (aopGet (left, AOP_SIZE (left) - 1, FALSE, FALSE));
   if (AOP_TYPE (result) == AOP_CRY)
     {
       emitcode ("rlc", "a");
@@ -6672,9 +7990,139 @@ genGetHbit (iCode * ic)
       outAcc (result);
     }
 
+  freeAsmop (result, NULL, ic, TRUE);
+  freeAsmop (left, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genGetAbit - generates code get a single bit                    */
+/*-----------------------------------------------------------------*/
+static void
+genGetAbit (iCode * ic)
+{
+  operand *left, *right, *result;
+  int shCount;
+
+  D (emitcode (";", "genGetAbit"));
+
+  left = IC_LEFT (ic);
+  right = IC_RIGHT (ic);
+  result = IC_RESULT (ic);
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  shCount = (int) ulFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+
+  /* get the needed byte into a */
+  MOVA (aopGet (left, shCount / 8, FALSE, FALSE));
+  shCount %= 8;
+  if (AOP_TYPE (result) == AOP_CRY)
+    {
+      if ((shCount) == 7)
+          emitcode ("rlc", "a");
+      else if ((shCount) == 0)
+          emitcode ("rrc", "a");
+      else
+          emitcode ("mov", "c,acc[%d]", shCount);
+      outBitC (result);
+    }
+  else
+    {
+      switch (shCount)
+        {
+        case 2:
+          emitcode ("rr", "a");
+          //fallthrough
+        case 1:
+          emitcode ("rr", "a");
+          //fallthrough
+        case 0:
+          emitcode ("anl", "a,#0x01");
+          break;
+        case 3:
+        case 5:
+          emitcode ("mov", "c,acc[%d]", shCount);
+          emitcode ("clr", "a");
+          emitcode ("rlc", "a");
+          break;
+        case 4:
+          emitcode ("swap", "a");
+          emitcode ("anl", "a,#0x01");
+          break;
+        case 6:
+          emitcode ("rl", "a");
+          //fallthrough
+        case 7:
+          emitcode ("rl", "a");
+          emitcode ("anl", "a,#0x01");
+          break;
+        }
+      outAcc (result);
+    }
+
+  freeAsmop (result, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (left, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genGetByte - generates code get a single byte                   */
+/*-----------------------------------------------------------------*/
+static void
+genGetByte (iCode * ic)
+{
+  operand *left, *right, *result;
+  int offset;
+
+  D (emitcode (";", "genGetByte"));
+
+  left = IC_LEFT (ic);
+  right = IC_RIGHT (ic);
+  result = IC_RESULT (ic);
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  offset = (int) ulFromVal (AOP (right)->aopu.aop_lit) / 8;
+  aopPut (result,
+          aopGet (left, offset, FALSE, FALSE),
+          0);
 
+  freeAsmop (result, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
   freeAsmop (left, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genGetWord - generates code get two bytes                       */
+/*-----------------------------------------------------------------*/
+static void
+genGetWord (iCode * ic)
+{
+  operand *left, *right, *result;
+  int offset;
+
+  D (emitcode (";", "genGetWord"));
+
+  left = IC_LEFT (ic);
+  right = IC_RIGHT (ic);
+  result = IC_RESULT (ic);
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  offset = (int) ulFromVal (AOP (right)->aopu.aop_lit) / 8;
+  aopPut (result,
+          aopGet (left, offset, FALSE, FALSE),
+          0);
+  aopPut (result,
+          aopGet (left, offset+1, FALSE, FALSE),
+          1);
+
   freeAsmop (result, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (left, NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6685,7 +8133,7 @@ genSwap (iCode * ic)
 {
   operand *left, *result;
 
-  D(emitcode (";     genSwap",""));
+  D(emitcode (";", "genSwap"));
 
   left = IC_LEFT (ic);
   result = IC_RESULT (ic);
@@ -6695,55 +8143,50 @@ genSwap (iCode * ic)
   switch (AOP_SIZE (left))
     {
     case 1: /* swap nibbles in byte */
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("swap", "a");
-      aopPut (AOP (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 (AOP (left), 0, FALSE, FALSE));
-          aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
-                  0, isOperandVolatile (result, FALSE));
-          aopPut (AOP (result), "a", 1, isOperandVolatile (result, FALSE));
+          MOVA (aopGet (left, 0, FALSE, FALSE));
+          aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+          aopPut (result, "a", 1);
         }
       else if (operandsEqu (left, result))
         {
           char * reg = "a";
           bool pushedB = FALSE, leftInB = FALSE;
 
-          MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
-          if (aopGetUsesAcc(AOP (left), 1) || aopGetUsesAcc(AOP (result), 0))
+          MOVA (aopGet (left, 0, FALSE, FALSE));
+          if (aopGetUsesAcc(left, 1) || aopGetUsesAcc(result, 0))
             {
               pushedB = pushB ();
               emitcode ("mov", "b,a");
               reg = "b";
               leftInB = TRUE;
             }
-          aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
-                  0, isOperandVolatile (result, FALSE));
-          aopPut (AOP (result), reg, 1, isOperandVolatile (result, FALSE));
+          aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+          aopPut (result, reg, 1);
 
           if (leftInB)
             popB (pushedB);
         }
       else
         {
-          aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
-                  0, isOperandVolatile (result, FALSE));
-          aopPut (AOP (result), aopGet (AOP (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                 */
 /*-----------------------------------------------------------------*/
@@ -6863,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);
         }
     }
 }
@@ -6876,13 +8319,13 @@ shiftR1Left2Result (operand * left, int offl,
                     operand * result, int offr,
                     int shCount, int sign)
 {
-  MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
+  MOVA (aopGet (left, offl, FALSE, FALSE));
   /* shift right accumulator */
   if (sign)
     AccSRsh (shCount);
   else
     AccRsh (shCount);
-  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6893,11 +8336,11 @@ shiftL1Left2Result (operand * left, int offl,
                     operand * result, int offr, int shCount)
 {
   char *l;
-  l = aopGet (AOP (left), offl, FALSE, FALSE);
+  l = aopGet (left, offl, FALSE, FALSE);
   MOVA (l);
   /* shift left accumulator */
   AccLsh (shCount);
-  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6910,24 +8353,26 @@ movLeft2Result (operand * left, int offl,
   char *l;
   if (!sameRegs (AOP (left), AOP (result)) || (offl != offr))
     {
-      l = aopGet (AOP (left), offl, FALSE, FALSE);
+      l = aopGet (left, offl, FALSE, FALSE);
 
       if (*l == '@' && (IS_AOP_PREG (result)))
         {
           emitcode ("mov", "a,%s", l);
-          aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", offr);
         }
       else
         {
           if (!sign)
-            aopPut (AOP (result), l, offr, isOperandVolatile (result, FALSE));
+            {
+              aopPut (result, l, offr);
+            }
           else
             {
               /* MSB sign in acc.7 ! */
               if (getDataSize (left) == offl + 1)
                 {
-                  emitcode ("mov", "a,%s", l);
-                  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+                  MOVA (l);
+                  aopPut (result, "a", offr);
                 }
             }
         }
@@ -6989,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
 
@@ -7014,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);
@@ -7035,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
@@ -7044,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:
@@ -7064,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
@@ -7102,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
 
@@ -7116,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
 
@@ -7146,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
@@ -7188,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
 
@@ -7209,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
 
@@ -7227,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;
@@ -7241,21 +8686,47 @@ static void
 shiftL2Left2Result (operand * left, int offl,
                     operand * result, int offr, int shCount)
 {
+  char * x;
+  bool pushedB = FALSE;
+  bool usedB = FALSE;
+
   if (sameRegs (AOP (result), AOP (left)) &&
       ((offl + MSB16) == offr))
     {
       /* don't crash result[offr] */
-      MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
-      emitcode ("xch", "a,%s", aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+      MOVA (aopGet (left, offl, FALSE, FALSE));
+      x = xch_a_aopGet (left, offl + MSB16, FALSE, FALSE);
+      usedB = !strncmp(x, "b", 1);
+    }
+  else if (aopGetUsesAcc (result, offr))
+    {
+      movLeft2Result (left, offl, result, offr, 0);
+      pushedB = pushB ();
+      usedB = TRUE;
+      emitcode ("mov", "b,%s", aopGet (left, offl + MSB16, FALSE, FALSE));
+      MOVA (aopGet (result, offr, FALSE, FALSE));
+      emitcode ("xch", "a,b");
+      x = "b";
     }
   else
     {
       movLeft2Result (left, offl, result, offr, 0);
-      MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+      MOVA (aopGet (left, offl + MSB16, FALSE, FALSE));
+      x = aopGet (result, offr, FALSE, FALSE);
     }
   /* ax << shCount (x = lsb(result)) */
-  AccAXLsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
-  aopPut (AOP (result), "a", offr + MSB16, isOperandVolatile (result, FALSE));
+  AccAXLsh (x, shCount);
+  if (usedB)
+    {
+      emitcode ("xch", "a,b");
+      aopPut (result, "a", offr);
+      aopPut (result, "b", offr + MSB16);
+      popB (pushedB);
+    }
+  else
+    {
+      aopPut (result, "a", offr + MSB16);
+    }
 }
 
 
@@ -7267,25 +8738,47 @@ shiftR2Left2Result (operand * left, int offl,
                     operand * result, int offr,
                     int shCount, int sign)
 {
+  char * x;
+  bool pushedB = FALSE;
+  bool usedB = FALSE;
+
   if (sameRegs (AOP (result), AOP (left)) &&
       ((offl + MSB16) == offr))
     {
       /* don't crash result[offr] */
-      MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
-      emitcode ("xch", "a,%s", aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+      MOVA (aopGet (left, offl, FALSE, FALSE));
+      x = xch_a_aopGet (left, offl + MSB16, FALSE, FALSE);
+      usedB = !strncmp(x, "b", 1);
+    }
+  else if (aopGetUsesAcc (result, offr))
+    {
+      movLeft2Result (left, offl, result, offr, 0);
+      pushedB = pushB ();
+      usedB = TRUE;
+      emitcode ("mov", "b,%s", aopGet (result, offr, FALSE, FALSE));
+      MOVA (aopGet (left, offl + MSB16, FALSE, FALSE));
+      x = "b";
     }
   else
     {
       movLeft2Result (left, offl, result, offr, 0);
-      MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE));
+      MOVA (aopGet (left, offl + MSB16, FALSE, FALSE));
+      x = aopGet (result, offr, FALSE, FALSE);
     }
   /* a:x >> shCount (x = lsb(result)) */
   if (sign)
-    AccAXRshS (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
+    AccAXRshS (x, shCount);
   else
-    AccAXRsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
+    AccAXRsh (x, shCount);
+  if (usedB)
+    {
+      emitcode ("xch", "a,b");
+      aopPut (result, "a", offr);
+      emitcode ("xch", "a,b");
+      popB (pushedB);
+    }
   if (getDataSize (result) > 1)
-    aopPut (AOP (result), "a", offr + MSB16, isOperandVolatile (result, FALSE));
+    aopPut (result, "a", offr + MSB16);
 }
 
 /*-----------------------------------------------------------------*/
@@ -7295,13 +8788,22 @@ static void
 shiftLLeftOrResult (operand * left, int offl,
                     operand * result, int offr, int shCount)
 {
-  MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
+  MOVA (aopGet (left, offl, FALSE, FALSE));
   /* shift left accumulator */
   AccLsh (shCount);
   /* or with result */
-  emitcode ("orl", "a,%s", aopGet (AOP (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 (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr);
 }
 
 /*-----------------------------------------------------------------*/
@@ -7311,13 +8813,22 @@ static void
 shiftRLeftOrResult (operand * left, int offl,
                     operand * result, int offr, int shCount)
 {
-  MOVA (aopGet (AOP (left), offl, FALSE, FALSE));
+  MOVA (aopGet (left, offl, FALSE, FALSE));
   /* shift right accumulator */
   AccRsh (shCount);
   /* or with result */
-  emitcode ("orl", "a,%s", aopGet (AOP (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 (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr);
 }
 
 /*-----------------------------------------------------------------*/
@@ -7326,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);
 }
@@ -7339,7 +8850,7 @@ genlshTwo (operand * result, operand * left, int shCount)
 {
   int size;
 
-  D(emitcode (";     genlshTwo",""));
+  D (emitcode (";", "genlshTwo"));
 
   size = getDataSize (result);
 
@@ -7351,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 (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, LSB);
     }
 
   /*  1 <= shCount <= 7 */
@@ -7380,61 +8895,58 @@ shiftLLong (operand * left, operand * result, int offr)
 
   if (size >= LSB + offr)
     {
-      l = aopGet (AOP (left), LSB, FALSE, FALSE);
+      l = aopGet (left, LSB, FALSE, FALSE);
       MOVA (l);
       emitcode ("add", "a,acc");
       if (sameRegs (AOP (left), AOP (result)) &&
           size >= MSB16 + offr && offr != LSB)
-        emitcode ("xch", "a,%s",
-                  aopGet (AOP (left), LSB + offr, FALSE, FALSE));
+        xch_a_aopGet (left, LSB + offr, FALSE, FALSE);
       else
-        aopPut (AOP (result), "a", LSB + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", LSB + offr);
     }
 
   if (size >= MSB16 + offr)
     {
       if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB16 + offr && offr != LSB))
         {
-          l = aopGet (AOP (left), MSB16, FALSE, FALSE);
+          l = aopGet (left, MSB16, FALSE, FALSE);
           MOVA (l);
         }
       emitcode ("rlc", "a");
       if (sameRegs (AOP (left), AOP (result)) &&
           size >= MSB24 + offr && offr != LSB)
-        emitcode ("xch", "a,%s",
-                  aopGet (AOP (left), MSB16 + offr, FALSE, FALSE));
+        xch_a_aopGet (left, MSB16 + offr, FALSE, FALSE);
       else
-        aopPut (AOP (result), "a", MSB16 + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", MSB16 + offr);
     }
 
   if (size >= MSB24 + offr)
     {
-      if (!(sameRegs (AOP (left), AOP (left)) && size >= MSB24 + offr && offr != LSB))
+      if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB24 + offr && offr != LSB))
         {
-          l = aopGet (AOP (left), MSB24, FALSE, FALSE);
+          l = aopGet (left, MSB24, FALSE, FALSE);
           MOVA (l);
         }
       emitcode ("rlc", "a");
       if (sameRegs (AOP (left), AOP (result)) &&
           size >= MSB32 + offr && offr != LSB)
-        emitcode ("xch", "a,%s",
-                  aopGet (AOP (left), MSB24 + offr, FALSE, FALSE));
+        xch_a_aopGet (left, MSB24 + offr, FALSE, FALSE);
       else
-        aopPut (AOP (result), "a", MSB24 + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", MSB24 + offr);
     }
 
   if (size > MSB32 + offr)
     {
       if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB32 + offr && offr != LSB))
         {
-          l = aopGet (AOP (left), MSB32, FALSE, FALSE);
+          l = aopGet (left, MSB32, FALSE, FALSE);
           MOVA (l);
         }
       emitcode ("rlc", "a");
-      aopPut (AOP (result), "a", MSB32 + offr, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", MSB32 + offr);
     }
   if (offr != LSB)
-    aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+    aopPut (result, zero, LSB);
 }
 
 /*-----------------------------------------------------------------*/
@@ -7445,7 +8957,7 @@ genlshFour (operand * result, operand * left, int shCount)
 {
   int size;
 
-  D(emitcode (";     genlshFour",""));
+  D (emitcode (";", "genlshFour"));
 
   size = AOP_SIZE (result);
 
@@ -7459,9 +8971,9 @@ genlshFour (operand * result, operand * left, int shCount)
         shiftL1Left2Result (left, LSB, result, MSB32, shCount);
       else
         movLeft2Result (left, LSB, result, MSB32, 0);
-      aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
-      aopPut (AOP (result), zero, MSB16, isOperandVolatile (result, FALSE));
-      aopPut (AOP (result), zero, MSB24, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, LSB);
+      aopPut (result, zero, MSB16);
+      aopPut (result, zero, MSB24);
       return;
     }
 
@@ -7478,8 +8990,8 @@ genlshFour (operand * result, operand * left, int shCount)
           movLeft2Result (left, MSB16, result, MSB32, 0);
           movLeft2Result (left, LSB, result, MSB24, 0);
         }
-      aopPut (AOP (result), zero, MSB16, isOperandVolatile (result, FALSE));
-      aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, MSB16);
+      aopPut (result, zero, LSB);
       return;
     }
 
@@ -7502,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 (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+              aopPut (result, zero, LSB);
             }
           else if (shCount == 1)
             shiftLLong (left, result, MSB16);
@@ -7511,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 (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+              aopPut (result, zero, LSB);
             }
         }
     }
@@ -7541,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);
 
@@ -7566,10 +9078,13 @@ genLeftShiftLiteral (operand * left,
           movLeft2Result (left, size, result, size, 0);
         }
     }
-
   else if (shCount >= (size * 8))
-    while (size--)
-      aopPut (AOP (result), zero, size, isOperandVolatile (result, FALSE));
+    {
+      while (size--)
+        {
+          aopPut (result, zero, size);
+        }
+    }
   else
     {
       switch (size)
@@ -7591,8 +9106,8 @@ genLeftShiftLiteral (operand * left,
           break;
         }
     }
-  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
+  freeAsmop (left, NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -7607,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);
@@ -7630,7 +9145,7 @@ genLeftShift (iCode * ic)
      largest size of an object can be only 32 bits ) */
 
   pushedB = pushB ();
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+  MOVB (aopGet (right, 0, FALSE, FALSE));
   emitcode ("inc", "b");
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE);
@@ -7645,15 +9160,15 @@ genLeftShift (iCode * ic)
       offset = 0;
       while (size--)
         {
-          l = aopGet (AOP (left), offset, FALSE, TRUE);
+          l = aopGet (left, offset, FALSE, TRUE);
           if (*l == '@' && (IS_AOP_PREG (result)))
             {
 
               emitcode ("mov", "a,%s", l);
-              aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);
             }
           else
-            aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset);
           offset++;
         }
     }
@@ -7668,41 +9183,41 @@ genLeftShift (iCode * ic)
     {
       symbol *tlbl1 = newiTempLabel (NULL);
 
-      l = aopGet (AOP (left), 0, FALSE, FALSE);
+      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 (AOP (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);
-  l = aopGet (AOP (result), offset, FALSE, FALSE);
+  emitLabel (tlbl);
+  l = aopGet (result, offset, FALSE, FALSE);
   MOVA (l);
   emitcode ("add", "a,acc");
-  aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offset++);
   while (--size)
     {
-      l = aopGet (AOP (result), offset, FALSE, FALSE);
+      l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rlc", "a");
-      aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -7712,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);
 }
@@ -7724,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);
@@ -7751,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 (AOP (left), MSB32, FALSE, FALSE));
+  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(AOP(left), MSB32, FALSE, FALSE));
-      else {
-        aopPut (AOP (result), "a", MSB32, isOperandVolatile (result, FALSE));
-        MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
-      }
-    } else {
-      aopPut (AOP(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 (AOP (left), MSB24, FALSE, FALSE));
-  } else {
-    aopPut (AOP (result), "a", MSB32-offl, isOperandVolatile (result, FALSE));
-    MOVA (aopGet (AOP (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 (AOP (left), MSB16, FALSE, FALSE));
-  } else {
-    aopPut (AOP (result), "a", MSB24-offl, isOperandVolatile (result, FALSE));
-    MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
-  }
-  emitcode ("rrc", "a");
-  aopPut (AOP (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 (AOP (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 (AOP (result), "a", LSB, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", LSB);
     }
 }
 
@@ -7816,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)
@@ -7844,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);
@@ -7862,7 +9418,8 @@ genrshFour (operand * result, operand * left,
         }
     }
   else
-    {                           /* 1 <= shCount <= 7 */
+    {
+      /* 1 <= shCount <= 7 */
       if (shCount <= 2)
         {
           shiftRLong (left, LSB, result, sign);
@@ -7888,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);
 
@@ -7913,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 (AOP (left), size - 1, FALSE, FALSE));
-      }
+      if (sign)
+        {
+          /* get sign in acc.7 */
+          MOVA (aopGet (left, size - 1, FALSE, FALSE));
+        }
       addSign (result, LSB, sign);
     }
   else
@@ -7941,8 +9498,8 @@ genRightShiftLiteral (operand * left,
           break;
         }
     }
-  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
+  freeAsmop (left, NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -7957,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 */
@@ -7981,7 +9538,7 @@ genSignedRightShift (iCode * ic)
      largest size of an object can be only 32 bits ) */
 
   pushedB = pushB ();
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+  MOVB (aopGet (right, 0, FALSE, FALSE));
   emitcode ("inc", "b");
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE);
@@ -7997,15 +9554,15 @@ genSignedRightShift (iCode * ic)
       offset = 0;
       while (size--)
         {
-          l = aopGet (AOP (left), offset, FALSE, TRUE);
+          l = aopGet (left, offset, FALSE, TRUE);
           if (*l == '@' && IS_AOP_PREG (result))
             {
 
               emitcode ("mov", "a,%s", l);
-              aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);
             }
           else
-            aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset);
           offset++;
         }
     }
@@ -8016,44 +9573,44 @@ genSignedRightShift (iCode * ic)
 
   size = AOP_SIZE (result);
   offset = size - 1;
-  MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+  MOVA (aopGet (left, offset, FALSE, FALSE));
   emitcode ("rlc", "a");
   emitcode ("mov", "ov,c");
   /* if it is only one byte then */
   if (size == 1)
     {
-      l = aopGet (AOP (left), 0, FALSE, FALSE);
+      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 (AOP (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 (AOP (result), offset, FALSE, FALSE);
+      l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");
-      aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -8069,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 */
@@ -8109,7 +9666,7 @@ genRightShift (iCode * ic)
      largest size of an object can be only 32 bits ) */
 
   pushedB = pushB ();
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+  MOVB (aopGet (right, 0, FALSE, FALSE));
   emitcode ("inc", "b");
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE);
@@ -8120,20 +9677,19 @@ genRightShift (iCode * ic)
   if (!sameRegs (AOP (left), AOP (result)) &&
       AOP_SIZE (result) > 1)
     {
-
       size = AOP_SIZE (result);
       offset = 0;
       while (size--)
         {
-          l = aopGet (AOP (left), offset, FALSE, TRUE);
+          l = aopGet (left, offset, FALSE, TRUE);
           if (*l == '@' && IS_AOP_PREG (result))
             {
 
               emitcode ("mov", "a,%s", l);
-              aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);
             }
           else
-            aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset);
           offset++;
         }
     }
@@ -8146,39 +9702,39 @@ genRightShift (iCode * ic)
   /* if it is only one byte then */
   if (size == 1)
     {
-      l = aopGet (AOP (left), 0, FALSE, FALSE);
+      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 (AOP (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 (AOP (result), offset, FALSE, FALSE);
+      l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");
-      aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -8270,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 */
@@ -8279,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));
@@ -8293,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);
 
@@ -8312,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 (AOP (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;
     }
 
@@ -8323,7 +9886,7 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx)
   for (rlen=blen;rlen>=8;rlen-=8)
     {
       emitPtrByteGet (rname, ptype, FALSE);
-      aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offset++);
       if (rlen>8)
         emitcode ("inc", "%s", rname);
     }
@@ -8333,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 (AOP (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 (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, source, offset++);
     }
+  return NULL;
 }
 
 
@@ -8358,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 (AOP (left), 0, FALSE, TRUE);
+  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 (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -8391,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);
@@ -8414,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)))
@@ -8421,11 +10014,17 @@ genNearPointerGet (operand * left,
       if (IS_AOP_PREG (left))
         {
           // Aha, it is a pointer, just in disguise.
-          rname = aopGet (AOP (left), 0, FALSE, FALSE);
-          if (*rname != '@')
+          rname = aopGet (left, 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 (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
             {
@@ -8441,19 +10040,16 @@ genNearPointerGet (operand * left,
           preg = getFreePtr (ic, &aop, FALSE);
           emitcode ("mov", "%s,%s",
                     preg->name,
-                    aopGet (AOP (left), 0, FALSE, TRUE));
+                    aopGet (left, 0, FALSE, TRUE));
           rname = preg->name;
         }
-    }
-  else
-    rname = aopGet (AOP (left), 0, FALSE, FALSE);
-
-  //aopOp (result, ic, FALSE);
-  aopOp (result, ic, result?TRUE:FALSE);
+    }
+  else
+    rname = aopGet (left, 0, FALSE, 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 */
@@ -8467,12 +10063,14 @@ genNearPointerGet (operand * left,
 
               emitcode ("mov", "a,@%s", rname);
               if (!ifx)
-              aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+                aopPut (result, "a", offset);
             }
           else
             {
-              sprintf (buffer, "@%s", rname);
-              aopPut (AOP (result), buffer, offset, isOperandVolatile (result, FALSE));
+              char buffer[80];
+
+              SNPRINTF (buffer, sizeof(buffer), "@%s", rname);
+              aopPut (result, buffer, offset);
             }
           offset++;
           if (size || pi)
@@ -8481,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(AOP ( left ),rname,0, isOperandVolatile (left, FALSE));
+        aopPut (left, rname, 0);
       }
       freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
     }
@@ -8509,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 */
@@ -8531,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)))
@@ -8549,17 +10150,15 @@ genPagedPointerGet (operand * left,
       preg = getFreePtr (ic, &aop, FALSE);
       emitcode ("mov", "%s,%s",
                 preg->name,
-                aopGet (AOP (left), 0, FALSE, TRUE));
+                aopGet (left, 0, FALSE, TRUE));
       rname = preg->name;
     }
   else
-    rname = aopGet (AOP (left), 0, FALSE, FALSE);
-
-  aopOp (result, ic, FALSE);
+    rname = aopGet (left, 0, FALSE, 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 */
@@ -8571,7 +10170,7 @@ genPagedPointerGet (operand * left,
 
           emitcode ("movx", "a,@%s", rname);
           if (!ifx)
-          aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset);
 
           offset++;
 
@@ -8581,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 ( AOP (left), rname, 0, isOperandVolatile (left, FALSE));
+      if (pi)
+        aopPut (left, rname, 0);
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -8607,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;
-
 }
 
 /*--------------------------------------------------------------------*/
@@ -8628,21 +10227,21 @@ loadDptrFromOperand (operand *op, bool loadBToo)
       /* if this is rematerializable */
       if (AOP_TYPE (op) == AOP_IMMD)
         {
-          emitcode ("mov", "dptr,%s", aopGet (AOP (op), 0, TRUE, FALSE));
+          emitcode ("mov", "dptr,%s", aopGet (op, 0, TRUE, FALSE));
           if (loadBToo)
             {
               if (AOP(op)->aopu.aop_immd.from_cast_remat)
-                emitcode ("mov", "b,%s",aopGet(AOP (op), AOP_SIZE(op)-1, FALSE, FALSE));
+                emitcode ("mov", "b,%s",aopGet (op, AOP_SIZE(op)-1, FALSE, FALSE));
               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:
                   **  emitcode ("mov", "b,#%d", pointerCode (retype));
                   ** from genPointerSet:
-                  **  emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE));
+                  **  emitcode ("mov", "b,%s + 1", aopGet (result, 0, TRUE, FALSE));
                   */
                 }
             }
@@ -8651,43 +10250,44 @@ loadDptrFromOperand (operand *op, bool loadBToo)
         {
           if (loadBToo)
             {
-              MOVA (aopGet (AOP (op), 0, FALSE, FALSE));
+              MOVA (aopGet (op, 0, FALSE, FALSE));
               emitcode ("push", "acc");
-              MOVA (aopGet (AOP (op), 1, FALSE, FALSE));
+              MOVA (aopGet (op, 1, FALSE, FALSE));
               emitcode ("push", "acc");
-              emitcode ("mov", "b,%s", aopGet (AOP (op), 2, FALSE, FALSE));
+              emitcode ("mov", "b,%s", aopGet (op, 2, FALSE, FALSE));
               emitcode ("pop", "dph");
               emitcode ("pop", "dpl");
             }
           else
             {
-              MOVA (aopGet (AOP (op), 0, FALSE, FALSE));
+              MOVA (aopGet (op, 0, FALSE, FALSE));
               emitcode ("push", "acc");
-              emitcode ("mov", "dph,%s", aopGet (AOP (op), 1, FALSE, FALSE));
+              emitcode ("mov", "dph,%s", aopGet (op, 1, FALSE, FALSE));
               emitcode ("pop", "dpl");
             }
         }
       else
         {                       /* we need to get it byte by byte */
-          emitcode ("mov", "dpl,%s", aopGet (AOP (op), 0, FALSE, FALSE));
-          emitcode ("mov", "dph,%s", aopGet (AOP (op), 1, FALSE, FALSE));
+          emitcode ("mov", "dpl,%s", aopGet (op, 0, FALSE, FALSE));
+          emitcode ("mov", "dph,%s", aopGet (op, 1, FALSE, FALSE));
           if (loadBToo)
-            emitcode ("mov", "b,%s", aopGet (AOP (op), 2, FALSE, FALSE));
+            emitcode ("mov", "b,%s", aopGet (op, 2, FALSE, FALSE));
         }
     }
 }
 
 /*-----------------------------------------------------------------*/
-/* 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);
@@ -8697,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);
@@ -8707,7 +10307,7 @@ genFarPointerGet (operand * left,
         {
           emitcode ("movx", "a,@dptr");
           if (!ifx)
-            aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset++);
           if (size || pi)
             emitcode ("inc", "dptr");
         }
@@ -8715,31 +10315,32 @@ genFarPointerGet (operand * left,
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
     {
-    aopPut ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
-    aopPut ( AOP (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);
@@ -8749,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);
@@ -8757,61 +10358,55 @@ genCodePointerGet (operand * left,
 
       while (size--)
         {
-          if (pi)
-            {
-              emitcode ("clr", "a");
-              emitcode ("movc", "a,@a+dptr");
-              if (!ifx)
-              aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
-              emitcode ("inc", "dptr");
-            }
-          else
-            {
-              emitcode ("mov", "a,#0x%02x", offset);
-              emitcode ("movc", "a,@a+dptr");
-              if (!ifx)
-              aopPut (AOP (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 ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
-    aopPut ( AOP (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);
@@ -8821,7 +10416,7 @@ genGenPointerGet (operand * left,
         {
           emitcode ("lcall", "__gptrget");
           if (!ifx)
-          aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset++);
           if (size || pi)
             emitcode ("inc", "dptr");
         }
@@ -8829,19 +10424,18 @@ genGenPointerGet (operand * left,
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
     {
-    aopPut ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
-    aopPut ( AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -8854,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);
@@ -8868,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 */
@@ -8877,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)
@@ -8908,11 +10505,9 @@ genPointerGet (iCode * ic, iCode *pi, iCode *ifx)
       genGenPointerGet (left, result, ic, pi, ifx);
       break;
     }
-
 }
 
 
-
 /*-----------------------------------------------------------------*/
 /* genPackBits - generates code for packed bit storage             */
 /*-----------------------------------------------------------------*/
@@ -8928,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);
@@ -8943,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);
@@ -8962,7 +10557,7 @@ genPackBits (sym_link * etype,
                 emitcode ("mov", "c,%s", AOP(right)->aopu.aop_dir);
               else
                 {
-                  MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+                  MOVA (aopGet (right, 0, FALSE, FALSE));
                   emitcode ("rrc","a");
                 }
               emitPtrByteGet (rname, p_type, FALSE);
@@ -8973,7 +10568,7 @@ genPackBits (sym_link * etype,
               bool pushedB;
               /* Case with a bitfield length < 8 and arbitrary source
               */
-              MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+              MOVA (aopGet (right, 0, FALSE, FALSE));
               /* shift and mask source value */
               AccLsh (bstr);
               emitcode ("anl", "a,#0x%02x", (~mask) & 0xff);
@@ -9000,7 +10595,7 @@ genPackBits (sym_link * etype,
   for (rlen=blen;rlen>=8;rlen-=8)
     {
       emitPtrByteSet (rname, p_type,
-                      aopGet (AOP (right), offset++, FALSE, TRUE) );
+                      aopGet (right, offset++, FALSE, TRUE) );
       if (rlen>8)
         emitcode ("inc", "%s", rname);
     }
@@ -9014,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);
@@ -9028,7 +10623,7 @@ genPackBits (sym_link * etype,
           bool pushedB;
           /* Case with partial byte and arbitrary source
           */
-          MOVA (aopGet (AOP (right), offset++, FALSE, FALSE));
+          MOVA (aopGet (right, offset++, FALSE, FALSE));
           emitcode ("anl", "a,#0x%02x", (~mask) & 0xff);
 
           pushedB = pushB ();
@@ -9044,7 +10639,6 @@ genPackBits (sym_link * etype,
         }
       emitPtrByteSet (rname, p_type, "a");
     }
-
 }
 
 
@@ -9059,20 +10653,21 @@ genDataPointerSet (operand * right,
   int size, offset = 0;
   char *l, buffer[256];
 
-  D(emitcode (";     genDataPointerSet",""));
+  D (emitcode (";", "genDataPointerSet"));
 
   aopOp (right, ic, FALSE);
 
-  l = aopGet (AOP (result), 0, FALSE, TRUE);
-  size = AOP_SIZE (right);
+  l = aopGet (result, 0, FALSE, TRUE);
+  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 (AOP (right), offset++, FALSE, FALSE));
+                aopGet (right, offset++, FALSE, FALSE));
     }
 
   freeAsmop (right, NULL, ic, TRUE);
@@ -9080,7 +10675,7 @@ genDataPointerSet (operand * right,
 }
 
 /*-----------------------------------------------------------------*/
-/* genNearPointerSet - emitcode for near pointer put                */
+/* genNearPointerSet - emitcode for near pointer put               */
 /*-----------------------------------------------------------------*/
 static void
 genNearPointerSet (operand * right,
@@ -9094,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 &
@@ -9115,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 (AOP (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 (AOP (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 (AOP (result), 0, FALSE, FALSE);
+      rname = aopGet (result, 0, FALSE, FALSE);
     }
 
   aopOp (right, ic, FALSE);
@@ -9157,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 (AOP (right), offset, FALSE, TRUE);
-          if (*l == '@')
+          l = aopGet (right, offset, FALSE, TRUE);
+          if ((*l == '@') || (strcmp (l, "acc") == 0))
             {
               MOVA (l);
               emitcode ("mov", "@%s,a", rname);
@@ -9178,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 (AOP (result), rname, 0, isOperandVolatile (result, FALSE));
+        aopPut (result, rname, 0);
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -9204,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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -9223,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));
@@ -9234,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 (AOP (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 (AOP (result), 0, FALSE, FALSE);
+    {
+      rname = aopGet (result, 0, FALSE, FALSE);
+    }
 
   aopOp (right, ic, FALSE);
 
@@ -9252,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 (AOP (right), offset, FALSE, TRUE);
-
+          l = aopGet (right, offset, FALSE, TRUE);
           MOVA (l);
           emitcode ("movx", "@%s,a", rname);
-
           if (size || pi)
             emitcode ("inc", "%s", rname);
-
           offset++;
         }
     }
@@ -9274,7 +10892,7 @@ genPagedPointerSet (operand * right,
   if (aop) /* we had to allocate for this iCode */
     {
       if (pi)
-        aopPut (AOP (result), rname, 0, isOperandVolatile (result, FALSE));
+        aopPut (result, rname, 0);
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -9286,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--)
@@ -9296,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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -9314,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 */
@@ -9332,7 +10949,7 @@ genFarPointerSet (operand * right,
 
       while (size--)
         {
-          char *l = aopGet (AOP (right), offset++, FALSE, FALSE);
+          char *l = aopGet (right, offset++, FALSE, FALSE);
           MOVA (l);
           emitcode ("movx", "@dptr,a");
           if (size || pi)
@@ -9340,8 +10957,8 @@ genFarPointerSet (operand * right,
         }
     }
   if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
-    aopPut (AOP(result), "dpl", 0, isOperandVolatile (result, FALSE));
-    aopPut (AOP(result), "dph", 1, isOperandVolatile (result, FALSE));
+    aopPut (result, "dpl", 0);
+    aopPut (result, "dph", 1);
     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);
@@ -9359,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);
@@ -9377,7 +10996,7 @@ genGenPointerSet (operand * right,
 
       while (size--)
         {
-          char *l = aopGet (AOP (right), offset++, FALSE, FALSE);
+          char *l = aopGet (right, offset++, FALSE, FALSE);
           MOVA (l);
           emitcode ("lcall", "__gptrput");
           if (size || pi)
@@ -9386,8 +11005,8 @@ genGenPointerSet (operand * right,
     }
 
   if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
-    aopPut (AOP(result), "dpl", 0, isOperandVolatile (result, FALSE));
-    aopPut (AOP(result), "dph", 1, isOperandVolatile (result, FALSE));
+    aopPut (result, "dpl", 0);
+    aopPut (result, "dph", 1);
     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);
@@ -9404,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);
@@ -9431,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)
@@ -9457,7 +11077,6 @@ genPointerSet (iCode * ic, iCode *pi)
       werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
               "genPointerSet: illegal pointer type");
     }
-
 }
 
 /*-----------------------------------------------------------------*/
@@ -9468,31 +11087,36 @@ genIfx (iCode * ic, iCode * popIc)
 {
   operand *cond = IC_COND (ic);
   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;
-  /* the result is now in the accumulator */
-  freeAsmop (cond, NULL, ic, TRUE);
+    {
+      isbit = 1;
+      if (AOP(cond)->aopu.aop_dir)
+        dup = Safe_strdup(AOP(cond)->aopu.aop_dir);
+    }
 
-  /* if there was something to be popped then do it */
-  if (popIc)
-    genIpop (popIc);
+  /* the result is now in the accumulator or a directly addressable bit */
+  freeAsmop (cond, NULL, ic, TRUE);
 
   /* if the condition is a bit variable */
-  if (isbit && IS_ITEMP (cond) &&
-      SPIL_LOC (cond))
-    genIfxJump (ic, SPIL_LOC (cond)->rname, NULL, NULL, NULL);
+  if (isbit && dup)
+    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, 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;
 }
@@ -9506,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);
 
@@ -9515,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,_bp");
-          emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ?
-                                         ((char) (sym->stack - _G.nRegsSaved)) :
-                                         ((char) sym->stack)) & 0xff);
-          aopPut (AOP (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 (AOP (IC_RESULT (ic)), "_bp", 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;
@@ -9536,31 +11173,40 @@ genAddrOf (iCode * ic)
       offset = 1;
       while (size--)
         {
-          aopPut (AOP (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 (AOP (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);
-
 }
 
 /*-----------------------------------------------------------------*/
@@ -9573,12 +11219,12 @@ 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--)
     {
-      l = aopGet (AOP (right), offset++, FALSE, FALSE);
+      l = aopGet (right, offset++, FALSE, FALSE);
       MOVA (l);
       emitcode ("push", "acc");
     }
@@ -9590,10 +11236,9 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   while (size--)
     {
       emitcode ("pop", "acc");
-      aopPut (AOP (result), "a", --offset, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", --offset);
     }
   freeAsmop (result, NULL, ic, FALSE);
-
 }
 
 /*-----------------------------------------------------------------*/
@@ -9606,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);
@@ -9624,7 +11269,6 @@ genAssign (iCode * ic)
       IS_TRUE_SYMOP (result) &&
       isOperandInFarSpace (result))
     {
-
       genFarFarAssign (result, right, ic);
       return;
     }
@@ -9640,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 (AOP (result), one, 0, isOperandVolatile (result, FALSE));
-          else
-            aopPut (AOP (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 (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
-          goto release;
-        }
-
-      /* we need to or */
-      toBoolean (right);
-      aopPut (AOP (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) &&
@@ -9680,18 +11303,21 @@ genAssign (iCode * ic)
     {
       while ((size) && (lit))
         {
-          aopPut (AOP (result),
-                  aopGet (AOP (right), offset, FALSE, FALSE),
-                  offset,
-                  isOperandVolatile (result, FALSE));
+          aopPut (result,
+                  aopGet (right, offset, FALSE, FALSE),
+                  offset);
           lit >>= 8;
           offset++;
           size--;
         }
-      emitcode ("clr", "a");
+      /* And now fill the rest with zeros. */
+      if (size)
+        {
+          emitcode ("clr", "a");
+        }
       while (size--)
         {
-          aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", offset);
           offset++;
         }
     }
@@ -9699,21 +11325,21 @@ genAssign (iCode * ic)
     {
       while (size--)
         {
-          aopPut (AOP (result),
-                  aopGet (AOP (right), offset, FALSE, FALSE),
-                  offset,
-                  isOperandVolatile (result, FALSE));
+          aopPut (result,
+                  aopGet (right, offset, FALSE, FALSE),
+                  offset);
           offset++;
         }
     }
+  adjustArithmeticResult (ic);
 
 release:
-  freeAsmop (right, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
-/* genJumpTab - genrates code for jump table                       */
+/* genJumpTab - generates code for jump table                      */
 /*-----------------------------------------------------------------*/
 static void
 genJumpTab (iCode * ic)
@@ -9722,7 +11348,7 @@ genJumpTab (iCode * ic)
   char *l;
   unsigned int count;
 
-  D(emitcode (";     genJumpTab",""));
+  D (emitcode (";", "genJumpTab"));
 
   count = elementsInSet( IC_JTLABELS (ic) );
 
@@ -9731,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 (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE);
+      l = aopGet (IC_JTCOND (ic), 0, FALSE, FALSE);
       MOVA (l);
       /* multiply by three */
-      emitcode ("add", "a,acc");
-      emitcode ("add", "a,%s", aopGet (AOP (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)))
@@ -9762,12 +11397,12 @@ genJumpTab (iCode * ic)
       /* get the condition into accumulator.
          Using b as temporary storage, if register push/pop is needed */
       aopOp (IC_JTCOND (ic), ic, FALSE);
-      l = aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE);
+      l = aopGet (IC_JTCOND (ic), 0, FALSE, FALSE);
       if ((AOP_TYPE (IC_JTCOND (ic)) == AOP_R0 && _G.r0Pushed) ||
           (AOP_TYPE (IC_JTCOND (ic)) == AOP_R1 && _G.r1Pushed))
         {
           // (MB) what if B is in use???
-          wassertl(!_G.BInUse, "B was in use");
+          wassertl(!BINUSE, "B was in use");
           emitcode ("mov", "b,%s", l);
           l = "b";
         }
@@ -9801,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);
@@ -9826,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)))
@@ -9836,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 (AOP (result), one, 0, isOperandVolatile (result, FALSE));
-          else
-            aopPut (AOP (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 (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
-          goto release;
-        }
-
-      /* we need to or */
-      toBoolean (right);
-      aopPut (AOP (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))
     {
@@ -9880,20 +11490,17 @@ genCast (iCode * ic)
       offset = 0;
       while (size--)
         {
-          aopPut (AOP (result),
-                  aopGet (AOP (right), offset, FALSE, FALSE),
-                  offset,
-                  isOperandVolatile (result, FALSE));
+          aopPut (result,
+                  aopGet (right, offset, FALSE, 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);
@@ -9902,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) {
@@ -9919,10 +11528,9 @@ genCast (iCode * ic)
           offset = 0;
           while (size--)
             {
-              aopPut (AOP (result),
-                      aopGet (AOP (right), offset, FALSE, FALSE),
-                      offset,
-                      isOperandVolatile (result, FALSE));
+              aopPut (result,
+                      aopGet (right, offset, FALSE, FALSE),
+                      offset);
               offset++;
             }
           /* the last byte depending on type */
@@ -9936,8 +11544,8 @@ genCast (iCode * ic)
                     exit(1);
                 }
 
-                sprintf(gpValStr, "#0x%d", gpVal);
-                aopPut (AOP (result), gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
+                sprintf(gpValStr, "#0x%02x", gpVal);
+                aopPut (result, gpValStr, GPTRSIZE - 1);
             }
           goto release;
         }
@@ -9947,10 +11555,9 @@ genCast (iCode * ic)
       offset = 0;
       while (size--)
         {
-          aopPut (AOP (result),
-                  aopGet (AOP (right), offset, FALSE, FALSE),
-                  offset,
-                  isOperandVolatile (result, FALSE));
+          aopPut (result,
+                  aopGet (right, offset, FALSE, FALSE),
+                  offset);
           offset++;
         }
       goto release;
@@ -9963,10 +11570,9 @@ genCast (iCode * ic)
   offset = 0;
   while (size--)
     {
-      aopPut (AOP (result),
-              aopGet (AOP (right), offset, FALSE, FALSE),
-              offset,
-              isOperandVolatile (result, FALSE));
+      aopPut (result,
+              aopGet (right, offset, FALSE, FALSE),
+              offset);
       offset++;
     }
 
@@ -9976,26 +11582,25 @@ genCast (iCode * ic)
   if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE(right)==AOP_CRY)
     {
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);
     }
   else
     {
       /* we need to extend the sign :{ */
-      char *l = aopGet (AOP (right), AOP_SIZE (right) - 1,
+      char *l = aopGet (right, AOP_SIZE (right) - 1,
                         FALSE, FALSE);
       MOVA (l);
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
-        aopPut (AOP (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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -10008,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;
@@ -10030,6 +11632,9 @@ genDjnz (iCode * ic, iCode * ifx)
     return 0;
 
   /* otherwise we can save BIG */
+
+  D (emitcode (";", "genDjnz"));
+
   lbl = newiTempLabel (NULL);
   lbl1 = newiTempLabel (NULL);
 
@@ -10041,7 +11646,7 @@ genDjnz (iCode * ic, iCode * ifx)
        * the accumulator, we must explicitly write
        * it back after the decrement.
        */
-      char *rByte = aopGet(AOP(IC_RESULT(ic)), 0, FALSE, FALSE);
+      char *rByte = aopGet (IC_RESULT(ic), 0, FALSE, FALSE);
 
       if (strcmp(rByte, "a"))
       {
@@ -10055,27 +11660,30 @@ genDjnz (iCode * ic, iCode * ifx)
            return 0;
       }
       emitcode ("dec", "%s", rByte);
-      aopPut(AOP(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)))
     {
       emitcode ("dec", "%s",
-                aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
-      MOVA (aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
+                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
     {
-      emitcode ("djnz", "%s,%05d$", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE),
+      emitcode ("djnz", "%s,%05d$", aopGet (IC_RESULT (ic), 0, FALSE, FALSE),
                 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;
 }
@@ -10086,15 +11694,18 @@ genDjnz (iCode * ic, iCode * ifx)
 static void
 genReceive (iCode * ic)
 {
-    int size = getSize (operandType (IC_RESULT (ic)));
-    int offset = 0;
-  D(emitcode (";     genReceive",""));
+  int size = getSize (operandType (IC_RESULT (ic)));
+  int offset = 0;
 
-  if (ic->argreg == 1) { /* first parameter */
-      if (isOperandInFarSpace (IC_RESULT (ic)) &&
-          (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
-           IS_TRUE_SYMOP (IC_RESULT (ic)))) {
+  D (emitcode (";", "genReceive"));
 
+  if (ic->argreg == 1)
+    { /* first parameter */
+      if ((isOperandInFarSpace (IC_RESULT (ic)) ||
+           isOperandInPagedSpace (IC_RESULT (ic))) &&
+          (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
+           IS_TRUE_SYMOP (IC_RESULT (ic))))
+        {
           regs *tempRegs[4];
           int receivingA = 0;
           int roffset = 0;
@@ -10113,11 +11724,9 @@ genReceive (iCode * ic)
                   _G.accInUse++;
                   aopOp (IC_RESULT (ic), ic, FALSE);
                   _G.accInUse--;
-                  aopPut (AOP (IC_RESULT (ic)), "a", offset,
-                          isOperandVolatile (IC_RESULT (ic), FALSE));
+                  aopPut (IC_RESULT (ic), "a", offset);
                   for (offset = 1; offset<size; offset++)
-                    aopPut (AOP (IC_RESULT (ic)), tempRegs[--roffset]->name, offset,
-                            isOperandVolatile (IC_RESULT (ic), FALSE));
+                    aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset);
                   goto release;
                 }
             }
@@ -10129,40 +11738,57 @@ genReceive (iCode * ic)
                     emitcode("mov","%s,%s", tempRegs[offset]->name, fReturn[offset]);
                   aopOp (IC_RESULT (ic), ic, FALSE);
                   for (offset = 0; offset<size; offset++)
-                    aopPut (AOP (IC_RESULT (ic)), tempRegs[offset]->name, offset,
-                            isOperandVolatile (IC_RESULT (ic), FALSE));
+                    aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset);
                   goto release;
                 }
             }
 
           offset = fReturnSizeMCS51 - size;
-          while (size--) {
+          while (size--)
+            {
               emitcode ("push", "%s", (strcmp (fReturn[fReturnSizeMCS51 - offset - 1], "a") ?
                                        fReturn[fReturnSizeMCS51 - offset - 1] : "acc"));
               offset++;
-          }
+            }
           aopOp (IC_RESULT (ic), ic, FALSE);
           size = AOP_SIZE (IC_RESULT (ic));
           offset = 0;
-          while (size--) {
+          while (size--)
+            {
               emitcode ("pop", "acc");
-              aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
-          }
-
-      } else {
+              aopPut (IC_RESULT (ic), "a", offset++);
+            }
+        }
+      else
+        {
           _G.accInUse++;
           aopOp (IC_RESULT (ic), ic, FALSE);
           _G.accInUse--;
-          assignResultValue (IC_RESULT (ic));
-      }
-  } else { /* second receive onwards */
+          assignResultValue (IC_RESULT (ic), NULL);
+        }
+    }
+  else if (ic->argreg > 12)
+    { /* bit parameters */
+      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]);
+          outBitC(IC_RESULT (ic));
+        }
+    }
+  else
+    { /* other parameters */
       int rb1off ;
       aopOp (IC_RESULT (ic), ic, FALSE);
       rb1off = ic->argreg;
-      while (size--) {
-          aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
-      }
-  }
+      while (size--)
+        {
+          aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++);
+        }
+    }
 
 release:
   freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
@@ -10177,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))
@@ -10195,7 +11821,7 @@ genDummyRead (iCode * ic)
           offset = 0;
           while (size--)
           {
-            MOVA (aopGet (AOP (op), offset, FALSE, FALSE));
+            MOVA (aopGet (op, offset, FALSE, FALSE));
             offset++;
           }
         }
@@ -10219,7 +11845,7 @@ genDummyRead (iCode * ic)
           offset = 0;
           while (size--)
           {
-            MOVA (aopGet (AOP (op), offset, FALSE, FALSE));
+            MOVA (aopGet (op, offset, FALSE, FALSE));
             offset++;
           }
         }
@@ -10236,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 (AOP (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 (AOP (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
@@ -10252,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*/
     }
 }
@@ -10263,7 +11889,7 @@ genCritical (iCode *ic)
 static void
 genEndCritical (iCode *ic)
 {
-  D(emitcode(";     genEndCritical",""));
+  D(emitcode(";", "genEndCritical"));
 
   if (IC_RIGHT (ic))
     {
@@ -10276,7 +11902,7 @@ genEndCritical (iCode *ic)
       else
         {
           if (AOP_TYPE (IC_RIGHT (ic)) != AOP_DUMMY)
-            MOVA (aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
+            MOVA (aopGet (IC_RIGHT (ic), 0, FALSE, FALSE));
           emitcode ("rrc", "a");
           emitcode ("mov", "ea,c");
         }
@@ -10304,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)
     {
@@ -10328,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;
@@ -10336,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 (&regsInUse[i],
-                   "%c", ic->riu & (1<<i) ? i+'0' : '-');
-        }
+                   "%c", ic->riu & (1<<i) ? i+'0' : '-'); /* show riu */
         regsInUse[i]=0;
-        emitcode("", "; [%s] ic:%d: %s", regsInUse, ic->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
@@ -10378,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:
@@ -10454,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;
@@ -10499,6 +12145,18 @@ gen51Code (iCode * lic)
           genGetHbit (ic);
           break;
 
+        case GETABIT:
+          genGetAbit (ic);
+          break;
+
+        case GETBYTE:
+          genGetByte (ic);
+          break;
+
+        case GETWORD:
+          genGetWord (ic);
+          break;
+
         case LEFT_OP:
           genLeftShift (ic);
           break;
@@ -10516,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;
@@ -10574,6 +12234,6 @@ gen51Code (iCode * lic)
     peepHole (&lineHead);
 
   /* now do the actual printing */
-  printLine (lineHead, codeOutFile);
+  printLine (lineHead, codeOutBuf);
   return;
 }