X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fmcs51%2Fgen.c;h=fbbe3a9f14336e693bc31b1439259d9941a5586a;hb=39ce53a15aaf8e5d1f0cd723e0a8732904865296;hp=83cadf84ea92165b8b94e7b586a88ca4d6af4870;hpb=8d326ee2d53edf7e720d694f73d29b8b1a27d87d;p=fw%2Fsdcc

diff --git a/src/mcs51/gen.c b/src/mcs51/gen.c
index 83cadf84..fbbe3a9f 100644
--- a/src/mcs51/gen.c
+++ b/src/mcs51/gen.c
@@ -44,6 +44,7 @@
 #include "gen.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,12 +65,41 @@ static char *accUse[] =
 
 static unsigned short rbank = -1;
 
+#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) )))
+
+
+#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;
     short r1Pushed;
-    short r0InB;
-    short r1InB;
+    union
+      {
+        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;
@@ -81,20 +111,22 @@ 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);
+
 #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 CLRC    emitcode("clr","c")
-#define SETC    emitcode("setb","c")
+#define MOVA(x)  mova(x)  /* use function to avoid multiple eval */
+#define CLRC     emitcode("clr","c")
+#define SETC     emitcode("setb","c")
 
 static lineNode *lineHead = NULL;
 static lineNode *lineCurr = NULL;
@@ -126,23 +158,21 @@ emitcode (char *inst, const char *fmt,...)
   if (inst && *inst)
     {
       if (fmt && *fmt)
-        SNPRINTF (lb, sizeof(lb), "%s\t", inst);
+          SNPRINTF (lb, sizeof(lb), "%s\t", inst);
       else
-        SNPRINTF (lb, sizeof(lb), "%s", inst);
+          SNPRINTF (lb, sizeof(lb), "%s", inst);
       tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb), fmt, ap);
     }
   else
-    tvsprintf (lb, sizeof(lb), fmt, ap);
-
-  while (isspace (*lbp))
-    lbp++;
+      tvsprintf (lb, sizeof(lb), fmt, ap);
 
-  //printf ("%s\n", lb);
+  while (isspace ((unsigned char)*lbp))
+      lbp++;
 
   if (lbp && *lbp)
-    lineCurr = (lineCurr ?
-                connectLine (lineCurr, newLineNode (lb)) :
-                (lineHead = newLineNode (lb)));
+      lineCurr = (lineCurr ?
+                  connectLine (lineCurr, newLineNode (lb)) :
+                  (lineHead = newLineNode (lb)));
   lineCurr->isInline = _G.inLine;
   lineCurr->isDebug = _G.debugLine;
   lineCurr->ic = _G.current_iCode;
@@ -169,20 +199,111 @@ static void
 mova (const char *x)
 {
   /* do some early peephole optimization */
-  if (!strcmp(x, "a") || !strcmp(x, "acc"))
+  if (!strncmp(x, "a", 2) || !strncmp(x, "acc", 4))
     return;
 
   emitcode("mov","a,%s", x);
 }
 
+/*-----------------------------------------------------------------*/
+/* movc - moves specified value into the carry                     */
+/*-----------------------------------------------------------------*/
+static void
+movc (const char *s)
+{
+  if (s == zero)
+    CLRC;
+  else if (s == one)
+    SETC;
+  else if (strcmp (s, "c"))
+    {/* it's not in carry already */
+      MOVA (s);
+      /* set C, if a >= 1 */
+      emitcode ("add", "a,#0xff");
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* pushB - saves register B if necessary                           */
+/*-----------------------------------------------------------------*/
+static bool
+pushB (void)
+{
+  bool pushedB = FALSE;
+
+  if (BINUSE)
+    {
+      emitcode ("push", "b");
+//    printf("B was in use !\n");
+      pushedB = TRUE;
+    }
+  else
+    {
+      OPINB++;
+    }
+  return pushedB;
+}
+
+/*-----------------------------------------------------------------*/
+/* popB - restores value of register B if necessary                */
+/*-----------------------------------------------------------------*/
+static void
+popB (bool pushedB)
+{
+  if (pushedB)
+    {
+      emitcode ("pop", "b");
+    }
+  else
+    {
+      OPINB--;
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* pushReg - saves register                                        */
+/*-----------------------------------------------------------------*/
+static bool
+pushReg (int index, bool bits_pushed)
+{
+  regs * reg = mcs51_regWithIdx (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 = mcs51_regWithIdx (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;
+}
+
 /*-----------------------------------------------------------------*/
 /* getFreePtr - returns r0 or r1 whichever is free or can be pushed */
 /*-----------------------------------------------------------------*/
 static regs *
 getFreePtr (iCode * ic, asmop ** aopp, bool result)
 {
-  bool r0iu = FALSE, r1iu = FALSE;
-  bool r0ou = FALSE, r1ou = FALSE;
+  bool r0iu, r1iu;
+  bool r0ou, r1ou;
 
   /* the logic: if r0 & r1 used in the instruction
      then we are in trouble otherwise */
@@ -225,7 +346,7 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result)
         {
           emitcode ("mov", "b,%s",
                     mcs51_regWithIdx (R0_IDX)->dname);
-          _G.r0InB++;
+          R0INB++;
         }
       else if (!_G.r0Pushed)
         {
@@ -249,7 +370,7 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result)
         {
           emitcode ("mov", "b,%s",
                     mcs51_regWithIdx (R1_IDX)->dname);
-          _G.r1InB++;
+          R1INB++;
         }
       else if (!_G.r1Pushed)
         {
@@ -337,7 +458,7 @@ getTempRegs(regs **tempRegs, int size, iCode *ic)
     }
 
   freeBitVect(freeRegs);
-  return 1;
+  return 0;
 }
 
 
@@ -365,7 +486,6 @@ pointerCode (sym_link * etype)
 
 }
 
-
 /*-----------------------------------------------------------------*/
 /* leftRightUseAcc - returns size of accumulator use by operands   */
 /*-----------------------------------------------------------------*/
@@ -432,7 +552,6 @@ leftRightUseAcc(iCode *ic)
     return accuse;
 }
 
-
 /*-----------------------------------------------------------------*/
 /* aopForSym - for a true symbol                                   */
 /*-----------------------------------------------------------------*/
@@ -467,19 +586,36 @@ aopForSym (iCode * ic, symbol * sym, bool result)
 
           if (sym->onStack)
             {
-              if (_G.accInUse || leftRightUseAcc (ic))
-                emitcode ("push", "acc");
-
-              emitcode ("mov", "a,_bp");
-              emitcode ("add", "a,#0x%02x",
-                        ((sym->stack < 0) ?
+              char offset = ((sym->stack < 0) ?
                          ((char) (sym->stack - _G.nRegsSaved)) :
-                         ((char) sym->stack)) & 0xff);
-              emitcode ("mov", "%s,a",
-                        aop->aopu.aop_ptr->name);
+                         ((char) sym->stack)) & 0xff;
 
-              if (_G.accInUse || leftRightUseAcc (ic))
-                emitcode ("pop", "acc");
+              if ((offset >= -3) && (offset <= 3))
+                {
+                  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 (_G.accInUse || leftRightUseAcc (ic))
+                    emitcode ("push", "acc");
+                  emitcode ("mov", "a,%s", SYM_BP (sym));
+                  emitcode ("add", "a,#0x%02x", offset);
+                  emitcode ("mov", "%s,a",
+                            aop->aopu.aop_ptr->name);
+                  if (_G.accInUse || leftRightUseAcc (ic))
+                    emitcode ("pop", "acc");
+                }
             }
           else
             emitcode ("mov", "%s,#%s",
@@ -518,7 +654,7 @@ aopForSym (iCode * ic, symbol * sym, bool result)
       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->size = getSize (sym->type);
       return aop;
     }
 
@@ -543,7 +679,7 @@ aopForRemat (symbol * sym)
 {
   iCode *ic = sym->rematiCode;
   asmop *aop = newAsmop (AOP_IMMD);
-  int ptr_type=0;
+  int ptr_type = 0;
   int val = 0;
 
   for (;;)
@@ -556,12 +692,8 @@ aopForRemat (symbol * sym)
               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 ;
+              ptr_type = pointerTypeToGPByte (DCL_TYPE(from_type), NULL, NULL);
+              continue;
       } else break;
 
       ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
@@ -633,7 +765,7 @@ operandsEqu (operand * op1, operand * op2)
 {
   symbol *sym1, *sym2;
 
-  /* if they not symbols */
+  /* if they're not symbols */
   if (!IS_SYMOP (op1) || !IS_SYMOP (op2))
     return FALSE;
 
@@ -650,8 +782,10 @@ operandsEqu (operand * op1, operand * op2)
   if (sym1 == sym2)
     return TRUE;
 
-  if (sym1->rname[0] && sym2->rname[0]
-      && strcmp (sym1->rname, sym2->rname) == 0)
+  /* if they have the same rname */
+  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 */
@@ -682,8 +816,10 @@ 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)
@@ -738,7 +874,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
@@ -810,6 +946,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;
@@ -843,10 +989,10 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
   switch (aop->type)
     {
     case AOP_R0:
-      if (_G.r0InB)
+      if (R0INB)
         {
           emitcode ("mov", "r0,b");
-          _G.r0InB--;
+          R0INB--;
         }
       else if (_G.r0Pushed)
         {
@@ -860,10 +1006,10 @@ 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)
         {
@@ -958,7 +1104,7 @@ freeForBranchAsmop (operand * op)
   switch (aop->type)
     {
     case AOP_R0:
-      if (_G.r0InB)
+      if (R0INB)
         {
           emitcode ("mov", "r0,b");
         }
@@ -969,7 +1115,7 @@ freeForBranchAsmop (operand * op)
       break;
 
     case AOP_R1:
-      if (_G.r1InB)
+      if (R1INB)
         {
           emitcode ("mov", "r1,b");
         }
@@ -1015,8 +1161,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;
 
@@ -1040,6 +1188,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;
@@ -1060,10 +1210,11 @@ aopGetUsesAcc (asmop *aop, int offset)
 /* 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 */
@@ -1152,7 +1303,10 @@ aopGet (asmop * aop, int offset, bool bit16, bool dname)
       return rs;
 
     case AOP_DIR:
-      if (offset)
+      if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset)
+        sprintf (s, "(%s >> %d)",
+                 aop->aopu.aop_dir, offset * 8);
+      else if (offset)
         sprintf (s, "(%s + %d)",
                  aop->aopu.aop_dir,
                  offset);
@@ -1196,13 +1350,59 @@ 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, bool bvolatile)
 {
   char *d = buffer;
+  bool accuse = FALSE;
+  asmop * aop = AOP (result);
 
   if (aop->size && offset > (aop->size - 1))
     {
@@ -1217,18 +1417,21 @@ 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)
+        sprintf (d, "(%s >> %d)", aop->aopu.aop_dir, offset * 8);
+      else if (offset)
+        sprintf (d, "(%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);
+      if (strcmp (d, s) || bvolatile)
+          emitcode ("mov", "%s,%s", d, s);
+      if (!strcmp (d, "acc"))
+          accuse = TRUE;
 
       break;
 
@@ -1275,7 +1478,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");
@@ -1299,7 +1502,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 == '@')
         {
@@ -1339,11 +1541,13 @@ aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
       break;
 
     case AOP_CRY:
-      /* if bit variable */
+      /* if not bit variable */
       if (!aop->aopu.aop_dir)
         {
+          /* inefficient: move carry into A and use jz/jnz */
           emitcode ("clr", "a");
           emitcode ("rlc", "a");
+          accuse = TRUE;
         }
       else
         {
@@ -1353,17 +1557,12 @@ aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
             emitcode ("setb", "%s", aop->aopu.aop_dir);
           else if (!strcmp (s, "c"))
             emitcode ("mov", "%s,c", aop->aopu.aop_dir);
-          else
+          else if (strcmp (s, aop->aopu.aop_dir))
             {
-              if (strcmp (s, "a"))
-                {
-                  MOVA (s);
-                }
-              {
-                /* set C, if a >= 1 */
-                emitcode ("add", "a,#0xff");
-                emitcode ("mov", "%s,c", aop->aopu.aop_dir);
-              }
+              MOVA (s);
+              /* set C, if a >= 1 */
+              emitcode ("add", "a,#0xff");
+              emitcode ("mov", "%s,c", aop->aopu.aop_dir);
             }
         }
       break;
@@ -1376,6 +1575,7 @@ aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
       break;
 
     case AOP_ACC:
+      accuse = TRUE;
       aop->coff = offset;
       if (!offset && (strcmp (s, "acc") == 0) &&
           !bvolatile)
@@ -1392,6 +1592,7 @@ aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
       exit (1);
     }
 
+    return accuse;
 }
 
 
@@ -1449,20 +1650,6 @@ 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.             */
@@ -1511,13 +1698,13 @@ outAcc (operand * result)
   size = getDataSize (result);
   if (size)
     {
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       size--;
       offset = 1;
       /* unsigned or positive */
       while (size--)
         {
-          aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+          aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
         }
     }
 }
@@ -1530,7 +1717,7 @@ outBitC (operand * result)
 {
   /* if the result is bit */
   if (AOP_TYPE (result) == AOP_CRY)
-    aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+    aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
   else
     {
       emitcode ("clr", "a");
@@ -1547,9 +1734,37 @@ toBoolean (operand * oper)
 {
   int size = AOP_SIZE (oper) - 1;
   int offset = 1;
-  MOVA (aopGet (AOP (oper), 0, FALSE, FALSE));
-  while (size--)
-    emitcode ("orl", "a,%s", aopGet (AOP (oper), offset++, FALSE, FALSE));
+  bool AccUsed = FALSE;
+  bool pushedB;
+
+  while (!AccUsed && size--)
+    {
+      AccUsed |= aopGetUsesAcc(oper, offset++);
+    }
+
+  size = AOP_SIZE (oper) - 1;
+  offset = 1;
+  MOVA (aopGet (oper, 0, FALSE, FALSE));
+  if (size && AccUsed && (AOP (oper)->type != AOP_ACC))
+    {
+      pushedB = pushB ();
+      emitcode("mov", "b,a");
+      while (--size)
+        {
+          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 (oper, offset++, FALSE, FALSE));
+        }
+    }
 }
 
 
@@ -1570,14 +1785,23 @@ 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
+        {
+          emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
+          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);
@@ -1599,8 +1823,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);
@@ -1609,27 +1834,31 @@ 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);
       outBitC (IC_RESULT(ic));
@@ -1639,10 +1868,10 @@ 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++, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
 
@@ -1669,19 +1898,19 @@ genUminusFloat (operand * op, operand * result)
 
   while (size--)
     {
-      aopPut (AOP (result),
-              aopGet (AOP (op), offset, FALSE, FALSE),
+      aopPut (result,
+              aopGet (op, offset, FALSE, FALSE),
               offset,
               isOperandVolatile (result, FALSE));
       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, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -1728,7 +1957,7 @@ genUminus (iCode * ic)
   //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)
@@ -1743,7 +1972,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++, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
   /* if any remaining bytes in the result */
@@ -1753,7 +1982,7 @@ 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++, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
 release:
@@ -1792,7 +2021,7 @@ saveRegisters (iCode * lic)
        IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT (ic)))))
     return;
 
-  /* safe the registers in use at this time but skip the
+  /* save the registers in use at this time but skip the
      ones for the result */
   rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
                          mcs51_rUmaskForOp (IC_RESULT(ic)));
@@ -1800,31 +2029,88 @@ saveRegisters (iCode * lic)
   ic->regsSaved = 1;
   if (options.useXstack)
     {
-      if (bitVectBitValue (rsave, R0_IDX))
-        emitcode ("mov", "b,r0");
-      emitcode ("mov", "r0,%s", spname);
+      int count = bitVectnBitsOn (rsave);
+
+      if (count == 1)
+        {
+          regs * reg = mcs51_regWithIdx (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");
+          if (bitVectBitValue (rsave, R0_IDX))
+            emitcode ("mov", "r0,a");
+        }
+      else if (count != 0)
+        {
+          bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+          int nBits = bitVectnBitsOn (rsavebits);
+
+          if (nBits != 0)
+            {
+              count = count - nBits + 1;
+              /* remove all but the first bits as they are pushed all at once */
+              rsave = bitVectCplAnd (rsave, rsavebits);
+              rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
+            }
+
+          if (bitVectBitValue (rsave, R0_IDX))
+            {
+              emitcode ("push", "%s", mcs51_regWithIdx (R0_IDX)->dname);
+            }
+          emitcode ("mov", "r0,%s", spname);
+          MOVA ("r0");
+          emitcode ("add", "a,#%d", count);
+          emitcode ("mov", "%s,a", spname);
+          for (i = 0; i < mcs51_nRegs; i++)
+            {
+              if (bitVectBitValue (rsave, i))
+                {
+                  regs * reg = mcs51_regWithIdx (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", reg->name);
+                    }
+                  emitcode ("movx", "@r0,a");
+                  if (--count)
+                    {
+                      emitcode ("inc", "r0");
+                    }
+                }
+            }
+          if (bitVectBitValue (rsave, R0_IDX))
+            {
+              emitcode ("pop", "%s", mcs51_regWithIdx (R0_IDX)->dname);
+            }
+        }
+    }
+  else
+    {
+      bool bits_pushed = FALSE;
       for (i = 0; i < mcs51_nRegs; i++)
         {
           if (bitVectBitValue (rsave, i))
             {
-              if (i == R0_IDX)
-                emitcode ("mov", "a,b");
-              else
-                emitcode ("mov", "a,%s", mcs51_regWithIdx (i)->name);
-              emitcode ("movx", "@r0,a");
-              emitcode ("inc", "r0");
+              bits_pushed = pushReg (i, bits_pushed);
             }
         }
-      emitcode ("mov", "%s,r0", spname);
-      if (bitVectBitValue (rsave, R0_IDX))
-        emitcode ("mov", "r0,b");
     }
-  else
-    for (i = 0; i < mcs51_nRegs; i++)
-      {
-        if (bitVectBitValue (rsave, i))
-          emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
-      }
 }
 
 /*-----------------------------------------------------------------*/
@@ -1843,36 +2129,82 @@ unsaveRegisters (iCode * ic)
 
   if (options.useXstack)
     {
-      emitcode ("mov", "r0,%s", spname);
-      for (i = mcs51_nRegs; i >= 0; i--)
+      int count = bitVectnBitsOn (rsave);
+
+      if (count == 1)
         {
-          if (bitVectBitValue (rsave, i))
+          regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));
+          emitcode ("mov", "r0,%s", spname);
+          emitcode ("dec", "r0");
+          emitcode ("movx", "a,@r0");
+          if (reg->type == REG_BIT)
             {
-              emitcode ("dec", "r0");
-              emitcode ("movx", "a,@r0");
-              if (i == R0_IDX)
-                emitcode ("mov", "b,a");
-              else
-                emitcode ("mov", "%s,a", mcs51_regWithIdx (i)->name);
+              emitcode ("mov", "%s,a", reg->base);
             }
-
+          else
+            {
+              emitcode ("mov", "%s,a", reg->name);
+            }
+          emitcode ("dec", "%s", spname);
         }
-      emitcode ("mov", "%s,r0", spname);
-      if (bitVectBitValue (rsave, R0_IDX))
-        emitcode ("mov", "r0,b");
-    }
-  else
-    for (i = mcs51_nRegs; i >= 0; i--)
-      {
-        if (bitVectBitValue (rsave, i))
-          emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
-      }
+      else if (count != 0)
+        {
+          bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+          int nBits = bitVectnBitsOn (rsavebits);
+
+          if (nBits != 0)
+            {
+              count = count - nBits + 1;
+              /* remove all but the first bits as they are popped all at once */
+              rsave = bitVectCplAnd (rsave, rsavebits);
+              rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
+            }
 
+          emitcode ("mov", "r0,%s", spname);
+          for (i = mcs51_nRegs; i >= 0; i--)
+            {
+              if (bitVectBitValue (rsave, i))
+                {
+                  regs * reg = mcs51_regWithIdx (i);
+                  emitcode ("dec", "r0");
+                  emitcode ("movx", "a,@r0");
+                  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 ("pop", "ar0");
+            }
+        }
+    }
+  else
+    {
+      bool bits_popped = FALSE;
+      for (i = mcs51_nRegs; i >= 0; i--)
+        {
+          if (bitVectBitValue (rsave, i))
+            {
+              bits_popped = popReg (i, bits_popped);
+            }
+        }
+    }
 }
 
 
 /*-----------------------------------------------------------------*/
-/* pushSide -                */
+/* pushSide -                                                      */
 /*-----------------------------------------------------------------*/
 static void
 pushSide (operand * oper, int size)
@@ -1880,7 +2212,7 @@ pushSide (operand * oper, int size)
   int offset = 0;
   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"))
@@ -1889,23 +2221,42 @@ pushSide (operand * oper, int size)
           emitcode ("push", "acc");
         }
       else
-        emitcode ("push", "%s", l);
+        {
+          emitcode ("push", "%s", l);
+        }
     }
 }
 
 /*-----------------------------------------------------------------*/
-/* 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, isOperandVolatile (oper, FALSE));
       offset++;
     }
+  return accuse;
 }
 
 
@@ -1924,36 +2275,44 @@ genXpush (iCode * ic)
   aopOp (IC_LEFT (ic), ic, FALSE);
   r = getFreePtr (ic, &aop, FALSE);
 
-
-  emitcode ("mov", "%s,_spx", r->name);
-
   size = AOP_SIZE (IC_LEFT (ic));
-  while (size--)
-    {
 
-      char *l = aopGet (AOP (IC_LEFT (ic)),
-                        offset++, FALSE, FALSE);
-      MOVA (l);
+  if (size == 1)
+    {
+      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);
-      emitcode ("inc", "%s", r->name);
-
     }
+  else
+    {
+      // allocate space first
+      emitcode ("mov", "%s,%s", r->name, spname);
+      MOVA (r->name);
+      emitcode ("add", "a,#%d", size);
+      emitcode ("mov", "%s,a", spname);
 
-
-  emitcode ("mov", "_spx,%s", r->name);
+      while (size--)
+        {
+          MOVA (aopGet (IC_LEFT (ic), offset++, FALSE, FALSE));
+          emitcode ("movx", "@%s,a", r->name);
+          emitcode ("inc", "%s", r->name);
+        }
+    }
 
   freeAsmop (NULL, aop, ic, TRUE);
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
-/* 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",""));
 
@@ -1971,7 +2330,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);
@@ -1982,7 +2341,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);
@@ -1998,22 +2357,25 @@ genIpush (iCode * ic)
   /* then do the push */
   aopOp (IC_LEFT (ic), ic, FALSE);
 
-
   // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
   size = AOP_SIZE (IC_LEFT (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"))
         {
-          MOVA (l);
+          if (strcmp (l, prev) || *l == '@')
+            MOVA (l);
           emitcode ("push", "acc");
         }
       else
-        emitcode ("push", "%s", l);
+        {
+          emitcode ("push", "%s", l);
+        }
+      prev = l;
     }
 
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
@@ -2037,24 +2399,25 @@ genIpop (iCode * ic)
   size = AOP_SIZE (IC_LEFT (ic));
   offset = (size - 1);
   while (size--)
-    emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--,
+    emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--,
                                    FALSE, TRUE));
 
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
-/* unsaveRBank - restores the resgister bank from stack            */
+/* saveRBank - saves an entire register bank on the stack          */
 /*-----------------------------------------------------------------*/
 static void
-unsaveRBank (int bank, iCode * ic, bool popPsw)
+saveRBank (int bank, iCode * ic, bool pushPsw)
 {
   int i;
+  int count = 8 + ((mcs51_nRegs > 8) ? 1 : 0) + (pushPsw ? 1 : 0);
   asmop *aop = NULL;
   regs *r = NULL;
 
   if (options.useXstack)
-  {
+    {
       if (!ic)
       {
           /* Assume r0 is available for use. */
@@ -2065,54 +2428,76 @@ unsaveRBank (int bank, iCode * ic, bool popPsw)
           aop = newAsmop (0);
           r = getFreePtr (ic, &aop, FALSE);
       }
-      emitcode ("mov", "%s,_spx", r->name);
-  }
+      // allocate space first
+      emitcode ("mov", "%s,%s", r->name, spname);
+      MOVA (r->name);
+      emitcode ("add", "a,#%d", count);
+      emitcode ("mov", "%s,a", spname);
+    }
 
-  if (popPsw)
+  for (i = 0; i < 8; i++)
     {
       if (options.useXstack)
-      {
-          emitcode ("movx", "a,@%s", r->name);
-          emitcode ("mov", "psw,a");
-          emitcode ("dec", "%s", r->name);
+        {
+          emitcode ("mov", "a,(%s+%d)",
+                    regs8051[i].base, 8 * bank + regs8051[i].offset);
+          emitcode ("movx", "@%s,a", r->name);
+          if (--count)
+            emitcode ("inc", "%s", r->name);
         }
       else
-      {
-        emitcode ("pop", "psw");
-      }
+        emitcode ("push", "(%s+%d)",
+                  regs8051[i].base, 8 * bank + regs8051[i].offset);
     }
 
-  for (i = (mcs51_nRegs - 1); i >= 0; i--)
+  if (mcs51_nRegs > 8)
     {
       if (options.useXstack)
         {
-          emitcode ("movx", "a,@%s", r->name);
-          emitcode ("mov", "(%s+%d),a",
-                    regs8051[i].base, 8 * bank + regs8051[i].offset);
-          emitcode ("dec", "%s", r->name);
-
+          emitcode ("mov", "a,bits");
+          emitcode ("movx", "@%s,a", r->name);
+          if (--count)
+            emitcode ("inc", "%s", r->name);
         }
       else
-        emitcode ("pop", "(%s+%d)",
-                  regs8051[i].base, 8 * bank + regs8051[i].offset);
+        {
+          emitcode ("push", "bits");
+        }
+      BitBankUsed = 1;
     }
 
-  if (options.useXstack)
+  if (pushPsw)
     {
-      emitcode ("mov", "_spx,%s", r->name);
+      if (options.useXstack)
+        {
+          emitcode ("mov", "a,psw");
+          emitcode ("movx", "@%s,a", r->name);
+
+        }
+      else
+        {
+          emitcode ("push", "psw");
+        }
+
+      emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
     }
 
   if (aop)
-  {
+    {
       freeAsmop (NULL, aop, ic, TRUE);
+    }
+
+  if (ic)
+  {
+    ic->bankSaved = 1;
   }
 }
 
 /*-----------------------------------------------------------------*/
-/* saveRBank - saves an entire register bank on the stack          */
+/* unsaveRBank - restores the register bank from stack             */
 /*-----------------------------------------------------------------*/
 static void
-saveRBank (int bank, iCode * ic, bool pushPsw)
+unsaveRBank (int bank, iCode * ic, bool popPsw)
 {
   int i;
   asmop *aop = NULL;
@@ -2121,59 +2506,71 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
   if (options.useXstack)
     {
       if (!ic)
-      {
+        {
           /* Assume r0 is available for use. */
           r = mcs51_regWithIdx (R0_IDX);;
-      }
+        }
       else
-      {
+        {
           aop = newAsmop (0);
           r = getFreePtr (ic, &aop, FALSE);
-      }
-      emitcode ("mov", "%s,_spx", r->name);
+        }
+      emitcode ("mov", "%s,%s", r->name, spname);
     }
 
-  for (i = 0; i < mcs51_nRegs; i++)
+  if (popPsw)
     {
       if (options.useXstack)
         {
-          emitcode ("inc", "%s", r->name);
-          emitcode ("mov", "a,(%s+%d)",
-                    regs8051[i].base, 8 * bank + regs8051[i].offset);
-          emitcode ("movx", "@%s,a", r->name);
+          emitcode ("dec", "%s", r->name);
+          emitcode ("movx", "a,@%s", r->name);
+          emitcode ("mov", "psw,a");
         }
       else
-        emitcode ("push", "(%s+%d)",
-                  regs8051[i].base, 8 * bank + regs8051[i].offset);
+        {
+          emitcode ("pop", "psw");
+        }
     }
 
-  if (pushPsw)
+  if (mcs51_nRegs > 8)
     {
       if (options.useXstack)
         {
-          emitcode ("mov", "a,psw");
-          emitcode ("movx", "@%s,a", r->name);
-          emitcode ("inc", "%s", r->name);
-          emitcode ("mov", "_spx,%s", r->name);
-
+          emitcode ("dec", "%s", r->name);
+          emitcode ("movx", "a,@%s", r->name);
+          emitcode ("mov", "bits,a");
         }
       else
-      {
-        emitcode ("push", "psw");
-      }
+        {
+          emitcode ("pop", "bits");
+        }
+    }
 
-      emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
+  for (i = 7; i >= 0; i--)
+    {
+      if (options.useXstack)
+        {
+          emitcode ("dec", "%s", r->name);
+          emitcode ("movx", "a,@%s", r->name);
+          emitcode ("mov", "(%s+%d),a",
+                    regs8051[i].base, 8 * bank + regs8051[i].offset);
+        }
+      else
+        {
+          emitcode ("pop", "(%s+%d)",
+                  regs8051[i].base, 8 * bank + regs8051[i].offset);
+        }
     }
 
-    if (aop)
+  if (options.useXstack)
     {
-        freeAsmop (NULL, aop, ic, TRUE);
+      emitcode ("mov", "%s,%s", spname, r->name);
     }
 
-  if (ic)
-  {
-      ic->bankSaved = 1;
-  }
+  if (aop)
+    {
+      freeAsmop (NULL, aop, ic, TRUE);
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -2181,31 +2578,102 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
 /*-----------------------------------------------------------------*/
 static void genSend(set *sendSet)
 {
-    iCode *sic;
-    int rb1_count = 0 ;
-
-    for (sic = setFirstItem (sendSet); sic;
-         sic = setNextItem (sendSet)) {
-          int size, offset = 0;
-          aopOp (IC_LEFT (sic), sic, FALSE);
-          size = AOP_SIZE (IC_LEFT (sic));
-
-          if (sic->argreg == 1) {
-              while (size--) {
-                  char *l = aopGet (AOP (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));
-              }
-          }
-          freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+  iCode *sic;
+  int bit_count = 0;
+
+  /* first we do all bit parameters */
+  for (sic = setFirstItem (sendSet); sic;
+       sic = setNextItem (sendSet))
+    {
+      aopOp (IC_LEFT (sic), sic, FALSE);
+
+      if (sic->argreg > 12)
+        {
+          int bit = sic->argreg-13;
+
+          /* 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 if (AOP_TYPE (IC_LEFT (sic)) == AOP_CRY)
+            {
+              char *l = AOP (IC_LEFT (sic))->aopu.aop_dir;
+                if (strcmp (l, "c"))
+                    emitcode ("mov", "c,%s", l);
+                emitcode ("mov", "b[%d],c", bit);
+            }
+          else
+            {
+              /* we need to or */
+              toBoolean (IC_LEFT (sic));
+              /* set C, if a >= 1 */
+              emitcode ("add", "a,#0xff");
+              emitcode ("mov", "b[%d],c", bit);
+            }
+          bit_count++;
+          BitBankUsed = 1;
+        }
+      freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+    }
+
+  if (bit_count)
+    {
+      saveRegisters (setFirstItem (sendSet));
+      emitcode ("mov", "bits,b");
+    }
+
+  /* then we do all other parameters */
+  for (sic = setFirstItem (sendSet); sic;
+       sic = setNextItem (sendSet))
+    {
+      int size, offset = 0;
+      aopOp (IC_LEFT (sic), sic, FALSE);
+      size = AOP_SIZE (IC_LEFT (sic));
+
+      if (sic->argreg == 1)
+        {
+          while (size--)
+            {
+              char *l = aopGet (IC_LEFT (sic), offset, FALSE, FALSE);
+              if (strcmp (l, fReturn[offset]))
+                  emitcode ("mov", "%s,%s", fReturn[offset], l);
+              offset++;
+            }
+        }
+      else if (sic->argreg <= 12)
+        {
+          while (size--)
+            {
+              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);
     }
 }
 
@@ -2216,13 +2684,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;
 
   D(emitcode(";     genCall",""));
 
   dtype = operandType (IC_LEFT (ic));
-  /* if send set is not empty the assign */
+  etype = getSpec(dtype);
+  /* if send set is not empty then assign */
   if (_G.sendSet)
     {
         if (IFFUNC_ISREENT(dtype)) { /* need to reverse the send set */
@@ -2237,37 +2710,57 @@ genCall (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));
   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);
-  }
+    }
 
   /* 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)) ||
@@ -2278,34 +2771,74 @@ genCall (iCode * ic)
       aopOp (IC_RESULT (ic), ic, FALSE);
       _G.accInUse--;
 
-      assignResultValue (IC_RESULT (ic));
+      accuse = 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 (accuse)
+            {
+              emitcode ("push", "acc");
+              accPushed = TRUE;
+            }
+          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);
+
+          /* 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))))
+    {
+      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");
 }
 
 /*-----------------------------------------------------------------*/
@@ -2315,69 +2848,155 @@ 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",""));
 
-  /* if caller saves & we have not saved then */
-  if (!ic->regsSaved)
-    saveRegisters (ic);
+  dtype = operandType (IC_LEFT (ic))->next;
+  etype = getSpec(dtype);
+  /* if caller saves & we have not saved then */
+  if (!ic->regsSaved)
+    saveRegisters (ic);
+
+  /* if we are calling a not _naked function that is not using
+     the same register bank then we need to save the
+     destination registers on the stack */
+  if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
+      (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
+    }
+
+  if (IS_LITERAL(etype))
+    {
+      /* 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);
+        }
+
+      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);
+
+              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", "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));
+                }
 
-  /* 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) &&
-      (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
-  }
+              freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
 
-  /* 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");
+              /* if send set is not empty then assign */
+              if (_G.sendSet)
+                {
+                  genSend(reverseSet(_G.sendSet));
+                  _G.sendSet = NULL;
+                }
 
-  /* now push the calling address */
-  aopOp (IC_LEFT (ic), ic, FALSE);
+              if (swapBanks)
+                {
+                  emitcode ("mov", "psw,#0x%02x",
+                   ((FUNC_REGBANK(dtype)) << 3) & 0xff);
+                }
 
-  pushSide (IC_LEFT (ic), FPTRSIZE);
+              /* make the call */
+              emitcode ("lcall", "__sdcc_banked_call");
+            }
+        }
+      else
+        {
+          /* 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");
 
-  freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+          /* now push the calling address */
+          aopOp (IC_LEFT (ic), ic, FALSE);
 
-  /* if send set is not empty the 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);
 
-  /* make the call */
-  emitcode ("ret", "");
-  emitcode ("", "%05d$:", (rlbl->key + 100));
+          /* if send set is not empty the 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", "");
+          emitcode ("", "%05d$:", (rlbl->key + 100));
+        }
+    }
   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)))
@@ -2387,18 +3006,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);
@@ -2413,10 +3038,19 @@ genPcall (iCode * ic)
 //  if (restoreBank)
 //    unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
 
-  /* 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 (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);
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -2471,13 +3105,14 @@ inExcludeList (char *s)
 static void
 genFunction (iCode * ic)
 {
-  symbol *sym = OP_SYMBOL (IC_LEFT (ic));
+  symbol   *sym = OP_SYMBOL (IC_LEFT (ic));
   sym_link *ftype;
-  bool   switchedPSW = FALSE;
-  int calleesaves_saved_register = -1;
-  int stackAdjust = sym->stack;
-  int accIsFree = sym->recvSize < 4;
-  iCode * ric = (ic->next && ic->next->op == RECEIVE) ? ic->next : NULL;
+  bool     switchedPSW = FALSE;
+  int      calleesaves_saved_register = -1;
+  int      stackAdjust = sym->stack;
+  int      accIsFree = sym->recvSize < 4;
+  iCode    *ric = (ic->next && ic->next->op == RECEIVE) ? ic->next : NULL;
+  bool     fReentrant = (IFFUNC_ISREENT (sym->type) || options.stackAuto);
 
   _G.nRegsSaved = 0;
   /* create the function header */
@@ -2504,15 +3139,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);
+            }
         }
     }
 
@@ -2545,11 +3183,12 @@ 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++)
                     {
                       if (bitVectBitValue (sym->regsUsed, i))
-                        emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
+                        bits_pushed = pushReg (i, bits_pushed);
                     }
                 }
             }
@@ -2681,6 +3320,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++)
                 {
@@ -2689,7 +3329,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++;
                     }
                 }
@@ -2698,26 +3338,35 @@ genFunction (iCode * ic)
     }
 
 
-  if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
+  if (fReentrant)
     {
-
       if (options.useXstack)
         {
-          if (!accIsFree)
-            emitcode ("push", "acc");
-          emitcode ("mov", "r0,%s", spname);
-          emitcode ("mov", "a,_bp");
-          emitcode ("movx", "@r0,a");
-          emitcode ("inc", "%s", spname);
-          if (!accIsFree)
-            emitcode ("pop", "acc");
+          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  */
+          if (sym->stack || FUNC_HASSTACKPARM(sym->type))
+            {
+              /* set up the stack */
+              emitcode ("push", "_bp");     /* save the callers stack  */
+              emitcode ("mov", "_bp,sp");
+            }
         }
-      emitcode ("mov", "_bp,%s", spname);
     }
 
   /* For some cases it is worthwhile to perform a RECEIVE iCode */
@@ -2783,18 +3432,15 @@ genFunction (iCode * ic)
   /* adjust the stack for the function */
   if (stackAdjust)
     {
-
       int i = stackAdjust;
       if (i > 256)
         werror (W_STACK_OVERFLOW, sym->name);
 
       if (i > 3 && accIsFree)
         {
-
           emitcode ("mov", "a,sp");
           emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
           emitcode ("mov", "sp,a");
-
         }
       else if (i > 5)
         {
@@ -2836,14 +3482,27 @@ genFunction (iCode * ic)
 
   if (sym->xstack)
     {
+      char i = ((char) sym->xstack & 0xff);
 
-      if (!accIsFree)
-        emitcode ("push", "acc");
-      emitcode ("mov", "a,_spx");
-      emitcode ("add", "a,#0x%02x", ((char) sym->xstack & 0xff));
-      emitcode ("mov", "_spx,a");
-      if (!accIsFree)
-        emitcode ("pop", "acc");
+      if (i > 3 && accIsFree)
+        {
+          emitcode ("mov", "a,_spx");
+          emitcode ("add", "a,#0x%02x", i);
+          emitcode ("mov", "_spx,a");
+        }
+      else if (i > 5)
+        {
+          emitcode ("push", "acc");
+          emitcode ("mov", "a,_spx");
+          emitcode ("add", "a,#0x%02x", i);
+          emitcode ("mov", "_spx,a");
+          emitcode ("pop", "acc");
+        }
+      else
+        {
+          while (i--)
+            emitcode ("inc", "_spx");
+        }
     }
 
   /* if critical function then turn interrupts off */
@@ -2864,12 +3523,12 @@ genFunction (iCode * ic)
 static void
 genEndFunction (iCode * ic)
 {
-  symbol *sym = OP_SYMBOL (IC_LEFT (ic));
+  symbol   *sym = OP_SYMBOL (IC_LEFT (ic));
   lineNode *lnp = lineCurr;
-  bitVect *regsUsed;
-  bitVect *regsUsedPrologue;
-  bitVect *regsUnneeded;
-  int idx;
+  bitVect  *regsUsed;
+  bitVect  *regsUsedPrologue;
+  bitVect  *regsUnneeded;
+  int      idx;
 
   _G.currentFunc = NULL;
   if (IFFUNC_ISNAKED(sym->type))
@@ -2882,37 +3541,42 @@ 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)
-    {
-      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)
-    {
-      emitcode ("mov", "a,sp");
-      emitcode ("add", "a,#0x%02x", ((char) -sym->stack) & 0xff);
-      emitcode ("mov", "sp,a");
+      if (IS_BIT (OP_SYM_ETYPE (IC_LEFT (ic))))
+        {
+          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
+        {
+          emitcode ("pop", "psw"); /* restore ea via c in psw */
+          emitcode ("mov", "ea,c");
+        }
     }
 
-
   if ((IFFUNC_ISREENT (sym->type) || options.stackAuto))
     {
       if (options.useXstack)
         {
-          emitcode ("mov", "r0,%s", spname);
-          emitcode ("movx", "a,@r0");
-          emitcode ("mov", "_bp,a");
-          emitcode ("dec", "%s", spname);
+          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))
         {
+          emitcode ("mov", "sp,_bp");
           emitcode ("pop", "_bp");
         }
     }
@@ -2949,11 +3613,12 @@ genEndFunction (iCode * ic)
               /* if any registers used */
               if (sym->regsUsed)
                 {
+                  bool bits_popped = FALSE;
                   /* save the registers used */
                   for (i = sym->regsUsed->size; i >= 0; i--)
                     {
                       if (bitVectBitValue (sym->regsUsed, i))
-                        emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
+                        bits_popped = popReg (i, bits_popped);
                     }
                 }
             }
@@ -3046,7 +3711,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)
@@ -3164,36 +3836,40 @@ genRet (iCode * ic)
   aopOp (IC_LEFT (ic), ic, FALSE);
   size = AOP_SIZE (IC_LEFT (ic));
 
+
+  if (IS_BIT(_G.currentFunc->etype))
+    {
+      movc (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
+      size = 0;
+    }
+
   while (size--)
     {
       char *l;
       if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
         {
           /* #NOCHANGE */
-          l = aopGet (AOP (IC_LEFT (ic)), offset++,
+          l = aopGet (IC_LEFT (ic), offset++,
                       FALSE, TRUE);
           emitcode ("push", "%s", l);
           pushed++;
         }
       else
         {
-          l = aopGet (AOP (IC_LEFT (ic)), offset,
+          l = aopGet (IC_LEFT (ic), offset,
                       FALSE, FALSE);
           if (strcmp (fReturn[offset], l))
             emitcode ("mov", "%s,%s", fReturn[offset++], l);
         }
     }
 
-  if (pushed)
+  while (pushed)
     {
-      while (pushed)
-        {
-          pushed--;
-          if (strcmp (fReturn[pushed], "a"))
-            emitcode ("pop", fReturn[pushed]);
-          else
-            emitcode ("pop", "acc");
-        }
+      pushed--;
+      if (strcmp (fReturn[pushed], "a"))
+        emitcode ("pop", fReturn[pushed]);
+      else
+        emitcode ("pop", "acc");
     }
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
 
@@ -3276,16 +3952,14 @@ 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) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
 
   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 ) &&
       sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
+      !isOperandVolatile (IC_RESULT (ic), FALSE) &&
       (size > 1) &&
       (icount == 1))
     {
@@ -3310,49 +3984,49 @@ genPlusIncr (iCode * ic)
           tlbl = newiTempLabel (NULL);
           emitTlbl = 1;
         }
-      emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
+      emitcode ("inc", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE));
       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),
+                  aopGet (IC_RESULT (ic), LSB, FALSE, FALSE),
                   tlbl->key + 100);
       else
         {
           emitcode ("clr", "a");
           emitcode ("cjne", "a,%s,%05d$",
-                    aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE),
+                    aopGet (IC_RESULT (ic), LSB, FALSE, FALSE),
                     tlbl->key + 100);
         }
 
-      emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE));
+      emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE));
       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),
+                      aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE),
                       tlbl->key + 100);
           else
             emitcode ("cjne", "a,%s,%05d$",
-                      aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
+                      aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE),
                       tlbl->key + 100);
 
-          emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE));
+          emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE));
         }
       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),
+                      aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE),
                       tlbl->key + 100);
           else
             {
               emitcode ("cjne", "a,%s,%05d$",
-                        aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
+                        aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE),
                         tlbl->key + 100);
             }
-          emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
+          emitcode ("inc", "%s", aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE));
         }
 
       if (emitTlbl)
@@ -3362,6 +4036,34 @@ genPlusIncr (iCode * ic)
       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, FALSE);
+      aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1, FALSE);
+      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)
@@ -3375,15 +4077,15 @@ genPlusIncr (iCode * 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, isOperandVolatile (IC_RESULT (ic), FALSE));
         }
       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;
@@ -3402,7 +4104,7 @@ 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, isOperandVolatile (result, FALSE));
     }
   else
     {
@@ -3453,16 +4155,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),
+    aopPut (IC_RESULT (ic),
+            aopGet (IC_LEFT (ic)), 2, FALSE, FALSE),
             2,
             isOperandVolatile (IC_RESULT (ic), FALSE));
 
   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),
+    aopPut (IC_RESULT (ic),
+            aopGet (IC_RIGHT (ic)), 2, FALSE, FALSE),
             2,
             isOperandVolatile (IC_RESULT (ic), FALSE));
 
@@ -3473,8 +4175,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, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 }
 #else
@@ -3489,8 +4191,8 @@ adjustArithmeticResult (iCode * ic)
       opIsGptr (IC_LEFT (ic)) &&
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
     {
-      aopPut (AOP (IC_RESULT (ic)),
-              aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE),
+      aopPut (IC_RESULT (ic),
+              aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE),
               GPTRSIZE - 1,
               isOperandVolatile (IC_RESULT (ic), FALSE));
     }
@@ -3499,8 +4201,8 @@ adjustArithmeticResult (iCode * 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),
+      aopPut (IC_RESULT (ic),
+              aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE),
               GPTRSIZE - 1,
               isOperandVolatile (IC_RESULT (ic), FALSE));
     }
@@ -3512,8 +4214,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, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+      sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
+      aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 }
 #endif
@@ -3527,7 +4229,7 @@ genPlus (iCode * ic)
   int size, offset = 0;
   int skip_bytes = 0;
   char *add = "add";
-  asmop *leftOp, *rightOp;
+  operand *leftOp, *rightOp;
   operand * op;
 
   /* special cases :- */
@@ -3576,9 +4278,9 @@ genPlus (iCode * ic)
           size = getDataSize (IC_RESULT (ic));
           while (size--)
             {
-              MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
+              MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE));
               emitcode ("addc", "a,#00");
-              aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+              aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
             }
         }
       goto release;
@@ -3590,8 +4292,8 @@ genPlus (iCode * ic)
     goto release;
 
   size = getDataSize (IC_RESULT (ic));
-  leftOp = AOP(IC_LEFT(ic));
-  rightOp = AOP(IC_RIGHT(ic));
+  leftOp = IC_LEFT(ic);
+  rightOp = IC_RIGHT(ic);
   op=IC_LEFT(ic);
 
   /* if this is an add for an array access
@@ -3605,23 +4307,23 @@ genPlus (iCode * ic)
      )
     {
       D(emitcode (";     genPlus aligned array",""));
-      aopPut (AOP (IC_RESULT (ic)),
+      aopPut (IC_RESULT (ic),
               aopGet (rightOp, 0, FALSE, FALSE),
               0,
               isOperandVolatile (IC_RESULT (ic), FALSE));
 
       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));
         }
       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, isOperandVolatile (IC_RESULT (ic), FALSE));
         }
       goto release;
     }
@@ -3644,11 +4346,13 @@ genPlus (iCode * ic)
         {
           if (aopGetUsesAcc (leftOp, offset) && aopGetUsesAcc (rightOp, offset))
             {
-              emitcode("mov", "b,a");
+              bool pushedB;
               MOVA (aopGet (leftOp,  offset, FALSE, TRUE));
+              pushedB = pushB ();
               emitcode("xch", "a,b");
               MOVA (aopGet (rightOp, offset, FALSE, TRUE));
               emitcode (add, "a,b");
+              popB (pushedB);
             }
           else if (aopGetUsesAcc (leftOp, offset))
             {
@@ -3660,7 +4364,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, isOperandVolatile (IC_RESULT (ic), FALSE));
           add = "addc";  /* further adds must propagate carry */
         }
       else
@@ -3669,7 +4373,7 @@ 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));
@@ -3687,7 +4391,7 @@ release:
 }
 
 /*-----------------------------------------------------------------*/
-/* genMinusDec :- does subtraction with deccrement if possible     */
+/* genMinusDec :- does subtraction with decrement if possible      */
 /*-----------------------------------------------------------------*/
 static bool
 genMinusDec (iCode * ic)
@@ -3736,49 +4440,49 @@ genMinusDec (iCode * ic)
           emitTlbl = 1;
         }
 
-      emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE));
+      emitcode ("dec", "%s", aopGet (IC_RESULT (ic), LSB, FALSE, FALSE));
       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)
+                  ,aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)
                   ,tlbl->key + 100);
       else
         {
           emitcode ("mov", "a,#0xff");
           emitcode ("cjne", "a,%s,%05d$"
-                    ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE)
+                    ,aopGet (IC_RESULT (ic), LSB, FALSE, FALSE)
                     ,tlbl->key + 100);
         }
-      emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE));
+      emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE));
       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)
+                      ,aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE)
                       ,tlbl->key + 100);
           else
             {
               emitcode ("cjne", "a,%s,%05d$"
-                        ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE)
+                        ,aopGet (IC_RESULT (ic), MSB16, FALSE, FALSE)
                         ,tlbl->key + 100);
             }
-          emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE));
+          emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE));
         }
       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)
+                      ,aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE)
                       ,tlbl->key + 100);
           else
             {
               emitcode ("cjne", "a,%s,%05d$"
-                        ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE)
+                        ,aopGet (IC_RESULT (ic), MSB24, FALSE, FALSE)
                         ,tlbl->key + 100);
             }
-          emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
+          emitcode ("dec", "%s", aopGet (IC_RESULT (ic), MSB32, FALSE, FALSE));
         }
       if (emitTlbl)
         {
@@ -3797,9 +4501,23 @@ 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, isOperandVolatile (IC_RESULT (ic), FALSE));
 
       return TRUE;
     }
@@ -3821,11 +4539,11 @@ 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++, isOperandVolatile (result, FALSE));
         }
       else
         while (size--)
-          aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+          aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
     }
 }
 
@@ -3854,7 +4572,7 @@ genMinusBits (iCode * ic)
       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));
+      aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
       addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
     }
 }
@@ -3893,45 +4611,80 @@ 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 = -(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++, isOperandVolatile (IC_RESULT (ic), FALSE));
+            }
+          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, isOperandVolatile (IC_RESULT (ic), FALSE));
+                }
+              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--)
         {
           if (aopGetUsesAcc(rightOp, offset)) {
-            wassertl(!aopGetUsesAcc(leftOp, offset), "accumulator clash");
-            MOVA (aopGet(rightOp, offset, FALSE, TRUE));
-            if (offset == 0) {
-              emitcode( "setb", "c");
+            if (aopGetUsesAcc(leftOp, offset)) {
+              bool pushedB;
+
+              MOVA (aopGet (rightOp, offset, FALSE, FALSE));
+              pushedB = pushB ();
+              emitcode ("mov", "b,a");
+              if (offset == 0)
+                CLRC;
+              MOVA (aopGet (leftOp, offset, FALSE, FALSE));
+              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));
+              emitcode("subb", "a,%s", aopGet(leftOp, offset, FALSE, TRUE));
+              emitcode("cpl", "a");
+              if (size) /* skip if last byte */
+                emitcode( "cpl", "c");
             }
-            emitcode("subb", "a,%s", aopGet(leftOp, offset, FALSE, TRUE));
-            emitcode("cpl", "a");
           } else {
             MOVA (aopGet (leftOp, offset, FALSE, FALSE));
             if (offset == 0)
@@ -3940,7 +4693,7 @@ 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++, isOperandVolatile (IC_RESULT (ic), FALSE));
         }
     }
 
@@ -3980,7 +4733,7 @@ genMultOneByte (operand * left,
   symbol *lbl;
   int size = AOP_SIZE (result);
   bool runtimeSign, compiletimeSign;
-  bool lUnsigned, rUnsigned;
+  bool lUnsigned, rUnsigned, pushedB;
 
   D(emitcode (";     genMultOneByte",""));
 
@@ -4013,6 +4766,8 @@ genMultOneByte (operand * left,
   lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
   rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
 
+  pushedB = pushB ();
+
   if (size == 1 /* no, this is not a bug; with a 1 byte result there's
                    no need to take care about the signedness! */
       || (lUnsigned && rUnsigned))
@@ -4025,19 +4780,21 @@ 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));
+          emitcode ("mov", "b,%s", 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, isOperandVolatile (result, FALSE));
       if (size == 2)
-        aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+        aopPut (result, "b", 1, isOperandVolatile (result, FALSE));
+
+      popB (pushedB);
       return;
     }
 
@@ -4103,10 +4860,10 @@ genMultOneByte (operand * left,
     {
       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 */
@@ -4128,7 +4885,7 @@ genMultOneByte (operand * left,
     }
   else /* ! literal */
     {
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
 
       if (!lUnsigned)
         {
@@ -4161,9 +4918,11 @@ genMultOneByte (operand * left,
         }
       emitcode ("", "%05d$:", (lbl->key + 100));
     }
-  aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
   if (size == 2)
-    aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+    aopPut (result, "b", 1, isOperandVolatile (result, FALSE));
+
+  popB (pushedB);
 }
 
 /*-----------------------------------------------------------------*/
@@ -4178,7 +4937,7 @@ genMult (iCode * ic)
 
   D(emitcode (";     genMult",""));
 
-  /* assign the amsops */
+  /* assign the asmops */
   aopOp (left, ic, FALSE);
   aopOp (right, ic, FALSE);
   aopOp (result, ic, TRUE);
@@ -4223,20 +4982,25 @@ genDivbits (operand * left,
             operand * right,
             operand * result)
 {
-
   char *l;
+  bool pushedB;
 
   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);
 
   emitcode ("div", "ab");
   emitcode ("rrc", "a");
-  aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+
+  popB (pushedB);
+
+  aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -4247,8 +5011,10 @@ genDivOneByte (operand * left,
                operand * right,
                operand * result)
 {
-  bool lUnsigned, rUnsigned;
+  bool lUnsigned, rUnsigned, pushedB;
   bool runtimeSign, compiletimeSign;
+  bool accuse = FALSE;
+  bool pushedA = FALSE;
   symbol *lbl;
   int size, offset;
 
@@ -4285,16 +5051,20 @@ genDivOneByte (operand * left,
   lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
   rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
 
+  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));
+      emitcode ("mov", "b,%s", 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, isOperandVolatile (result, FALSE));
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+
+      popB (pushedB);
       return;
     }
 
@@ -4358,10 +5128,10 @@ 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 */
@@ -4383,7 +5153,7 @@ genDivOneByte (operand * left,
     }
   else /* ! literal */
     {
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
 
       if (!lUnsigned)
         {
@@ -4408,28 +5178,44 @@ genDivOneByte (operand * left,
       emitcode ("inc", "a");
       emitcode ("", "%05d$:", (lbl->key + 100));
 
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      accuse = aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       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++, isOperandVolatile (result, FALSE));
             }
           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++, isOperandVolatile (result, FALSE));
+            }
         }
     }
   else
     {
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
     }
+
+  if (pushedA)
+    emitcode ("pop", "acc");
+  popB (pushedB);
 }
 
 /*-----------------------------------------------------------------*/
@@ -4482,21 +5268,26 @@ genModbits (operand * left,
             operand * right,
             operand * result)
 {
-
   char *l;
+  bool pushedB;
 
   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);
 
   emitcode ("div", "ab");
   emitcode ("mov", "a,b");
   emitcode ("rrc", "a");
-  aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+
+  popB (pushedB);
+
+  aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -4507,7 +5298,7 @@ genModOneByte (operand * left,
                operand * right,
                operand * result)
 {
-  bool lUnsigned, rUnsigned;
+  bool lUnsigned, rUnsigned, pushedB;
   bool runtimeSign, compiletimeSign;
   symbol *lbl;
   int size, offset;
@@ -4519,16 +5310,75 @@ genModOneByte (operand * left,
   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, isOperandVolatile (result, FALSE));
+                while (size2--)
+                  aopPut (result, "#0xff", offs2++, isOperandVolatile (result, FALSE));
+                lbl2 = newiTempLabel (NULL);
+                emitcode ("sjmp", "%05d$", (lbl2->key + 100));
+              }
+            emitcode ("", "%05d$:", (lbl->key + 100));
+            aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+            while (size--)
+              aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+            if (lbl2)
+              {
+                emitcode ("", "%05d$:", (lbl2->key + 100));
+              }
+            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));
+      emitcode ("mov", "b,%s", 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, isOperandVolatile (result, FALSE));
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+
+      popB (pushedB);
       return;
     }
 
@@ -4539,7 +5389,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);
@@ -4549,10 +5399,10 @@ 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 */
@@ -4583,7 +5433,7 @@ genModOneByte (operand * left,
     }
   else /* ! literal */
     {
-      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      MOVA (aopGet (left, 0, FALSE, FALSE));
 
       if (!lUnsigned)
         {
@@ -4612,7 +5462,7 @@ genModOneByte (operand * left,
       emitcode ("inc", "a");
       emitcode ("", "%05d$:", (lbl->key + 100));
 
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       if (size > 0)
         {
           /* msb is 0x00 or 0xff depending on the sign */
@@ -4621,19 +5471,21 @@ genModOneByte (operand * left,
               emitcode ("mov", "c,F0");
               emitcode ("subb", "a,acc");
               while (size--)
-                aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+                aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
             }
           else /* compiletimeSign */
             while (size--)
-              aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+              aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE));
         }
     }
   else
     {
-      aopPut (AOP (result), "b", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "b", 0, isOperandVolatile (result, FALSE));
       while (size--)
-        aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
     }
+
+  popB (pushedB);
 }
 
 /*-----------------------------------------------------------------*/
@@ -4648,7 +5500,7 @@ genMod (iCode * ic)
 
   D(emitcode (";     genMod",""));
 
-  /* assign the amsops */
+  /* assign the asmops */
   aopOp (left, ic, FALSE);
   aopOp (right, ic, FALSE);
   aopOp (result, ic, TRUE);
@@ -4753,8 +5605,8 @@ 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);
         }
@@ -4772,7 +5624,7 @@ 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);
@@ -4790,10 +5642,14 @@ genCmp (operand * left, operand * right,
           CLRC;
           while (size--)
             {
-              rightInB = aopGetUsesAcc(AOP (right), offset);
+              bool pushedB = FALSE;
+              rightInB = aopGetUsesAcc(right, offset);
               if (rightInB)
-                emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
-              MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+                {
+                  pushedB = pushB ();
+                  emitcode ("mov", "b,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              MOVA (aopGet (left, offset, FALSE, FALSE));
               if (sign && size == 0)
                 {
                   emitcode ("xrl", "a,#0x80");
@@ -4807,7 +5663,11 @@ genCmp (operand * left, operand * right,
                   else
                     {
                       if (!rightInB)
-                        emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+                        {
+                          pushedB = pushB ();
+                          rightInB++;
+                          emitcode ("mov", "b,%s", aopGet (right, offset, FALSE, FALSE));
+                        }
                       emitcode ("xrl", "b,#0x80");
                       emitcode ("subb", "a,b");
                     }
@@ -4817,8 +5677,10 @@ genCmp (operand * left, operand * right,
                   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);
               offset++;
             }
         }
@@ -4869,7 +5731,7 @@ genCmpGt (iCode * ic, iCode * ifx)
   aopOp (right, ic, FALSE);
   aopOp (result, ic, TRUE);
 
-  genCmp (right, left, result, ifx, sign,ic);
+  genCmp (right, left, result, ifx, sign, ic);
 
   freeAsmop (result, NULL, ic, TRUE);
 }
@@ -4899,7 +5761,7 @@ genCmpLt (iCode * ic, iCode * ifx)
   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);
 }
@@ -4937,8 +5799,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++;
         }
@@ -4955,13 +5817,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++;
         }
@@ -4971,10 +5833,13 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
       /* right is a pointer reg need both a & b */
       while (size--)
         {
-          char *l = aopGet (AOP (left), offset, FALSE, FALSE);
+          char *l;
+          //if B in use: push B; mov B,left; mov A,right; clrc; subb A,B; pop B; jnz
+          wassertl(!BINUSE, "B was in use");
+          l = aopGet (left, offset, FALSE, FALSE);
           if (strcmp (l, "b"))
             emitcode ("mov", "b,%s", l);
-          MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+          MOVA (aopGet (right, offset, FALSE, FALSE));
           emitcode ("cjne", "a,b,%05d$", lbl->key + 100);
           offset++;
         }
@@ -5156,7 +6021,7 @@ genCmpEq (iCode * ic, iCode * ifx)
       gencjne (left, right, newiTempLabel (NULL));
       if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
         {
-          aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
           goto release;
         }
       if (ifx)
@@ -5226,7 +6091,7 @@ hasInc (operand *op, iCode *ic,int osize)
       return lic;
     }
     /* if the operand used or deffed */
-    if (bitVectBitValue(OP_USES(op),lic->key) || (unsigned) lic->defKey == op->key) {
+    if (bitVectBitValue(OP_USES(op),lic->key) || lic->defKey == op->key) {
       return NULL;
     }
     /* if GOTO or IFX */
@@ -5490,7 +6355,7 @@ genAnd (iCode * ic, iCode * ifx)
           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);
@@ -5517,10 +6382,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
             {
@@ -5530,7 +6405,7 @@ genAnd (iCode * ic, iCode * ifx)
                             "acc.%d", posbit & 0x07);
                   genIfxJump (ifx, buffer, left, right, result);
                 }
-              else 
+              else
                 {// what is this case? just found it in ds390/gen.c
                    emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07));
                 }
@@ -5547,7 +6422,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);
@@ -5555,7 +6430,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);
                     }
                 }
@@ -5593,40 +6468,57 @@ 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;
+                    continue;
                 }
               else if (bytelit == 0)
                 {
-                  aopPut (AOP (result), zero, offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, zero, offset, isOperandVolatile (result, FALSE));
                 }
               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, isOperandVolatile (result, FALSE));
                 }
               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))
+                {
+                  emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,b");
+                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                }
               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, isOperandVolatile (result, FALSE));
                     }
                   else
                     emitcode ("anl", "%s,a",
-                              aopGet (AOP (left), offset, FALSE, TRUE));
+                              aopGet (left, offset, FALSE, TRUE));
                 }
             }
         }
@@ -5645,20 +6537,35 @@ 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) {
-                  emitcode("mov", "b,a");
-                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-                  emitcode("anl", "a,b");
-                }else {
-                  MOVA (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 (AOP (left), offset, FALSE, FALSE));
+                            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 {
+                      MOVA (aopGet (right, offset, FALSE, FALSE));
+                      emitcode ("anl", "a,%s",
+                                aopGet (left, offset, FALSE, FALSE));
+                    }
                 }
-              }
               emitcode ("jnz", "%05d$", tlbl->key + 100);
               offset++;
             }
@@ -5684,8 +6591,8 @@ genAnd (iCode * ic, iCode * ifx)
                   bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
                   if (bytelit == 0x0FF)
                     {
-                      aopPut (AOP (result),
-                              aopGet (AOP (left), offset, FALSE, FALSE),
+                      aopPut (result,
+                              aopGet (left, offset, FALSE, FALSE),
                               offset,
                               isOperandVolatile (result, FALSE));
                       continue;
@@ -5694,22 +6601,51 @@ genAnd (iCode * ic, iCode * ifx)
                     {
                       /* 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, isOperandVolatile (result, FALSE));
                       continue;
                     }
+                  else if (AOP_TYPE (left) == AOP_ACC)
+                    {
+                      if (!offset)
+                        {
+                          emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                          aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                          continue;
+                        }
+                      else
+                        {
+                          emitcode ("anl", "b,%s", aopGet (right, offset, FALSE, FALSE));
+                          aopPut (result, "b", offset, isOperandVolatile (result, FALSE));
+                          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 (offset)
+                    emitcode("mov", "a,b");
+                  emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  emitcode ("mov", "b,%s", 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, isOperandVolatile (result, FALSE));
             }
         }
     }
@@ -5894,43 +6830,60 @@ 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, isOperandVolatile (result, FALSE));
                 }
               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, isOperandVolatile (result, FALSE));
                 }
               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))
+                {
+                  emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("orl", "a,b");
+                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                }
               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, isOperandVolatile (result, FALSE));
                     }
                   else
                     {
                       emitcode ("orl", "%s,a",
-                                aopGet (AOP (left), offset, FALSE, TRUE));
+                                aopGet (left, offset, FALSE, TRUE));
                     }
                 }
             }
@@ -5951,12 +6904,14 @@ genOr (iCode * ic, iCode * ifx)
           while (sizer--)
             {
               if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+                if (offset)
+                  emitcode("mov", "a,b");
                 emitcode ("orl", "a,%s",
-                          aopGet (AOP (right), offset, FALSE, FALSE));
+                          aopGet (right, offset, FALSE, FALSE));
               } else {
-                MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+                MOVA (aopGet (right, offset, FALSE, FALSE));
                 emitcode ("orl", "a,%s",
-                          aopGet (AOP (left), offset, FALSE, FALSE));
+                          aopGet (left, offset, FALSE, FALSE));
               }
               emitcode ("jnz", "%05d$", tlbl->key + 100);
               offset++;
@@ -5983,8 +6938,8 @@ genOr (iCode * ic, iCode * ifx)
                   bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
                   if (bytelit == 0)
                     {
-                      aopPut (AOP (result),
-                              aopGet (AOP (left), offset, FALSE, FALSE),
+                      aopPut (result,
+                              aopGet (left, offset, FALSE, FALSE),
                               offset,
                               isOperandVolatile (result, FALSE));
                       continue;
@@ -5993,22 +6948,36 @@ genOr (iCode * ic, iCode * ifx)
                     {
                       /* 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, isOperandVolatile (result, FALSE));
                       continue;
                     }
                 }
               // faster than result <- left, anl 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 (offset)
+                    emitcode("mov", "a,b");
+                  emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  emitcode ("mov", "b,%s", 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, isOperandVolatile (result, FALSE));
             }
         }
     }
@@ -6140,7 +7109,7 @@ genXor (iCode * ic, iCode * ifx)
               emitcode ("setb", "c");
               while (sizer)
                 {
-                  MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE));
+                  MOVA (aopGet (right, sizer - 1, FALSE, FALSE));
                   if (sizer == 1)
                     // test the msb of the lsb
                     emitcode ("anl", "a,#0xfe");
@@ -6176,38 +7145,55 @@ 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;
+                    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, isOperandVolatile (result, FALSE));
                 }
               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))
+                {
+                  emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
+                  MOVA (aopGet (right, offset, FALSE, FALSE));
+                  emitcode ("xrl", "a,b");
+                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset))
+                {
+                  MOVA (aopGet (left, offset, FALSE, FALSE));
+                  emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                }
               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, isOperandVolatile (result, FALSE));
                     }
                   else
                     emitcode ("xrl", "%s,a",
-                              aopGet (AOP (left), offset, FALSE, TRUE));
+                              aopGet (left, offset, FALSE, TRUE));
                 }
             }
         }
@@ -6229,17 +7215,19 @@ 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 && AOP_TYPE(left)==AOP_ACC) {
+                    if (offset)
+                      emitcode("mov", "a,b");
                     emitcode ("xrl", "a,%s",
-                              aopGet (AOP (right), offset, FALSE, FALSE));
+                              aopGet (right, offset, FALSE, FALSE));
                   } else {
-                    MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+                    MOVA (aopGet (right, offset, FALSE, FALSE));
                     emitcode ("xrl", "a,%s",
-                              aopGet (AOP (left), offset, FALSE, FALSE));
+                              aopGet (left, offset, FALSE, FALSE));
                   }
                 }
               emitcode ("jnz", "%05d$", tlbl->key + 100);
@@ -6265,8 +7253,8 @@ genXor (iCode * ic, iCode * ifx)
                   bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
                   if (bytelit == 0)
                     {
-                      aopPut (AOP (result),
-                              aopGet (AOP (left), offset, FALSE, FALSE),
+                      aopPut (result,
+                              aopGet (left, offset, FALSE, FALSE),
                               offset,
                               isOperandVolatile (result, FALSE));
                       continue;
@@ -6275,14 +7263,28 @@ genXor (iCode * ic, iCode * ifx)
               // faster than result <- left, anl 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 (offset)
+                    emitcode("mov", "a,b");
+                  emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
+                }
+              else if (aopGetUsesAcc (left, offset) && aopGetUsesAcc (right, offset))
+                {
+                  emitcode ("mov", "b,%s", 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, isOperandVolatile (result, FALSE));
             }
         }
     }
@@ -6320,7 +7322,7 @@ genInline (iCode * ic)
       else
         {
           /* Add \n for labels, not dirs such as c:\mydir */
-          if ( (*bp == ':') && (isspace(bp[1])) )
+          if ( (*bp == ':') && (isspace((unsigned char)bp[1])) )
             {
               bp++;
               *bp = '\0';
@@ -6360,30 +7362,30 @@ 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--, isOperandVolatile (result, FALSE));
     }
   /* 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));
+  aopPut (result, "a", AOP_SIZE (result) - 1, isOperandVolatile (result, FALSE));
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
@@ -6411,34 +7413,34 @@ 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++, isOperandVolatile (result, FALSE));
       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++, isOperandVolatile (result, FALSE));
         }
     }
   /* 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));
+  aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
@@ -6459,7 +7461,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");
@@ -6477,6 +7479,140 @@ genGetHbit (iCode * ic)
   freeAsmop (result, 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) floatFromVal (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 (left, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, 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)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
+  aopPut (result,
+          aopGet (left, offset, FALSE, FALSE),
+          0,
+          isOperandVolatile (result, FALSE));
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, 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)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
+  aopPut (result,
+          aopGet (left, offset, FALSE, FALSE),
+          0,
+          isOperandVolatile (result, FALSE));
+  aopPut (result,
+          aopGet (left, offset+1, FALSE, FALSE),
+          1,
+          isOperandVolatile (result, FALSE));
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
 /*-----------------------------------------------------------------*/
 /* genSwap - generates code to swap nibbles or bytes               */
 /*-----------------------------------------------------------------*/
@@ -6495,36 +7631,43 @@ 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, isOperandVolatile (result, FALSE));
       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),
+          MOVA (aopGet (left, 0, FALSE, FALSE));
+          aopPut (result, aopGet (left, 1, FALSE, FALSE),
                   0, isOperandVolatile (result, FALSE));
-          aopPut (AOP (result), "a", 1, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", 1, isOperandVolatile (result, FALSE));
         }
       else if (operandsEqu (left, result))
         {
           char * reg = "a";
-          MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
-          if (aopGetUsesAcc(AOP (left), 1) || aopGetUsesAcc(AOP (result), 0))
+          bool pushedB = FALSE, leftInB = FALSE;
+
+          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),
+          aopPut (result, aopGet (left, 1, FALSE, FALSE),
                   0, isOperandVolatile (result, FALSE));
-          aopPut (AOP (result), reg, 1, isOperandVolatile (result, FALSE));
+          aopPut (result, reg, 1, isOperandVolatile (result, FALSE));
+
+          if (leftInB)
+            popB (pushedB);
         }
       else
         {
-          aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
+          aopPut (result, aopGet (left, 1, FALSE, FALSE),
                   0, isOperandVolatile (result, FALSE));
-          aopPut (AOP (result), aopGet (AOP (left), 0, FALSE, FALSE),
+          aopPut (result, aopGet (left, 0, FALSE, FALSE),
                   1, isOperandVolatile (result, FALSE));
         }
       break;
@@ -6669,13 +7812,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, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -6686,11 +7829,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, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -6703,24 +7846,24 @@ 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, isOperandVolatile (result, FALSE));
         }
       else
         {
           if (!sign)
-            aopPut (AOP (result), l, offr, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offr, isOperandVolatile (result, FALSE));
           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, isOperandVolatile (result, FALSE));
                 }
             }
         }
@@ -7034,21 +8177,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));
+      emitcode ("xch", "a,%s", aopGet (left, offl + MSB16, FALSE, FALSE));
+      x = aopGet (result, offr, FALSE, FALSE);
+    }
+  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, isOperandVolatile (result, FALSE));
+      aopPut (result, "b", offr + MSB16, isOperandVolatile (result, FALSE));
+      popB (pushedB);
+    }
+  else
+    {
+      aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE));
+    }
 }
 
 
@@ -7060,25 +8229,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));
+      emitcode ("xch", "a,%s", aopGet (left, offl + MSB16, FALSE, FALSE));
+      x = aopGet (result, offr, FALSE, FALSE);
+    }
+  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, isOperandVolatile (result, FALSE));
+      emitcode ("xch", "a,b");
+      popB (pushedB);
+    }
   if (getDataSize (result) > 1)
-    aopPut (AOP (result), "a", offr + MSB16, isOperandVolatile (result, FALSE));
+    aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -7088,13 +8279,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, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -7104,13 +8304,13 @@ 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));
+  emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
   /* back to result */
-  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -7148,7 +8348,7 @@ genlshTwo (operand * result, operand * left, int shCount)
           else
             movLeft2Result (left, LSB, result, MSB16, 0);
         }
-      aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
     }
 
   /*  1 <= shCount <= 7 */
@@ -7173,61 +8373,61 @@ 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));
+                  aopGet (left, LSB + offr, FALSE, FALSE));
       else
-        aopPut (AOP (result), "a", LSB + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", LSB + offr, isOperandVolatile (result, FALSE));
     }
 
   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));
+                  aopGet (left, MSB16 + offr, FALSE, FALSE));
       else
-        aopPut (AOP (result), "a", MSB16 + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", MSB16 + offr, isOperandVolatile (result, FALSE));
     }
 
   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));
+                  aopGet (left, MSB24 + offr, FALSE, FALSE));
       else
-        aopPut (AOP (result), "a", MSB24 + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", MSB24 + offr, isOperandVolatile (result, FALSE));
     }
 
   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, isOperandVolatile (result, FALSE));
     }
   if (offr != LSB)
-    aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+    aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -7252,9 +8452,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, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, MSB24, isOperandVolatile (result, FALSE));
       return;
     }
 
@@ -7271,8 +8471,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, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
       return;
     }
 
@@ -7295,7 +8495,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, isOperandVolatile (result, FALSE));
             }
           else if (shCount == 1)
             shiftLLong (left, result, MSB16);
@@ -7304,7 +8504,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, isOperandVolatile (result, FALSE));
             }
         }
     }
@@ -7362,7 +8562,7 @@ genLeftShiftLiteral (operand * left,
 
   else if (shCount >= (size * 8))
     while (size--)
-      aopPut (AOP (result), zero, size, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, size, isOperandVolatile (result, FALSE));
   else
     {
       switch (size)
@@ -7398,6 +8598,7 @@ genLeftShift (iCode * ic)
   int size, offset;
   char *l;
   symbol *tlbl, *tlbl1;
+  bool pushedB;
 
   D(emitcode (";     genLeftShift",""));
 
@@ -7421,14 +8622,14 @@ genLeftShift (iCode * ic)
      more that 32 bits make no sense anyway, ( the
      largest size of an object can be only 32 bits ) */
 
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+  pushedB = pushB ();
+  emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
   emitcode ("inc", "b");
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE);
   aopOp (result, ic, FALSE);
 
-  /* now move the left to the result if they are not the
-     same */
+  /* now move the left to the result if they are not the same */
   if (!sameRegs (AOP (left), AOP (result)) &&
       AOP_SIZE (result) > 1)
     {
@@ -7437,15 +8638,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, isOperandVolatile (result, FALSE));
             }
           else
-            aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset, isOperandVolatile (result, FALSE));
           offset++;
         }
     }
@@ -7460,14 +8661,15 @@ 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);
       emitcode ("add", "a,acc");
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      popB (pushedB);
+      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -7475,21 +8677,22 @@ genLeftShift (iCode * ic)
 
   emitcode ("sjmp", "%05d$", tlbl1->key + 100);
   emitcode ("", "%05d$:", tlbl->key + 100);
-  l = aopGet (AOP (result), offset, FALSE, FALSE);
+  l = aopGet (result, offset, FALSE, FALSE);
   MOVA (l);
   emitcode ("add", "a,acc");
-  aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
   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++, isOperandVolatile (result, FALSE));
     }
   reAdjustPreg (AOP (result));
 
   emitcode ("", "%05d$:", tlbl1->key + 100);
   emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+  popB (pushedB);
 release:
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
@@ -7541,14 +8744,14 @@ static void
 shiftRLong (operand * left, int offl,
             operand * result, int sign)
 {
-  int isSameRegs=sameRegs(AOP(left),AOP(result));
+  int isSameRegs = sameRegs (AOP (left), AOP (result));
 
   if (isSameRegs && 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
@@ -7556,13 +8759,13 @@ shiftRLong (operand * left, int offl,
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       if (isSameRegs)
-        emitcode ("xch", "a,%s", aopGet(AOP(left), MSB32, FALSE, FALSE));
+        emitcode ("xch", "a,%s", aopGet (left, MSB32, FALSE, FALSE));
       else {
-        aopPut (AOP (result), "a", MSB32, isOperandVolatile (result, FALSE));
-        MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
+        aopPut (result, "a", MSB32, isOperandVolatile (result, FALSE));
+        MOVA (aopGet (left, MSB32, FALSE, FALSE));
       }
     } else {
-      aopPut (AOP(result), zero, MSB32, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, MSB32, isOperandVolatile (result, FALSE));
     }
   }
 
@@ -7575,27 +8778,27 @@ shiftRLong (operand * left, int offl,
   emitcode ("rrc", "a");
 
   if (isSameRegs && offl==MSB16) {
-    emitcode ("xch", "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE));
+    emitcode ("xch", "a,%s",aopGet (left, MSB24, FALSE, FALSE));
   } else {
-    aopPut (AOP (result), "a", MSB32-offl, isOperandVolatile (result, FALSE));
-    MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
+    aopPut (result, "a", MSB32-offl, isOperandVolatile (result, FALSE));
+    MOVA (aopGet (left, MSB24, FALSE, FALSE));
   }
 
   emitcode ("rrc", "a");
   if (isSameRegs && offl==1) {
-    emitcode ("xch", "a,%s",aopGet (AOP (left), MSB16, FALSE, FALSE));
+    emitcode ("xch", "a,%s",aopGet (left, MSB16, FALSE, FALSE));
   } else {
-    aopPut (AOP (result), "a", MSB24-offl, isOperandVolatile (result, FALSE));
-    MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
+    aopPut (result, "a", MSB24-offl, isOperandVolatile (result, FALSE));
+    MOVA (aopGet (left, MSB16, FALSE, FALSE));
   }
   emitcode ("rrc", "a");
-  aopPut (AOP (result), "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
 
   if (offl == LSB)
     {
-      MOVA (aopGet (AOP (left), LSB, FALSE, FALSE));
+      MOVA (aopGet (left, LSB, FALSE, FALSE));
       emitcode ("rrc", "a");
-      aopPut (AOP (result), "a", LSB, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", LSB, isOperandVolatile (result, FALSE));
     }
 }
 
@@ -7708,7 +8911,7 @@ genRightShiftLiteral (operand * left,
     {
       if (sign) {
         /* get sign in acc.7 */
-        MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE));
+        MOVA (aopGet (left, size - 1, FALSE, FALSE));
       }
       addSign (result, LSB, sign);
     }
@@ -7745,6 +8948,7 @@ genSignedRightShift (iCode * ic)
   int size, offset;
   char *l;
   symbol *tlbl, *tlbl1;
+  bool pushedB;
 
   D(emitcode (";     genSignedRightShift",""));
 
@@ -7769,7 +8973,8 @@ genSignedRightShift (iCode * ic)
      more that 32 bits make no sense anyway, ( the
      largest size of an object can be only 32 bits ) */
 
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+  pushedB = pushB ();
+  emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
   emitcode ("inc", "b");
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE);
@@ -7785,15 +8990,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, isOperandVolatile (result, FALSE));
             }
           else
-            aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset, isOperandVolatile (result, FALSE));
           offset++;
         }
     }
@@ -7804,13 +9009,13 @@ 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);
@@ -7818,7 +9023,8 @@ genSignedRightShift (iCode * ic)
       emitcode ("rrc", "a");
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      popB (pushedB);
+      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -7828,14 +9034,15 @@ genSignedRightShift (iCode * ic)
   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--, isOperandVolatile (result, FALSE));
     }
   reAdjustPreg (AOP (result));
   emitcode ("", "%05d$:", tlbl1->key + 100);
   emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+  popB (pushedB);
 
 release:
   freeAsmop (left, NULL, ic, TRUE);
@@ -7853,6 +9060,7 @@ genRightShift (iCode * ic)
   int size, offset;
   char *l;
   symbol *tlbl, *tlbl1;
+  bool pushedB;
 
   D(emitcode (";     genRightShift",""));
 
@@ -7893,7 +9101,8 @@ genRightShift (iCode * ic)
      more that 32 bits make no sense anyway, ( the
      largest size of an object can be only 32 bits ) */
 
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+  pushedB = pushB ();
+  emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
   emitcode ("inc", "b");
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE);
@@ -7909,15 +9118,15 @@ genRightShift (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, isOperandVolatile (result, FALSE));
             }
           else
-            aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset, isOperandVolatile (result, FALSE));
           offset++;
         }
     }
@@ -7930,7 +9139,7 @@ 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);
@@ -7938,7 +9147,8 @@ genRightShift (iCode * ic)
       emitcode ("rrc", "a");
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      popB (pushedB);
+      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -7948,15 +9158,16 @@ genRightShift (iCode * ic)
   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--, isOperandVolatile (result, FALSE));
     }
   reAdjustPreg (AOP (result));
 
   emitcode ("", "%05d$:", tlbl1->key + 100);
   emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+  popB (pushedB);
 
 release:
   freeAsmop (left, NULL, ic, TRUE);
@@ -8078,25 +9289,34 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx)
           SNPRINTF (buffer, sizeof(buffer),
                     "acc.%d", bstr);
           genIfxJump (ifx, buffer, NULL, NULL, NULL);
-	}
+        }
       else
         {
           if (blen < 8)
             emitcode ("anl", "a,#0x%02x",
-	              (((unsigned char) -1) >> (8 - blen)) << bstr);
+                      (((unsigned char) -1) >> (8 - blen)) << bstr);
           genIfxJump (ifx, "a", NULL, NULL, NULL);
-	}
+        }
       return;
     }
   wassert (!ifx);
-  
+
   /* If the bitfield length is less than a byte */
   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));
+          emitcode ("", "%05d$:", tlbl->key + 100);
+        }
+      aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
       goto finish;
     }
 
@@ -8105,7 +9325,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++, isOperandVolatile (result, FALSE));
       if (rlen>8)
         emitcode ("inc", "%s", rname);
     }
@@ -8115,15 +9335,36 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx)
     {
       emitPtrByteGet (rname, ptype, FALSE);
       emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (8-rlen));
-      aopPut (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));
+          emitcode ("", "%05d$:", tlbl->key + 100);
+        }
+      aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
     }
 
 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++, isOperandVolatile (result, FALSE));
     }
 }
 
@@ -8145,7 +9386,7 @@ genDataPointerGet (operand * left,
   aopOp (result, ic, TRUE);
 
   /* get the string representation of the name */
-  l = aopGet (AOP (left), 0, FALSE, TRUE);
+  l = aopGet (left, 0, FALSE, TRUE);
   size = AOP_SIZE (result);
   while (size--)
     {
@@ -8153,7 +9394,7 @@ genDataPointerGet (operand * left,
         sprintf (buffer, "(%s + %d)", l + 1, offset);
       else
         sprintf (buffer, "%s", l + 1);
-      aopPut (AOP (result), buffer, offset++, isOperandVolatile (result, FALSE));
+      aopPut (result, buffer, offset++, isOperandVolatile (result, FALSE));
     }
 
   freeAsmop (left, NULL, ic, TRUE);
@@ -8168,7 +9409,7 @@ genNearPointerGet (operand * left,
                    operand * result,
                    iCode * ic,
                    iCode * pi,
-		   iCode * ifx)
+                   iCode * ifx)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -8203,7 +9444,7 @@ genNearPointerGet (operand * left,
       if (IS_AOP_PREG (left))
         {
           // Aha, it is a pointer, just in disguise.
-          rname = aopGet (AOP (left), 0, FALSE, FALSE);
+          rname = aopGet (left, 0, FALSE, FALSE);
           if (*rname != '@')
             {
               fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
@@ -8223,12 +9464,12 @@ 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);
+    rname = aopGet (left, 0, FALSE, FALSE);
 
   //aopOp (result, ic, FALSE);
   aopOp (result, ic, result?TRUE:FALSE);
@@ -8249,12 +9490,12 @@ genNearPointerGet (operand * left,
 
               emitcode ("mov", "a,@%s", rname);
               if (!ifx)
-                aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
             }
           else
             {
               sprintf (buffer, "@%s", rname);
-              aopPut (AOP (result), buffer, offset, isOperandVolatile (result, FALSE));
+              aopPut (result, buffer, offset, isOperandVolatile (result, FALSE));
             }
           offset++;
           if (size || pi)
@@ -8266,7 +9507,7 @@ genNearPointerGet (operand * left,
   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, isOperandVolatile (left, FALSE));
       }
       freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
     }
@@ -8288,7 +9529,7 @@ genNearPointerGet (operand * left,
             emitcode ("dec", "%s", rname);
         }
     }
-  
+
   if (ifx && !ifx->generated)
     {
       genIfxJump (ifx, "a", left, NULL, result);
@@ -8308,7 +9549,7 @@ genPagedPointerGet (operand * left,
                     operand * result,
                     iCode * ic,
                     iCode *pi,
-		    iCode *ifx)
+                    iCode *ifx)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -8331,11 +9572,11 @@ 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);
+    rname = aopGet (left, 0, FALSE, FALSE);
 
   aopOp (result, ic, FALSE);
 
@@ -8353,7 +9594,7 @@ genPagedPointerGet (operand * left,
 
           emitcode ("movx", "a,@%s", rname);
           if (!ifx)
-            aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
 
           offset++;
 
@@ -8365,7 +9606,7 @@ genPagedPointerGet (operand * left,
   /* now some housekeeping stuff */
   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, isOperandVolatile (left, FALSE));
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -8407,14 +9648,14 @@ loadDptrFromOperand (operand *op, bool loadBToo)
 {
   if (AOP_TYPE (op) != AOP_STR)
     {
-      /* if this is remateriazable */
+      /* 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");
@@ -8424,7 +9665,7 @@ loadDptrFromOperand (operand *op, bool loadBToo)
                   ** 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));
                   */
                 }
             }
@@ -8433,28 +9674,28 @@ 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));
         }
     }
 }
@@ -8488,20 +9729,19 @@ genFarPointerGet (operand * left,
       while (size--)
         {
           emitcode ("movx", "a,@dptr");
-	  if (!ifx)
-            aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+          if (!ifx)
+            aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
           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, isOperandVolatile (left, FALSE));
+    aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
+    pi->generated = 1;
+  }
 
   if (ifx && !ifx->generated)
     {
@@ -8545,7 +9785,7 @@ genCodePointerGet (operand * left,
               emitcode ("clr", "a");
               emitcode ("movc", "a,@a+dptr");
               if (!ifx)
-                aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
               emitcode ("inc", "dptr");
             }
           else
@@ -8553,17 +9793,17 @@ genCodePointerGet (operand * left,
               emitcode ("mov", "a,#0x%02x", offset);
               emitcode ("movc", "a,@a+dptr");
               if (!ifx)
-                aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
             }
         }
     }
 
   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, isOperandVolatile (left, FALSE));
+    aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
+    pi->generated = 1;
+  }
 
   if (ifx && !ifx->generated)
     {
@@ -8604,7 +9844,7 @@ genGenPointerGet (operand * left,
         {
           emitcode ("lcall", "__gptrget");
           if (!ifx)
-            aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
           if (size || pi)
             emitcode ("inc", "dptr");
         }
@@ -8612,17 +9852,17 @@ 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, isOperandVolatile (left, FALSE));
+    aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
+    pi->generated = 1;
+  }
 
   if (ifx && !ifx->generated)
     {
       genIfxJump (ifx, "a", left, NULL, result);
     }
 
-    
+
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
@@ -8641,7 +9881,7 @@ genPointerGet (iCode * ic, iCode *pi, iCode *ifx)
 
   left = IC_LEFT (ic);
   result = IC_RESULT (ic);
-  
+
   if (getSize (operandType (result))>1)
     ifx = NULL;
 
@@ -8745,7 +9985,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);
@@ -8753,13 +9993,15 @@ genPackBits (sym_link * etype,
             }
           else
             {
+              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);
 
+              pushedB = pushB ();
               /* transfer A to B and get next byte */
               emitPtrByteGet (rname, p_type, TRUE);
 
@@ -8767,6 +10009,8 @@ genPackBits (sym_link * etype,
               emitcode ("orl", "a,b");
               if (p_type == GPOINTER)
                 emitcode ("pop", "b");
+
+              popB (pushedB);
            }
         }
 
@@ -8779,7 +10023,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);
     }
@@ -8804,11 +10048,13 @@ genPackBits (sym_link * etype,
         }
       else
         {
+          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 ();
           /* transfer A to B and get next byte */
           emitPtrByteGet (rname, p_type, TRUE);
 
@@ -8816,6 +10062,8 @@ genPackBits (sym_link * etype,
           emitcode ("orl", "a,b");
           if (p_type == GPOINTER)
             emitcode ("pop", "b");
+
+          popB (pushedB);
         }
       emitPtrByteSet (rname, p_type, "a");
     }
@@ -8838,7 +10086,7 @@ genDataPointerSet (operand * right,
 
   aopOp (right, ic, FALSE);
 
-  l = aopGet (AOP (result), 0, FALSE, TRUE);
+  l = aopGet (result, 0, FALSE, TRUE);
   size = AOP_SIZE (right);
   while (size--)
     {
@@ -8847,7 +10095,7 @@ genDataPointerSet (operand * right,
       else
         sprintf (buffer, "%s", l + 1);
       emitcode ("mov", "%s,%s", buffer,
-                aopGet (AOP (right), offset++, FALSE, FALSE));
+                aopGet (right, offset++, FALSE, FALSE));
     }
 
   freeAsmop (right, NULL, ic, TRUE);
@@ -8896,7 +10144,7 @@ genNearPointerSet (operand * right,
             )
         {
             // Aha, it is a pointer, just in disguise.
-            rname = aopGet (AOP (result), 0, FALSE, FALSE);
+            rname = aopGet (result, 0, FALSE, FALSE);
             if (*rname != '@')
             {
                 fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
@@ -8916,13 +10164,13 @@ genNearPointerSet (operand * right,
             preg = getFreePtr (ic, &aop, FALSE);
             emitcode ("mov", "%s,%s",
                       preg->name,
-                      aopGet (AOP (result), 0, FALSE, TRUE));
+                      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);
@@ -8938,7 +10186,7 @@ genNearPointerSet (operand * right,
 
       while (size--)
         {
-          l = aopGet (AOP (right), offset, FALSE, TRUE);
+          l = aopGet (right, offset, FALSE, TRUE);
           if (*l == '@')
             {
               MOVA (l);
@@ -8956,7 +10204,7 @@ genNearPointerSet (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, isOperandVolatile (result, FALSE));
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -9014,11 +10262,11 @@ genPagedPointerSet (operand * right,
       preg = getFreePtr (ic, &aop, FALSE);
       emitcode ("mov", "%s,%s",
                 preg->name,
-                aopGet (AOP (result), 0, FALSE, TRUE));
+                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);
 
@@ -9033,7 +10281,7 @@ genPagedPointerSet (operand * right,
 
       while (size--)
         {
-          l = aopGet (AOP (right), offset, FALSE, TRUE);
+          l = aopGet (right, offset, FALSE, TRUE);
 
           MOVA (l);
           emitcode ("movx", "@%s,a", rname);
@@ -9049,7 +10297,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, isOperandVolatile (result, FALSE));
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -9107,7 +10355,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)
@@ -9115,8 +10363,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, isOperandVolatile (result, FALSE));
+    aopPut (result, "dph", 1, isOperandVolatile (result, FALSE));
     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);
@@ -9152,7 +10400,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)
@@ -9161,8 +10409,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, isOperandVolatile (result, FALSE));
+    aopPut (result, "dph", 1, isOperandVolatile (result, FALSE));
     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);
@@ -9243,6 +10491,7 @@ genIfx (iCode * ic, iCode * popIc)
 {
   operand *cond = IC_COND (ic);
   int isbit = 0;
+  char *dup = NULL;
 
   D(emitcode (";     genIfx",""));
 
@@ -9252,17 +10501,22 @@ genIfx (iCode * ic, iCode * popIc)
   if (AOP_TYPE (cond) != AOP_CRY)
     toBoolean (cond);
   else
-    isbit = 1;
-  /* the result is now in the accumulator */
+    {
+      isbit = 1;
+      if (AOP(cond)->aopu.aop_dir)
+        dup = Safe_strdup(AOP(cond)->aopu.aop_dir);
+    }
+  /* the result is now in the accumulator or a directly addressable bit */
   freeAsmop (cond, NULL, ic, TRUE);
 
   /* if there was something to be popped then do it */
   if (popIc)
     genIpop (popIc);
 
-  /* if the condition is  a bit variable */
-  if (isbit && IS_ITEMP (cond) &&
-      SPIL_LOC (cond))
+  /* if the condition is a bit variable */
+  if (isbit && dup)
+    genIfxJump(ic, dup, NULL, NULL, NULL);
+  else if (isbit && IS_ITEMP (cond) && SPIL_LOC (cond))
     genIfxJump (ic, SPIL_LOC (cond)->rname, NULL, NULL, NULL);
   else if (isbit && !IS_ITEMP (cond))
     genIfxJump (ic, OP_SYMBOL (cond)->rname, NULL, NULL, NULL);
@@ -9294,16 +10548,16 @@ genAddrOf (iCode * ic)
          it */
       if (sym->stack)
         {
-          emitcode ("mov", "a,_bp");
+          emitcode ("mov", "a,%s", SYM_BP (sym));
           emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ?
                                          ((char) (sym->stack - _G.nRegsSaved)) :
                                          ((char) sym->stack)) & 0xff);
-          aopPut (AOP (IC_RESULT (ic)), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
         }
       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, isOperandVolatile (IC_RESULT (ic), FALSE));
         }
       /* fill the result with zero */
       size = AOP_SIZE (IC_RESULT (ic)) - 1;
@@ -9311,7 +10565,7 @@ 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++, isOperandVolatile (IC_RESULT (ic), FALSE));
         }
 
       goto release;
@@ -9330,7 +10584,7 @@ genAddrOf (iCode * ic)
                  offset * 8);
       else
         sprintf (s, "#%s", sym->rname);
-      aopPut (AOP (IC_RESULT (ic)), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
 release:
@@ -9353,7 +10607,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   /* 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");
     }
@@ -9365,7 +10619,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   while (size--)
     {
       emitcode ("pop", "acc");
-      aopPut (AOP (result), "a", --offset, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", --offset, isOperandVolatile (result, FALSE));
     }
   freeAsmop (result, NULL, ic, FALSE);
 
@@ -9421,9 +10675,9 @@ genAssign (iCode * ic)
       if (AOP_TYPE (right) == AOP_LIT)
         {
           if (((int) operandLitValue (right)))
-            aopPut (AOP (result), one, 0, isOperandVolatile (result, FALSE));
+            aopPut (result, one, 0, isOperandVolatile (result, FALSE));
           else
-            aopPut (AOP (result), zero, 0, isOperandVolatile (result, FALSE));
+            aopPut (result, zero, 0, isOperandVolatile (result, FALSE));
           goto release;
         }
 
@@ -9431,13 +10685,13 @@ genAssign (iCode * ic)
       if (AOP_TYPE (right) == AOP_CRY)
         {
           emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-          aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+          aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
           goto release;
         }
 
       /* we need to or */
       toBoolean (right);
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -9453,24 +10707,29 @@ genAssign (iCode * ic)
       !IS_FLOAT (operandType (right)) &&
       (lit < 256L))
     {
+      while ((size) && (lit))
+        {
+          aopPut (result,
+                  aopGet (right, offset, FALSE, FALSE),
+                  offset,
+                  isOperandVolatile (result, FALSE));
+          lit >>= 8;
+          offset++;
+          size--;
+        }
       emitcode ("clr", "a");
       while (size--)
         {
-          if ((unsigned int) ((lit >> (size * 8)) & 0x0FFL) == 0)
-            aopPut (AOP (result), "a", size, isOperandVolatile (result, FALSE));
-          else
-            aopPut (AOP (result),
-                    aopGet (AOP (right), size, FALSE, FALSE),
-                    size,
-                    isOperandVolatile (result, FALSE));
+          aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+          offset++;
         }
     }
   else
     {
       while (size--)
         {
-          aopPut (AOP (result),
-                  aopGet (AOP (right), offset, FALSE, FALSE),
+          aopPut (result,
+                  aopGet (right, offset, FALSE, FALSE),
                   offset,
                   isOperandVolatile (result, FALSE));
           offset++;
@@ -9483,7 +10742,7 @@ release:
 }
 
 /*-----------------------------------------------------------------*/
-/* genJumpTab - genrates code for jump table                       */
+/* genJumpTab - generates code for jump table                      */
 /*-----------------------------------------------------------------*/
 static void
 genJumpTab (iCode * ic)
@@ -9498,16 +10757,18 @@ genJumpTab (iCode * ic)
 
   if( count <= 16 )
     {
-      /* this algorithm needs 9 cycles and 7 + 3*n bytes 
-         if the switch argument is in an register. 
-         (8 cycles and 6+2*n bytes if peepholes can change ljmp to sjmp) */ 
+      /* 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 ???*/
       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));
+      emitcode ("add", "a,%s", aopGet (IC_JTCOND (ic), 0, FALSE, FALSE));
       freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
 
       jtab = newiTempLabel (NULL);
@@ -9521,24 +10782,26 @@ genJumpTab (iCode * ic)
     }
   else
     {
-      /* this algorithm needs 14 cycles and 13 + 2*n bytes 
-         if the switch argument is in an register. 
-         For n>6 this algorithm may be more compact */ 
+      /* this algorithm needs 14 cycles and 13 + 2*n bytes
+         if the switch argument is in a register.
+         For n>6 this algorithm may be more compact */
       jtablo = newiTempLabel (NULL);
       jtabhi = newiTempLabel (NULL);
 
       /* get the condition into accumulator.
-         Using b as temporary storage, if register push/pop is needed */ 
+         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(!BINUSE, "B was in use");
           emitcode ("mov", "b,%s", l);
           l = "b";
         }
-      freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);            
-      MOVA (l);      
+      freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
+      MOVA (l);
       if( count <= 112 )
         {
           emitcode ("add", "a,#(%05d$-3-.)", jtablo->key + 100);
@@ -9550,7 +10813,7 @@ genJumpTab (iCode * ic)
           emitcode ("movc", "a,@a+pc");
           emitcode ("push", "acc");
         }
-      else	
+      else
         {
           /* this scales up to n<=255, but needs two more bytes
              and changes dptr */
@@ -9577,9 +10840,7 @@ genJumpTab (iCode * ic)
       for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab;
            jtab = setNextItem (IC_JTLABELS (ic)))
          emitcode (".db", "%05d$>>8", jtab->key + 100);
-    
-    }  
-
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -9605,17 +10866,17 @@ genCast (iCode * ic)
 
   /* 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))
+    /* not for bitfields */
     {
       /* 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));
+            aopPut (result, one, 0, isOperandVolatile (result, FALSE));
           else
-            aopPut (AOP (result), zero, 0, isOperandVolatile (result, FALSE));
+            aopPut (result, zero, 0, isOperandVolatile (result, FALSE));
 
           goto release;
         }
@@ -9624,13 +10885,13 @@ genCast (iCode * ic)
       if (AOP_TYPE (right) == AOP_CRY)
         {
           emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-          aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
+          aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
           goto release;
         }
 
       /* we need to or */
       toBoolean (right);
-      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -9648,8 +10909,8 @@ genCast (iCode * ic)
       offset = 0;
       while (size--)
         {
-          aopPut (AOP (result),
-                  aopGet (AOP (right), offset, FALSE, FALSE),
+          aopPut (result,
+                  aopGet (right, offset, FALSE, FALSE),
                   offset,
                   isOperandVolatile (result, FALSE));
           offset++;
@@ -9687,8 +10948,8 @@ genCast (iCode * ic)
           offset = 0;
           while (size--)
             {
-              aopPut (AOP (result),
-                      aopGet (AOP (right), offset, FALSE, FALSE),
+              aopPut (result,
+                      aopGet (right, offset, FALSE, FALSE),
                       offset,
                       isOperandVolatile (result, FALSE));
               offset++;
@@ -9704,8 +10965,8 @@ genCast (iCode * ic)
                     exit(1);
                 }
 
-                sprintf(gpValStr, "#0x%d", gpVal);
-                aopPut (AOP (result), gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
+                sprintf(gpValStr, "#0x%x", gpVal);
+                aopPut (result, gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
             }
           goto release;
         }
@@ -9715,8 +10976,8 @@ genCast (iCode * ic)
       offset = 0;
       while (size--)
         {
-          aopPut (AOP (result),
-                  aopGet (AOP (right), offset, FALSE, FALSE),
+          aopPut (result,
+                  aopGet (right, offset, FALSE, FALSE),
                   offset,
                   isOperandVolatile (result, FALSE));
           offset++;
@@ -9731,8 +10992,8 @@ genCast (iCode * ic)
   offset = 0;
   while (size--)
     {
-      aopPut (AOP (result),
-              aopGet (AOP (right), offset, FALSE, FALSE),
+      aopPut (result,
+              aopGet (right, offset, FALSE, FALSE),
               offset,
               isOperandVolatile (result, FALSE));
       offset++;
@@ -9744,18 +11005,18 @@ 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++, isOperandVolatile (result, FALSE));
     }
   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++, isOperandVolatile (result, FALSE));
     }
 
   /* we are done hurray !!!! */
@@ -9809,7 +11070,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"))
       {
@@ -9823,19 +11084,19 @@ 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, isOperandVolatile (IC_RESULT (ic), FALSE));
       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));
       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);
@@ -9854,15 +11115,18 @@ genDjnz (iCode * ic, iCode * ifx)
 static void
 genReceive (iCode * ic)
 {
-    int size = getSize (operandType (IC_RESULT (ic)));
-    int offset = 0;
+  int size = getSize (operandType (IC_RESULT (ic)));
+  int offset = 0;
+
   D(emitcode (";     genReceive",""));
 
-  if (ic->argreg == 1) { /* first parameter */
-      if (isOperandInFarSpace (IC_RESULT (ic)) &&
+  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)))) {
-
+           IS_TRUE_SYMOP (IC_RESULT (ic))))
+        {
           regs *tempRegs[4];
           int receivingA = 0;
           int roffset = 0;
@@ -9881,10 +11145,10 @@ genReceive (iCode * ic)
                   _G.accInUse++;
                   aopOp (IC_RESULT (ic), ic, FALSE);
                   _G.accInUse--;
-                  aopPut (AOP (IC_RESULT (ic)), "a", offset,
+                  aopPut (IC_RESULT (ic), "a", offset,
                           isOperandVolatile (IC_RESULT (ic), FALSE));
                   for (offset = 1; offset<size; offset++)
-                    aopPut (AOP (IC_RESULT (ic)), tempRegs[--roffset]->name, offset,
+                    aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset,
                             isOperandVolatile (IC_RESULT (ic), FALSE));
                   goto release;
                 }
@@ -9897,40 +11161,55 @@ 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,
+                    aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset,
                             isOperandVolatile (IC_RESULT (ic), FALSE));
                   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++, isOperandVolatile (IC_RESULT (ic), FALSE));
+            }
+        }
+      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 */
+      if (OP_SYMBOL (IC_RESULT (ic))->regs[0]->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++, isOperandVolatile (IC_RESULT (ic), FALSE));
+        }
+    }
 
 release:
   freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
@@ -9963,7 +11242,7 @@ genDummyRead (iCode * ic)
           offset = 0;
           while (size--)
           {
-            MOVA (aopGet (AOP (op), offset, FALSE, FALSE));
+            MOVA (aopGet (op, offset, FALSE, FALSE));
             offset++;
           }
         }
@@ -9987,7 +11266,7 @@ genDummyRead (iCode * ic)
           offset = 0;
           while (size--)
           {
-            MOVA (aopGet (AOP (op), offset, FALSE, FALSE));
+            MOVA (aopGet (op, offset, FALSE, FALSE));
             offset++;
           }
         }
@@ -10007,20 +11286,22 @@ genCritical (iCode *ic)
   D(emitcode(";     genCritical",""));
 
   if (IC_RESULT (ic))
-    aopOp (IC_RESULT (ic), ic, TRUE);
-
-  emitcode ("setb", "c");
-  emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
-  emitcode ("clr", "c");
-  emitcode ("", "%05d$:", (tlbl->key + 100));
-
-  if (IC_RESULT (ic))
-    outBitC (IC_RESULT (ic)); /* save old ea in an operand */
+    {
+      aopOp (IC_RESULT (ic), ic, TRUE);
+      aopPut (IC_RESULT (ic), one, 0, 0);
+      emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
+      aopPut (IC_RESULT (ic), zero, 0, 0);
+      emitcode ("", "%05d$:", (tlbl->key + 100));
+      freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+    }
   else
-    emitcode ("push", "psw"); /* save old ea via c in psw on top of stack*/
-
-  if (IC_RESULT (ic))
-    freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+    {
+      emitcode ("setb", "c");
+      emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
+      emitcode ("clr", "c");
+      emitcode ("", "%05d$:", (tlbl->key + 100));
+      emitcode ("push", "psw"); /* save old ea via c in psw on top of stack*/
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -10041,7 +11322,8 @@ genEndCritical (iCode *ic)
         }
       else
         {
-          MOVA (aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
+          if (AOP_TYPE (IC_RIGHT (ic)) != AOP_DUMMY)
+            MOVA (aopGet (IC_RIGHT (ic), 0, FALSE, FALSE));
           emitcode ("rrc", "a");
           emitcode ("mov", "ea,c");
         }
@@ -10090,7 +11372,7 @@ gen51Code (iCode * lic)
         {
           if (options.debug)
             {
-              debugFile->writeCLine(ic);
+              debugFile->writeCLine (ic);
             }
           if (!options.noCcodeInAsm) {
             emitcode ("", ";%s:%d: %s", ic->filename, ic->lineno,
@@ -10264,6 +11546,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;
@@ -10275,7 +11569,7 @@ gen51Code (iCode * lic)
         case GET_VALUE_AT_ADDRESS:
           genPointerGet (ic,
                          hasInc (IC_LEFT (ic), ic,
-			         getSize (operandType (IC_RESULT (ic)))),
+                                 getSize (operandType (IC_RESULT (ic)))),
                          ifxForOp (IC_RESULT (ic), ic) );
           break;