X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fmcs51%2Fgen.c;h=7e61b9de17774c15d138a7921eaf9be969798250;hb=7837c232c608353fb948c183d8e92775f427e5a9;hp=29d1711565a8d20a59fc955718ad481a8ae58c47;hpb=757f865299d9aa9336b99b0ef09f79303a81e76f;p=fw%2Fsdcc

diff --git a/src/mcs51/gen.c b/src/mcs51/gen.c
index 29d17115..7e61b9de 100644
--- a/src/mcs51/gen.c
+++ b/src/mcs51/gen.c
@@ -38,23 +38,6 @@
 #include "SDCCglobl.h"
 #include "newalloc.h"
 
-#ifdef HAVE_SYS_ISA_DEFS_H
-#include <sys/isa_defs.h>
-#else
-#ifdef HAVE_MACHINE_ENDIAN_H
-#include <machine/endian.h>
-#else
-#ifdef HAVE_ENDIAN_H
-#include <endian.h>
-#else
-#if !defined(__BORLANDC__) && !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-#warning "Cannot determine ENDIANESS of this machine assuming LITTLE_ENDIAN"
-#warning "If you running sdcc on an INTEL 80x86 Platform you are okay"
-#endif
-#endif
-#endif
-#endif
-
 #include "common.h"
 #include "SDCCpeeph.h"
 #include "ralloc.h"
@@ -79,7 +62,7 @@ char **fReturn = fReturn8051;
 static char *accUse[] =
 {"a", "b"};
 
-static short rbank = -1;
+static unsigned short rbank = -1;
 
 static struct
   {
@@ -90,9 +73,15 @@ static struct
     short debugLine;
     short nRegsSaved;
     set *sendSet;
+    iCode *current_iCode;
+    symbol *currentFunc;
   }
 _G;
 
+static char *rb1regs[] = {
+    "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7"
+};
+
 extern int mcs51_ptrRegReq;
 extern int mcs51_nRegs;
 extern FILE *codeOutFile;
@@ -101,7 +90,7 @@ static void saveRBank (int, iCode *, bool);
                          (IC_RESULT(x) && IC_RESULT(x)->aop && \
                          IC_RESULT(x)->aop->type == AOP_STK )
 
-#define MOVA(x) if (strcmp(x,"a") && strcmp(x,"acc")) emitcode("mov","a,%s",x);
+#define MOVA(x) mova(x)  /* use function to avoid multiple eval */
 #define CLRC    emitcode("clr","c")
 #define SETC    emitcode("setb","c")
 
@@ -124,7 +113,7 @@ static unsigned char SRMask[] =
 /* emitcode - writes the code into a file : for now it is simple    */
 /*-----------------------------------------------------------------*/
 static void
-emitcode (char *inst, char *fmt,...)
+emitcode (char *inst, const char *fmt,...)
 {
   va_list ap;
   char lb[INITIAL_INLINEASM];
@@ -146,15 +135,32 @@ emitcode (char *inst, char *fmt,...)
   while (isspace (*lbp))
     lbp++;
 
+  //printf ("%s\n", lb);
+  
   if (lbp && *lbp)
     lineCurr = (lineCurr ?
 		connectLine (lineCurr, newLineNode (lb)) :
 		(lineHead = newLineNode (lb)));
   lineCurr->isInline = _G.inLine;
   lineCurr->isDebug = _G.debugLine;
+  lineCurr->ic = _G.current_iCode;
+  lineCurr->isComment = (*lbp==';');
   va_end (ap);
 }
 
+/*-----------------------------------------------------------------*/
+/* mova - moves specified value into accumulator                   */
+/*-----------------------------------------------------------------*/
+static void
+mova (const char *x)
+{
+  /* do some early peephole optimization */
+  if (!strcmp(x, "a") || !strcmp(x, "acc"))
+    return;
+
+  emitcode("mov","a,%s", x);
+}
+
 /*-----------------------------------------------------------------*/
 /* getFreePtr - returns r0 or r1 whichever is free or can be pushed */
 /*-----------------------------------------------------------------*/
@@ -230,22 +236,85 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result)
       (*aopp)->type = AOP_R1;
       return mcs51_regWithIdx (R1_IDX);
     }
-
 endOfWorld:
-  /* I said end of world but not quite end of world yet */
-  /* if this is a result then we can push it on the stack */
-  if (result)
-    {
-      (*aopp)->type = AOP_STK;
-      return NULL;
+  /* I said end of world, but not quite end of world yet */
+  if (result) {
+    /* we can push it on the stack */
+    (*aopp)->type = AOP_STK;
+    return NULL;
+  } else {
+    /* in the case that result AND left AND right needs a pointer reg
+       we can safely use the result's */
+    if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R0_IDX)) {
+      (*aopp)->type = AOP_R0;
+      return mcs51_regWithIdx (R0_IDX);
     }
+    if (bitVectBitValue (mcs51_rUmaskForOp(IC_RESULT(ic)), R1_IDX)) {
+      (*aopp)->type = AOP_R1;
+      return mcs51_regWithIdx (R1_IDX);
+    }
+  }
 
-  /* other wise this is true end of the world */
+  /* now this is REALLY the end of the world */
   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 	  "getFreePtr should never reach here");
   exit (1);
 }
 
+
+/*-----------------------------------------------------------------*/
+/* getTempRegs - initialize an array of pointers to GPR registers */
+/*               that are not in use. Returns 1 if the requested   */
+/*               number of registers were available, 0 otherwise.  */
+/*-----------------------------------------------------------------*/
+int
+getTempRegs(regs **tempRegs, int size, iCode *ic)
+{
+  bitVect * freeRegs;
+  int i;
+  int offset;
+
+  if (!ic)
+    ic = _G.current_iCode;
+  if (!ic)
+    return 0;
+  if (!_G.currentFunc)
+    return 0;
+
+  freeRegs = newBitVect(8);
+  bitVectSetBit (freeRegs, R2_IDX);
+  bitVectSetBit (freeRegs, R3_IDX);
+  bitVectSetBit (freeRegs, R4_IDX);
+  bitVectSetBit (freeRegs, R5_IDX);
+  bitVectSetBit (freeRegs, R6_IDX);
+  bitVectSetBit (freeRegs, R7_IDX);
+
+  if (IFFUNC_CALLEESAVES(_G.currentFunc->type))
+    {
+      bitVect * newfreeRegs;
+      newfreeRegs = bitVectIntersect (freeRegs, _G.currentFunc->regsUsed);
+      freeBitVect(freeRegs);
+      freeRegs = newfreeRegs;
+    }
+  freeRegs = bitVectCplAnd (freeRegs, ic->rMask);
+
+  offset = 0;
+  for (i=0; i<freeRegs->size; i++)
+    {
+      if (bitVectBitValue(freeRegs,i))
+        tempRegs[offset++] = mcs51_regWithIdx(i);
+      if (offset>=size)
+        {
+	  freeBitVect(freeRegs);
+	  return 1;
+	}
+    }
+
+  freeBitVect(freeRegs);
+  return 1;
+}
+
+
 /*-----------------------------------------------------------------*/
 /* newAsmop - creates a new asmOp                                  */
 /*-----------------------------------------------------------------*/
@@ -270,6 +339,74 @@ pointerCode (sym_link * etype)
 
 }
 
+
+/*-----------------------------------------------------------------*/
+/* leftRightUseAcc - returns size of accumulator use by operands   */
+/*-----------------------------------------------------------------*/
+static int
+leftRightUseAcc(iCode *ic)
+{
+  operand *op;
+  int size;
+  int accuseSize = 0;
+  int accuse = 0;
+
+  if (!ic)
+    {
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+	      "null iCode pointer");
+      return 0;
+    }
+
+  if (ic->op == IFX)
+    {
+      op = IC_COND (ic);
+      if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse)
+        {
+          accuse = 1;
+          size = getSize (OP_SYMBOL (op)->type);
+          if (size>accuseSize)
+            accuseSize = size;
+        }
+    }
+  else if (ic->op == JUMPTABLE)
+    {
+      op = IC_JTCOND (ic);
+      if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse)
+        {
+          accuse = 1;
+          size = getSize (OP_SYMBOL (op)->type);
+          if (size>accuseSize)
+            accuseSize = size;
+        }
+    }
+  else
+    {
+      op = IC_LEFT (ic);
+      if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse)
+        {
+          accuse = 1;
+          size = getSize (OP_SYMBOL (op)->type);
+          if (size>accuseSize)
+            accuseSize = size;
+        }
+      op = IC_RIGHT (ic);
+      if (IS_SYMOP (op) && OP_SYMBOL (op) && OP_SYMBOL (op)->accuse)
+        {
+          accuse = 1;
+          size = getSize (OP_SYMBOL (op)->type);
+          if (size>accuseSize)
+            accuseSize = size;
+        }
+    }
+
+  if (accuseSize)
+    return accuseSize;
+  else
+    return accuse;
+}
+
+
 /*-----------------------------------------------------------------*/
 /* aopForSym - for a true symbol                                   */
 /*-----------------------------------------------------------------*/
@@ -304,7 +441,7 @@ aopForSym (iCode * ic, symbol * sym, bool result)
 
 	  if (sym->onStack)
 	    {
-	      if (_G.accInUse)
+	      if (_G.accInUse || leftRightUseAcc (ic))
 		emitcode ("push", "acc");
 
 	      emitcode ("mov", "a,_bp");
@@ -315,7 +452,7 @@ aopForSym (iCode * ic, symbol * sym, bool result)
 	      emitcode ("mov", "%s,a",
 			aop->aopu.aop_ptr->name);
 
-	      if (_G.accInUse)
+	      if (_G.accInUse || leftRightUseAcc (ic))
 		emitcode ("pop", "acc");
 	    }
 	  else
@@ -340,6 +477,9 @@ aopForSym (iCode * ic, symbol * sym, bool result)
   /* if it is in direct space */
   if (IN_DIRSPACE (space))
     {
+      //printf("aopForSym, using AOP_DIR for %s (%x)\n", sym->name, sym);
+      //printTypeChainRaw(sym->type, NULL);
+      //printf("space = %s\n", space ? space->sname : "NULL");
       sym->aop = aop = newAsmop (AOP_DIR);
       aop->aopu.aop_dir = sym->rname;
       aop->size = getSize (sym->type);
@@ -554,7 +694,7 @@ aopOp (operand * op, iCode * ic, bool result)
     }
 
   /* if already has a asmop then continue */
-  if (op->aop && aop->size == getSize(sym->type))
+  if (op->aop )
     return;
 
   /* if the underlying symbol has a aop */
@@ -625,9 +765,21 @@ aopOp (operand * op, iCode * ic, bool result)
 	  return;
 	}
 
-      /* else spill location  */
-      sym->aop = op->aop = aop =
-	aopForSym (ic, sym->usl.spillLoc, result);
+      if (sym->usl.spillLoc)
+        {
+          if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
+            {
+	      /* force a new aop if sizes differ */
+	      sym->usl.spillLoc->aop = NULL;
+	    }
+	  sym->aop = op->aop = aop =
+	             aopForSym (ic, sym->usl.spillLoc, result);
+	  aop->size = getSize (sym->type);
+	  return;
+        }
+
+      /* else must be a dummy iTemp */
+      sym->aop = op->aop = aop = newAsmop (AOP_DUMMY);
       aop->size = getSize (sym->type);
       return;
     }
@@ -691,7 +843,7 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
     case AOP_STK:
       {
 	int sz = aop->size;
-	int stk = aop->aopu.aop_stk + aop->size;
+	int stk = aop->aopu.aop_stk + aop->size - 1;
 	bitVectUnSetBit (ic->rUsed, R0_IDX);
 	bitVectUnSetBit (ic->rUsed, R1_IDX);
 
@@ -718,17 +870,17 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
 	  }
 	op->aop = aop;
 	freeAsmop (op, NULL, ic, TRUE);
-	if (_G.r0Pushed)
-	  {
-	    emitcode ("pop", "ar0");
-	    _G.r0Pushed--;
-	  }
-
 	if (_G.r1Pushed)
 	  {
 	    emitcode ("pop", "ar1");
 	    _G.r1Pushed--;
 	  }
+
+	if (_G.r0Pushed)
+	  {
+	    emitcode ("pop", "ar0");
+	    _G.r0Pushed--;
+	  }
       }
     }
 
@@ -747,6 +899,52 @@ dealloc:
     }
 }
 
+/*-----------------------------------------------------------------*/
+/* aopGetUsesAcc - indicates ahead of time whether aopGet() will   */
+/*                 clobber the accumulator                         */
+/*-----------------------------------------------------------------*/
+static bool
+aopGetUsesAcc (asmop *aop, int offset)
+{
+  if (offset > (aop->size - 1))
+    return FALSE;
+
+  switch (aop->type)
+    {
+
+    case AOP_R0:
+    case AOP_R1:
+      if (aop->paged)
+	return TRUE;
+      return FALSE;
+    case AOP_DPTR:
+      return TRUE;
+    case AOP_IMMD:
+      return FALSE;
+    case AOP_DIR:
+      return FALSE;
+    case AOP_REG:
+      wassert(strcmp(aop->aopu.aop_reg[offset]->name, "a"));
+      return FALSE;
+    case AOP_CRY:
+      return TRUE;
+    case AOP_ACC:
+      return TRUE;
+    case AOP_LIT:
+      return FALSE;
+    case AOP_STR:
+      if (strcmp (aop->aopu.aop_str[offset], "a") == 0)
+	return TRUE;
+      return FALSE;
+    case AOP_DUMMY:
+      return FALSE;
+    default:
+      /* Error case --- will have been caught already */
+      wassert(0);
+      return FALSE;
+    }
+}
+
 /*-----------------------------------------------------------------*/
 /* aopGet - for fetching value of the aop                          */
 /*-----------------------------------------------------------------*/
@@ -765,6 +963,8 @@ aopGet (asmop * aop, int offset, bool bit16, bool dname)
   /* depending on type */
   switch (aop->type)
     {
+    case AOP_DUMMY:
+      return zero;
 
     case AOP_R0:
     case AOP_R1:
@@ -793,6 +993,12 @@ aopGet (asmop * aop, int offset, bool bit16, bool dname)
       return rs;
 
     case AOP_DPTR:
+      if (aop->code && aop->coff==0 && offset>=1) {
+	emitcode ("mov", "a,#0x%02x", offset);
+	emitcode ("movc", "a,@a+dptr");
+	return (dname ? "acc" : "a");
+      }
+
       while (offset > aop->coff)
 	{
 	  emitcode ("inc", "dptr");
@@ -883,7 +1089,7 @@ aopGet (asmop * aop, int offset, bool bit16, bool dname)
 /* aopPut - puts a string for a aop                                */
 /*-----------------------------------------------------------------*/
 static void
-aopPut (asmop * aop, char *s, int offset)
+aopPut (asmop * aop, const char *s, int offset, bool bvolatile)
 {
   char *d = buffer;
 
@@ -898,6 +1104,10 @@ aopPut (asmop * aop, char *s, int offset)
   /* depending on where it is ofcourse */
   switch (aop->type)
     {
+    case AOP_DUMMY:
+      MOVA (s);		/* read s in case it was volatile */
+      break;
+
     case AOP_DIR:
       if (offset)
 	sprintf (d, "(%s + %d)",
@@ -905,7 +1115,8 @@ aopPut (asmop * aop, char *s, int offset)
       else
 	sprintf (d, "%s", aop->aopu.aop_dir);
 
-      if (strcmp (d, s))
+      if (strcmp (d, s) ||
+          bvolatile)
 	emitcode ("mov", "%s,%s", d, s);
 
       break;
@@ -935,7 +1146,7 @@ aopPut (asmop * aop, char *s, int offset)
       if (aop->code)
 	{
 	  werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-		  "aopPut writting to code space");
+		  "aopPut writing to code space");
 	  exit (1);
 	}
 
@@ -1038,11 +1249,8 @@ aopPut (asmop * aop, char *s, int offset)
 		  MOVA (s);
 		}
 	      {
-		symbol *lbl = newiTempLabel (NULL);
-		emitcode ("clr", "c");
-		emitcode ("jz", "%05d$", lbl->key + 100);
-		emitcode ("cpl", "c");
-		emitcode ("", "%05d$:", lbl->key + 100);
+		/* set C, if a >= 1 */
+                emitcode ("add", "a,#0xff");
 		emitcode ("mov", "%s,c", aop->aopu.aop_dir);
 	      }
 	    }
@@ -1051,16 +1259,19 @@ aopPut (asmop * aop, char *s, int offset)
 
     case AOP_STR:
       aop->coff = offset;
-      if (strcmp (aop->aopu.aop_str[offset], s))
+      if (strcmp (aop->aopu.aop_str[offset], s) ||
+          bvolatile)
 	emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
       break;
 
     case AOP_ACC:
       aop->coff = offset;
-      if (!offset && (strcmp (s, "acc") == 0))
+      if (!offset && (strcmp (s, "acc") == 0) &&
+          !bvolatile)
 	break;
 
-      if (strcmp (aop->aopu.aop_str[offset], s))
+      if (strcmp (aop->aopu.aop_str[offset], s) &&
+          !bvolatile)
 	emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
       break;
 
@@ -1140,46 +1351,6 @@ reAdjustPreg (asmop * aop)
                       (x->aopu.aop_reg[0] == mcs51_regWithIdx(R0_IDX) || \
                       x->aopu.aop_reg[0] == mcs51_regWithIdx(R1_IDX) )))
 
-/*-----------------------------------------------------------------*/
-/* genNotFloat - generates not for float operations              */
-/*-----------------------------------------------------------------*/
-static void
-genNotFloat (operand * op, operand * res)
-{
-  int size, offset;
-  char *l;
-  symbol *tlbl;
-
-  D(emitcode (";", "genNotFloat"));
-
-  /* we will put 127 in the first byte of
-     the result */
-  aopPut (AOP (res), "#127", 0);
-  size = AOP_SIZE (op) - 1;
-  offset = 1;
-
-  l = aopGet (op->aop, offset++, FALSE, FALSE);
-  MOVA (l);
-
-  while (size--)
-    {
-      emitcode ("orl", "a,%s",
-		aopGet (op->aop,
-			offset++, FALSE, FALSE));
-    }
-
-  tlbl = newiTempLabel (NULL);
-  aopPut (res->aop, one, 1);
-  emitcode ("jz", "%05d$", (tlbl->key + 100));
-  aopPut (res->aop, zero, 1);
-  emitcode ("", "%05d$:", (tlbl->key + 100));
-
-  size = res->aop->size - 2;
-  offset = 2;
-  /* put zeros in the rest */
-  while (size--)
-    aopPut (res->aop, zero, offset++);
-}
 
 /*-----------------------------------------------------------------*/
 /* opIsGptr: returns non-zero if the passed operand is       */
@@ -1229,13 +1400,13 @@ outAcc (operand * result)
   size = getDataSize (result);
   if (size)
     {
-      aopPut (AOP (result), "a", 0);
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
       size--;
       offset = 1;
       /* unsigned or positive */
       while (size--)
 	{
-	  aopPut (AOP (result), zero, offset++);
+	  aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
 	}
     }
 }
@@ -1248,7 +1419,7 @@ outBitC (operand * result)
 {
   /* if the result is bit */
   if (AOP_TYPE (result) == AOP_CRY)
-    aopPut (AOP (result), "c", 0);
+    aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
   else
     {
       emitcode ("clr", "a");
@@ -1278,9 +1449,8 @@ static void
 genNot (iCode * ic)
 {
   symbol *tlbl;
-  sym_link *optype = operandType (IC_LEFT (ic));
 
-  D(emitcode (";", "genNot"));
+  D(emitcode (";     genNot",""));
 
   /* assign asmOps to operand & result */
   aopOp (IC_LEFT (ic), ic, FALSE);
@@ -1295,13 +1465,6 @@ genNot (iCode * ic)
       goto release;
     }
 
-  /* if type float then do float */
-  if (IS_FLOAT (optype))
-    {
-      genNotFloat (IC_LEFT (ic), IC_RESULT (ic));
-      goto release;
-    }
-
   toBoolean (IC_LEFT (ic));
 
   tlbl = newiTempLabel (NULL);
@@ -1324,23 +1487,42 @@ genCpl (iCode * ic)
 {
   int offset = 0;
   int size;
+  symbol *tlbl;
 
-
-  D(emitcode (";", "genCpl"));
+  D(emitcode (";     genCpl",""));
 
   /* assign asmOps to operand & result */
   aopOp (IC_LEFT (ic), ic, FALSE);
   aopOp (IC_RESULT (ic), ic, TRUE);
 
-  /* if both are in bit space then
-     a special case */
-  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY &&
-      AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
+  /* special case if in bit space */
+  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
     {
+      if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
+	{
+	  emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
+	  emitcode ("cpl", "c");
+	  emitcode ("mov", "%s,c", IC_RESULT (ic)->aop->aopu.aop_dir);
+	  goto release;
+	}
 
-      emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
-      emitcode ("cpl", "c");
-      emitcode ("mov", "%s,c", IC_RESULT (ic)->aop->aopu.aop_dir);
+      tlbl=newiTempLabel(NULL);
+      if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC ||
+	  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);
+	}
+      else
+	{
+	  char *l = aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE);
+	  MOVA (l);
+	  emitcode ("cjne", "a,#0x01,%05d$", tlbl->key + 100);
+	}
+      emitcode ("", "%05d$:", tlbl->key + 100);
+      outBitC (IC_RESULT(ic));
       goto release;
     }
 
@@ -1350,7 +1532,7 @@ genCpl (iCode * ic)
       char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("cpl", "a");
-      aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+      aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
 
@@ -1369,25 +1551,27 @@ genUminusFloat (operand * op, operand * result)
   int size, offset = 0;
   char *l;
 
-  D(emitcode (";", "genUminusFloat"));
-
-  /* for this we just need to flip the
-     first it then copy the rest in place */
-  size = AOP_SIZE (op) - 1;
-  l = aopGet (AOP (op), 3, FALSE, FALSE);
+  D(emitcode (";     genUminusFloat",""));
 
-  MOVA (l);
+  /* for this we just copy and then flip the bit */
 
-  emitcode ("cpl", "acc.7");
-  aopPut (AOP (result), "a", 3);
+  size = AOP_SIZE (op) - 1;
 
   while (size--)
     {
       aopPut (AOP (result),
 	      aopGet (AOP (op), offset, FALSE, FALSE),
-	      offset);
+	      offset,
+	      isOperandVolatile (result, FALSE));
       offset++;
     }
+
+  l = aopGet (AOP (op), offset, FALSE, FALSE);
+
+  MOVA (l);
+
+  emitcode ("cpl", "acc.7");
+  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -1400,7 +1584,7 @@ genUminus (iCode * ic)
   sym_link *optype, *rtype;
 
 
-  D(emitcode (";", "genUminus"));
+  D(emitcode (";     genUminus",""));
 
   /* assign asmops */
   aopOp (IC_LEFT (ic), ic, FALSE);
@@ -1449,7 +1633,7 @@ genUminus (iCode * ic)
 	  emitcode ("clr", "a");
 	  emitcode ("subb", "a,%s", l);
 	}
-      aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+      aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
   /* if any remaining bytes in the result */
@@ -1459,7 +1643,7 @@ genUminus (iCode * ic)
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
-	aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+	aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
 release:
@@ -1491,13 +1675,16 @@ saveRegisters (iCode * lic)
 
   /* if the registers have been saved already or don't need to be then
      do nothing */
-  if (ic->regsSaved || IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type) ||
-      IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT (ic))))
+  if (ic->regsSaved)
+    return;
+  if (IS_SYMOP(IC_LEFT(ic)) &&
+      (IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type) ||
+       IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT (ic)))))
     return;
 
   /* safe the registers in use at this time but skip the
      ones for the result */
-  rsave = bitVectCplAnd (bitVectCopy (ic->rMask), 
+  rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
 			 mcs51_rUmaskForOp (IC_RESULT(ic)));
 
   ic->regsSaved = 1;
@@ -1541,7 +1728,7 @@ unsaveRegisters (iCode * ic)
 
   /* restore the registers in use at this time but skip the
      ones for the result */
-  rsave = bitVectCplAnd (bitVectCopy (ic->rMask), 
+  rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
 			 mcs51_rUmaskForOp (IC_RESULT(ic)));
 
   if (options.useXstack)
@@ -1588,7 +1775,7 @@ pushSide (operand * oper, int size)
 	  AOP_TYPE (oper) != AOP_DIR &&
 	  strcmp (l, "a"))
 	{
-	  emitcode ("mov", "a,%s", l);
+	  MOVA (l);
 	  emitcode ("push", "acc");
 	}
       else
@@ -1606,7 +1793,7 @@ assignResultValue (operand * oper)
   int size = AOP_SIZE (oper);
   while (size--)
     {
-      aopPut (AOP (oper), fReturn[offset], offset);
+      aopPut (AOP (oper), fReturn[offset], offset, isOperandVolatile (oper, FALSE));
       offset++;
     }
 }
@@ -1622,7 +1809,7 @@ genXpush (iCode * ic)
   regs *r;
   int size, offset = 0;
 
-  D(emitcode (";", "genXpush"));
+  D(emitcode (";     genXpush",""));
 
   aopOp (IC_LEFT (ic), ic, FALSE);
   r = getFreePtr (ic, &aop, FALSE);
@@ -1658,7 +1845,7 @@ genIpush (iCode * ic)
   int size, offset = 0;
   char *l;
 
-  D(emitcode (";", "genIpush"));
+  D(emitcode (";     genIpush",""));
 
   /* if this is not a parm push : ie. it is spill push
      and spill push is always done on the local stack */
@@ -1712,7 +1899,7 @@ genIpush (iCode * ic)
 	  AOP_TYPE (IC_LEFT (ic)) != AOP_DIR &&
 	  strcmp (l, "a"))
 	{
-	  emitcode ("mov", "a,%s", l);
+	  MOVA (l);
 	  emitcode ("push", "acc");
 	}
       else
@@ -1730,7 +1917,7 @@ genIpop (iCode * ic)
 {
   int size, offset;
 
-  D(emitcode (";", "genIpop"));
+  D(emitcode (";     genIpop",""));
 
   /* if the temp was not pushed then */
   if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
@@ -1761,16 +1948,16 @@ unsaveRBank (int bank, iCode * ic, bool popPsw)
       if (!ic)
       {
       	  /* Assume r0 is available for use. */
-      	  r = mcs51_regWithIdx (R0_IDX);;          
-      }	
+      	  r = mcs51_regWithIdx (R0_IDX);;
+      }
       else
       {
 	  aop = newAsmop (0);
 	  r = getFreePtr (ic, &aop, FALSE);
       }
-      emitcode ("mov", "%s,_spx", r->name);      
+      emitcode ("mov", "%s,_spx", r->name);
   }
-  
+
   if (popPsw)
     {
       if (options.useXstack)
@@ -1804,11 +1991,11 @@ unsaveRBank (int bank, iCode * ic, bool popPsw)
     {
       emitcode ("mov", "_spx,%s", r->name);
     }
-    
+
   if (aop)
   {
-      freeAsmop (NULL, aop, ic, TRUE);  
-  }    
+      freeAsmop (NULL, aop, ic, TRUE);
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -1874,11 +2061,44 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
     }
 
   if (ic)
-  {  
+  {
       ic->bankSaved = 1;
   }
 }
 
+/*-----------------------------------------------------------------*/
+/* genSend - gen code for SEND	                                   */
+/*-----------------------------------------------------------------*/
+static void genSend(set *sendSet)
+{
+    iCode *sic;
+    int rb1_count = 0 ;
+
+    for (sic = setFirstItem (_G.sendSet); sic;
+	 sic = setNextItem (_G.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);
+    }
+}
+
 /*-----------------------------------------------------------------*/
 /* genCall - generates a call statement                            */
 /*-----------------------------------------------------------------*/
@@ -1886,34 +2106,21 @@ static void
 genCall (iCode * ic)
 {
   sym_link *dtype;
-  bool restoreBank = FALSE;
+//  bool restoreBank = FALSE;
   bool swapBanks = FALSE;
 
-  D(emitcode(";", "genCall"));
+  D(emitcode(";     genCall",""));
 
+  dtype = operandType (IC_LEFT (ic));
   /* if send set is not empty the assign */
   if (_G.sendSet)
     {
-      iCode *sic;
-
-      for (sic = setFirstItem (_G.sendSet); sic;
-	   sic = setNextItem (_G.sendSet))
-	{
-	  int size, offset = 0;
-	  aopOp (IC_LEFT (sic), sic, FALSE);
-	  size = AOP_SIZE (IC_LEFT (sic));
-	  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++;
-	    }
-	  freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+	if (IFFUNC_ISREENT(dtype)) { /* need to reverse the send set */
+	    genSend(reverseSet(_G.sendSet));
+	} else {
+	    genSend(_G.sendSet);
 	}
+
       _G.sendSet = NULL;
     }
 
@@ -1921,28 +2128,20 @@ genCall (iCode * ic)
      the same register bank then we need to save the
      destination registers on the stack */
   dtype = operandType (IC_LEFT (ic));
-  if (dtype && !IFFUNC_ISNAKED(dtype) &&
+  if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
       (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
-      IFFUNC_ISISR (currFunc->type))
+       !IFFUNC_ISISR (dtype))
   {
-      if (!ic->bankSaved) 
-      {
-           /* This is unexpected; the bank should have been saved in
-            * genFunction.
-            */
-    	   saveRBank (FUNC_REGBANK (dtype), ic, FALSE);
-    	   restoreBank = TRUE;
-      }
-      swapBanks = TRUE;  
-  } 
-    
+      swapBanks = TRUE;
+  }
+
   /* if caller saves & we have not saved then */
   if (!ic->regsSaved)
       saveRegisters (ic);
 
   if (swapBanks)
   {
-        emitcode ("mov", "psw,#0x%02x", 
+        emitcode ("mov", "psw,#0x%02x",
            ((FUNC_REGBANK(dtype)) << 3) & 0xff);
   }
 
@@ -1953,14 +2152,14 @@ genCall (iCode * ic)
 
   if (swapBanks)
   {
-       emitcode ("mov", "psw,#0x%02x", 
+       emitcode ("mov", "psw,#0x%02x",
           ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
   }
 
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
-	OP_SYMBOL (IC_RESULT (ic))->accuse || 
+	OP_SYMBOL (IC_RESULT (ic))->accuse ||
 	OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
       IS_TRUE_SYMOP (IC_RESULT (ic)))
     {
@@ -1994,36 +2193,40 @@ genCall (iCode * ic)
   if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
     unsaveRegisters (ic);
 
-  /* if register bank was saved then pop them */
-  if (restoreBank)
-    unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
+//  /* if register bank was saved then pop them */
+//  if (restoreBank)
+//    unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
 }
 
 /*-----------------------------------------------------------------*/
-/* genPcall - generates a call by pointer statement                */
+/* -10l - generates a call by pointer statement                */
 /*-----------------------------------------------------------------*/
 static void
 genPcall (iCode * ic)
 {
   sym_link *dtype;
   symbol *rlbl = newiTempLabel (NULL);
-  bool restoreBank=FALSE;
+//  bool restoreBank=FALSE;
+  bool swapBanks = FALSE;
 
-  D(emitcode(";", "genPCall"));
+  D(emitcode(";     genPCall",""));
 
   /* if caller saves & we have not saved then */
   if (!ic->regsSaved)
     saveRegisters (ic);
 
-  /* if we are calling a function that is not using
+  /* 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 (dtype && !FUNC_ISNAKED(dtype) &&
-      IFFUNC_ISISR (currFunc->type) &&
-      (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype))) {
-    saveRBank (FUNC_REGBANK (dtype), ic, TRUE);
-    restoreBank=TRUE;
+  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
   }
 
   /* push the return address on to the stack */
@@ -2042,33 +2245,27 @@ genPcall (iCode * ic)
   /* if send set is not empty the assign */
   if (_G.sendSet)
     {
-      iCode *sic;
-
-      for (sic = setFirstItem (_G.sendSet); sic;
-	   sic = setNextItem (_G.sendSet))
-	{
-	  int size, offset = 0;
-	  aopOp (IC_LEFT (sic), sic, FALSE);
-	  size = AOP_SIZE (IC_LEFT (sic));
-	  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++;
-	    }
-	  freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
-	}
-      _G.sendSet = NULL;
+	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);
+  }
+
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
@@ -2102,9 +2299,9 @@ genPcall (iCode * ic)
 
     }
 
-  /* if register bank was saved then unsave them */
-  if (restoreBank)
-    unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
+//  /* if register bank was saved then unsave them */
+//  if (restoreBank)
+//    unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
 
   /* if we hade saved some registers then
      unsave them */
@@ -2140,22 +2337,22 @@ resultRemat (iCode * ic)
 /*-----------------------------------------------------------------*/
 /* inExcludeList - return 1 if the string is in exclude Reg list   */
 /*-----------------------------------------------------------------*/
+static int
+regsCmp(void *p1, void *p2)
+{
+  return (STRCASECMP((char *)p1, (char *)(p2)) == 0);
+}
+
 static bool
 inExcludeList (char *s)
 {
-  int i = 0;
+  const char *p = setFirstItem(options.excludeRegsSet);
 
-  if (options.excludeRegs[i] &&
-      STRCASECMP (options.excludeRegs[i], "none") == 0)
+  if (p == NULL || STRCASECMP(p, "none") == 0)
     return FALSE;
 
-  for (i = 0; options.excludeRegs[i]; i++)
-    {
-      if (options.excludeRegs[i] &&
-	  STRCASECMP (s, options.excludeRegs[i]) == 0)
-	return TRUE;
-    }
-  return FALSE;
+
+  return isinSetWith(options.excludeRegsSet, s, regsCmp);
 }
 
 /*-----------------------------------------------------------------*/
@@ -2164,29 +2361,30 @@ inExcludeList (char *s)
 static void
 genFunction (iCode * ic)
 {
-  symbol *sym;
+  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;
 
   _G.nRegsSaved = 0;
   /* create the function header */
   emitcode (";", "-----------------------------------------");
-  emitcode (";", " function %s", (sym = OP_SYMBOL (IC_LEFT (ic)))->name);
+  emitcode (";", " function %s", sym->name);
   emitcode (";", "-----------------------------------------");
 
   emitcode ("", "%s:", sym->rname);
   ftype = operandType (IC_LEFT (ic));
+  _G.currentFunc = sym;
 
   if (IFFUNC_ISNAKED(ftype))
   {
       emitcode(";", "naked function: no prologue.");
       return;
   }
-
-  /* if critical function then turn interrupts off */
-  if (IFFUNC_ISCRITICAL (ftype))
-    emitcode ("clr", "ea");
-
+  
   /* here we need to generate the equates for the
      register bank if required */
   if (FUNC_REGBANK (ftype) != rbank)
@@ -2240,19 +2438,24 @@ genFunction (iCode * ic)
 		  /* save the registers used */
 		  for (i = 0; i < sym->regsUsed->size; i++)
 		    {
-		      if (bitVectBitValue (sym->regsUsed, i) ||
-			  (mcs51_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
+		      if (bitVectBitValue (sym->regsUsed, i))
 			emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
 		    }
 		}
-
 	    }
 	  else
 	    {
-	      /* this function has  a function call cannot
+
+	      /* this function has a function call. We cannot
 	         determines register usage so we will have to push the
 	         entire bank */
-	      saveRBank (0, ic, FALSE);
+		saveRBank (0, ic, FALSE);
+		if (options.parms_in_bank1) {
+		    int i;
+		    for (i=0; i < 8 ; i++ ) {
+			emitcode ("push","%s",rb1regs[i]);
+		    }
+		}
 	    }
 	}
 	else
@@ -2266,7 +2469,7 @@ genFunction (iCode * ic)
 	     * other bank, we must save that bank entirely.
 	     */
 	    unsigned long banksToSave = 0;
-	    
+
 	    if (IFFUNC_HASFCALL(sym->type))
 	    {
 
@@ -2282,11 +2485,11 @@ genFunction (iCode * ic)
 	                /* we got to the end OK. */
 	                break;
 	            }
-	            
+
 	            if (i->op == CALL)
 	            {
 	                sym_link *dtype;
-	                
+
 	                dtype = operandType (IC_LEFT(i));
 	                if (dtype
 	                 && FUNC_REGBANK(dtype) != FUNC_REGBANK(sym->type))
@@ -2300,8 +2503,8 @@ genFunction (iCode * ic)
 	                     {
 	                         banksToSave |= (1 << FUNC_REGBANK(dtype));
 	                     }
-	                     
-	                     /* And note that we don't need to do it in 
+
+	                     /* And note that we don't need to do it in
 	                      * genCall.
 	                      */
 	                     i->bankSaved = 1;
@@ -2316,24 +2519,24 @@ genFunction (iCode * ic)
 	             	 * The only thing I can think of to do is
 	             	 * throw a warning and hope.
 	             	 */
-	             	werror(W_FUNCPTR_IN_USING_ISR);   
+	             	werror(W_FUNCPTR_IN_USING_ISR);
 	            }
 	        }
 
 		if (banksToSave && options.useXstack)
 		{
-		    /* Since we aren't passing it an ic, 
+		    /* Since we aren't passing it an ic,
 		     * saveRBank will assume r0 is available to abuse.
 		     *
 		     * So switch to our (trashable) bank now, so
 		     * the caller's R0 isn't trashed.
 		     */
 		    emitcode ("push", "psw");
-		    emitcode ("mov", "psw,#0x%02x", 
+		    emitcode ("mov", "psw,#0x%02x",
 		    	      (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
 		    switchedPSW = TRUE;
 		}
-		
+
 	        for (ix = 0; ix < MAX_REGISTER_BANKS; ix++)
 	        {
 	             if (banksToSave & (1 << ix))
@@ -2342,12 +2545,23 @@ genFunction (iCode * ic)
 	             }
 	        }
 	    }
-	    // jwk: this needs a closer look
+	    // TODO: this needs a closer look
 	    SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
 	}
+      
+      /* Set the register bank to the desired value if nothing else */
+      /* has done so yet. */
+      if (!switchedPSW)
+        {
+          emitcode ("push", "psw");
+          emitcode ("mov", "psw,#0x%02x", (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
+        }
     }
   else
     {
+      /* This is a non-ISR function. The caller has already switched register */
+      /* banks, if necessary, so just handle the callee-saves option. */
+      
       /* if callee-save to be used for this function
          then save the registers being used in this function */
       if (IFFUNC_CALLEESAVES(sym->type))
@@ -2360,9 +2574,11 @@ genFunction (iCode * ic)
 	      /* save the registers used */
 	      for (i = 0; i < sym->regsUsed->size; i++)
 		{
-		  if (bitVectBitValue (sym->regsUsed, i) ||
-		      (mcs51_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
+		  if (bitVectBitValue (sym->regsUsed, i))
 		    {
+		      /* remember one saved register for later usage */
+		      if (calleesaves_saved_register < 0)
+		        calleesaves_saved_register = i;
 		      emitcode ("push", "%s", mcs51_regWithIdx (i)->dname);
 		      _G.nRegsSaved++;
 		    }
@@ -2371,23 +2587,20 @@ genFunction (iCode * ic)
 	}
     }
 
-  /* set the register bank to the desired value */
-  if ((FUNC_REGBANK (sym->type) || IFFUNC_ISISR (sym->type))
-   && !switchedPSW)
-    {
-      emitcode ("push", "psw");
-      emitcode ("mov", "psw,#0x%02x", (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
-    }
 
   if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
     {
 
       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");
 	}
       else
 	{
@@ -2396,16 +2609,76 @@ genFunction (iCode * ic)
 	}
       emitcode ("mov", "_bp,%s", spname);
     }
-
+  
+  /* For some cases it is worthwhile to perform a RECEIVE iCode */
+  /* before setting up the stack frame completely. */
+  if (ric && ric->argreg == 1 && IC_RESULT (ric))
+    {
+      symbol * rsym = OP_SYMBOL (IC_RESULT (ric));
+      
+      if (rsym->isitmp)
+        {
+	  if (rsym && rsym->regType == REG_CND)
+	    rsym = NULL;
+	  if (rsym && (rsym->accuse || rsym->ruonly))
+	    rsym = NULL;
+          if (rsym && (rsym->isspilt || rsym->nRegs == 0) && rsym->usl.spillLoc)
+            rsym = rsym->usl.spillLoc;
+	}
+      
+      /* If the RECEIVE operand immediately spills to the first entry on the */
+      /* stack, we can push it directly (since sp = _bp + 1 at this point) */
+      /* rather than the usual @r0/r1 machinations. */
+      if (!options.useXstack && rsym && rsym->onStack && rsym->stack == 1)
+        {
+	  int ofs;
+	  
+	  _G.current_iCode = ric;
+	  D(emitcode (";     genReceive",""));
+	  for (ofs=0; ofs < sym->recvSize; ofs++)
+	    {
+	      if (!strcmp (fReturn[ofs], "a"))
+	        emitcode ("push", "acc");
+	      else
+	        emitcode ("push", fReturn[ofs]);
+	    }
+	  stackAdjust -= sym->recvSize;
+	  if (stackAdjust<0)
+	    {
+	      assert (stackAdjust>=0);
+	      stackAdjust = 0;
+	    }
+	  _G.current_iCode = ic;
+	  ric->generated = 1;
+	  accIsFree = 1;
+	}
+      /* If the RECEIVE operand is 4 registers, we can do the moves now */
+      /* to free up the accumulator. */
+      else if (rsym && rsym->nRegs && sym->recvSize == 4)
+        {
+	  int ofs;
+	  
+	  _G.current_iCode = ric;
+	  D(emitcode (";     genReceive",""));
+	  for (ofs=0; ofs < sym->recvSize; ofs++)
+	    {
+	      emitcode ("mov", "%s,%s", rsym->regs[ofs]->name, fReturn[ofs]);
+	    }
+	  _G.current_iCode = ic;
+	  ric->generated = 1;
+	  accIsFree = 1;
+	}
+    }
+  
   /* adjust the stack for the function */
-  if (sym->stack)
+  if (stackAdjust)
     {
 
-      int i = sym->stack;
+      int i = stackAdjust;
       if (i > 256)
 	werror (W_STACK_OVERFLOW, sym->name);
 
-      if (i > 3 && sym->recvSize < 4)
+      if (i > 3 && accIsFree)
 	{
 
 	  emitcode ("mov", "a,sp");
@@ -2413,6 +2686,39 @@ genFunction (iCode * ic)
 	  emitcode ("mov", "sp,a");
 
 	}
+      else if (i > 5)
+        {
+	  /* The accumulator is not free, so we will need another register */
+	  /* to clobber. No need to worry about a possible conflict with */
+	  /* the above early RECEIVE optimizations since they would have */
+	  /* freed the accumulator if they were generated. */
+	  
+	  if (IFFUNC_CALLEESAVES(sym->type))
+	    {
+	      /* if it's a callee-saves function we need a saved register */
+	      if (calleesaves_saved_register >= 0)
+		{
+		  emitcode ("mov", "%s,a", mcs51_regWithIdx (calleesaves_saved_register)->dname);
+		  emitcode ("mov", "a,sp");
+		  emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
+		  emitcode ("mov", "sp,a");
+		  emitcode ("mov", "a,%s", mcs51_regWithIdx (calleesaves_saved_register)->dname);
+		}
+	      else
+		/* do it the hard way */
+		while (i--)
+		  emitcode ("inc", "sp");
+	    }
+	  else
+	    {
+	      /* not callee-saves, we can clobber r0 */
+	      emitcode ("mov", "r0,a");
+	      emitcode ("mov", "a,sp");
+	      emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
+	      emitcode ("mov", "sp,a");
+	      emitcode ("mov", "a,r0");
+	    }
+	}
       else
 	while (i--)
 	  emitcode ("inc", "sp");
@@ -2421,11 +2727,25 @@ genFunction (iCode * ic)
   if (sym->xstack)
     {
 
+      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 critical function then turn interrupts off */
+  if (IFFUNC_ISCRITICAL (ftype))
+    {
+      symbol *tlbl = newiTempLabel (NULL);
+      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 */
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -2435,13 +2755,25 @@ static void
 genEndFunction (iCode * ic)
 {
   symbol *sym = OP_SYMBOL (IC_LEFT (ic));
-
+  lineNode *lnp = lineCurr;
+  bitVect *regsUsed;
+  bitVect *regsUsedPrologue;
+  bitVect *regsUnneeded;
+  int idx;
+  
+  _G.currentFunc = NULL;
   if (IFFUNC_ISNAKED(sym->type))
   {
       emitcode(";", "naked function: no epilogue.");
       return;
   }
 
+  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);
@@ -2474,9 +2806,9 @@ genEndFunction (iCode * ic)
     }
 
   /* restore the register bank  */
-  if (FUNC_REGBANK (sym->type) || IFFUNC_ISISR (sym->type))
+  if ( /* FUNC_REGBANK (sym->type) || */ IFFUNC_ISISR (sym->type))
   {
-    if (!FUNC_REGBANK (sym->type) || !IFFUNC_ISISR (sym->type)
+    if (/* !FUNC_REGBANK (sym->type) || */ !IFFUNC_ISISR (sym->type)
      || !options.useXstack)
     {
         /* Special case of ISR using non-zero bank with useXstack
@@ -2508,15 +2840,19 @@ genEndFunction (iCode * ic)
 		  /* save the registers used */
 		  for (i = sym->regsUsed->size; i >= 0; i--)
 		    {
-		      if (bitVectBitValue (sym->regsUsed, i) ||
-			  (mcs51_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
+		      if (bitVectBitValue (sym->regsUsed, i))
 			emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
 		    }
 		}
-
 	    }
 	  else
 	    {
+	      if (options.parms_in_bank1) {
+		  int i;
+		  for (i = 7 ; i >= 0 ; i-- ) {
+		      emitcode ("pop","%s",rb1regs[i]);
+		  }
+	      }
 	      /* this function has  a function call cannot
 	         determines register usage so we will have to pop the
 	         entire bank */
@@ -2530,10 +2866,9 @@ genEndFunction (iCode * ic)
 	     * Restore any register banks saved by genFunction
 	     * in reverse order.
 	     */
-	  // jwk: this needs a closer look
 	    unsigned savedBanks = SPEC_ISR_SAVED_BANKS(currFunc->etype);
 	    int ix;
-	  
+
 	    for (ix = MAX_REGISTER_BANKS - 1; ix >= 0; ix--)
 	    {
 	        if (savedBanks & (1 << ix))
@@ -2541,7 +2876,7 @@ genEndFunction (iCode * ic)
 	            unsaveRBank(ix, NULL, FALSE);
 	        }
 	    }
-	    
+
 	    if (options.useXstack)
 	    {
 	    	/* Restore bank AFTER calling unsaveRBank,
@@ -2560,11 +2895,7 @@ genEndFunction (iCode * ic)
       if (!inExcludeList ("acc"))
 	emitcode ("pop", "acc");
 
-      if (IFFUNC_ISCRITICAL (sym->type))
-	emitcode ("setb", "ea");
-
       /* if debug then send end of function */
-      /*  if (options.debug && currFunc)  */
       if (options.debug && currFunc)
 	{
 	  _G.debugLine = 1;
@@ -2582,9 +2913,6 @@ genEndFunction (iCode * ic)
     }
   else
     {
-      if (IFFUNC_ISCRITICAL (sym->type))
-	emitcode ("setb", "ea");
-
       if (IFFUNC_CALLEESAVES(sym->type))
 	{
 	  int i;
@@ -2600,6 +2928,11 @@ genEndFunction (iCode * ic)
 		    emitcode ("pop", "%s", mcs51_regWithIdx (i)->dname);
 		}
 	    }
+          else if (mcs51_ptrRegReq)
+	    {
+	      emitcode ("pop", "%s", mcs51_regWithIdx (R1_IDX)->dname);
+	      emitcode ("pop", "%s", mcs51_regWithIdx (R0_IDX)->dname);
+	    }
 
 	}
 
@@ -2620,6 +2953,99 @@ genEndFunction (iCode * ic)
       emitcode ("ret", "");
     }
 
+  if (!port->peep.getRegsRead || !port->peep.getRegsWritten)
+    return;
+  
+  /* If this was an interrupt handler using bank 0 that called another */
+  /* function, then all registers must be saved; nothing to optimized. */
+  if (IFFUNC_ISISR (sym->type) && IFFUNC_HASFCALL(sym->type)
+      && !FUNC_REGBANK(sym->type))
+    return;
+
+  /* There are no push/pops to optimize if not callee-saves or ISR */
+  if (!(FUNC_CALLEESAVES (sym->type) || FUNC_ISISR (sym->type)))
+    return;
+  
+  /* If there were stack parameters, we cannot optimize without also    */
+  /* fixing all of the stack offsets; this is too dificult to consider. */
+  if (FUNC_HASSTACKPARM(sym->type))
+    return;
+    
+  /* Compute the registers actually used */
+  regsUsed = newBitVect (mcs51_nRegs);
+  regsUsedPrologue = newBitVect (mcs51_nRegs);
+  while (lnp)
+    {
+      if (lnp->ic && lnp->ic->op == FUNCTION)
+        regsUsedPrologue = bitVectUnion (regsUsedPrologue, port->peep.getRegsWritten(lnp));
+      else
+        regsUsed = bitVectUnion (regsUsed, port->peep.getRegsWritten(lnp));
+      
+      if (lnp->ic && lnp->ic->op == FUNCTION && lnp->prev
+          && lnp->prev->ic && lnp->prev->ic->op == ENDFUNCTION)
+	break;
+      if (!lnp->prev)
+        break;
+      lnp = lnp->prev;
+    }
+
+  if (bitVectBitValue (regsUsedPrologue, CND_IDX)
+      && !bitVectBitValue (regsUsed, CND_IDX))
+    {
+      regsUsed = bitVectUnion (regsUsed, regsUsedPrologue);
+      if (IFFUNC_ISISR (sym->type) && !FUNC_REGBANK(sym->type)
+          && !sym->stack)
+        bitVectUnSetBit (regsUsed, CND_IDX);
+    }
+  else
+    regsUsed = bitVectUnion (regsUsed, regsUsedPrologue);
+    
+  /* If this was an interrupt handler that called another function */
+  /* function, then assume A, B, DPH, & DPL may be modified by it. */
+  if (IFFUNC_ISISR (sym->type) && IFFUNC_HASFCALL(sym->type))
+    {
+      regsUsed = bitVectSetBit (regsUsed, DPL_IDX);
+      regsUsed = bitVectSetBit (regsUsed, DPH_IDX);
+      regsUsed = bitVectSetBit (regsUsed, B_IDX);
+      regsUsed = bitVectSetBit (regsUsed, A_IDX);
+      regsUsed = bitVectSetBit (regsUsed, CND_IDX);
+    }
+
+  /* Remove the unneeded push/pops */
+  regsUnneeded = newBitVect (mcs51_nRegs);
+  while (lnp)
+    {
+      if (lnp->ic && (lnp->ic->op == FUNCTION || lnp->ic->op == ENDFUNCTION))
+        {
+	  if (!strncmp(lnp->line, "push", 4))
+	    {
+	      idx = bitVectFirstBit (port->peep.getRegsRead(lnp));
+	      if (idx>=0 && !bitVectBitValue (regsUsed, idx))
+	        {
+	          connectLine (lnp->prev, lnp->next);
+		  regsUnneeded = bitVectSetBit (regsUnneeded, idx);
+		}
+	    }
+	  if (!strncmp(lnp->line, "pop", 3) || !strncmp(lnp->line, "mov", 3))
+	    {
+	      idx = bitVectFirstBit (port->peep.getRegsWritten(lnp));
+	      if (idx>=0 && !bitVectBitValue (regsUsed, idx))
+	        {
+		  connectLine (lnp->prev, lnp->next);
+		  regsUnneeded = bitVectSetBit (regsUnneeded, idx);
+		}
+	    }
+	}
+      lnp = lnp->next;
+    }  
+  
+  for (idx = 0; idx < regsUnneeded->size; idx++)
+    if (bitVectBitValue (regsUnneeded, idx))
+      emitcode ("", ";\teliminated unneeded push/pop %s", mcs51_regWithIdx (idx)->dname);
+  
+  freeBitVect (regsUnneeded);
+  freeBitVect (regsUsed);
+  freeBitVect (regsUsedPrologue);
 }
 
 /*-----------------------------------------------------------------*/
@@ -2630,7 +3056,7 @@ genRet (iCode * ic)
 {
   int size, offset = 0, pushed = 0;
 
-  D(emitcode (";", "genRet"));
+  D(emitcode (";     genRet",""));
 
   /* if we have no return value then
      just generate the "ret" */
@@ -2723,9 +3149,15 @@ findLabelBackwards (iCode * ic, int key)
       ic = ic->prev;
       count++;
 
+      /* If we have any pushes or pops, we cannot predict the distance.
+	 I don't like this at all, this should be dealt with in the
+	 back-end */
+      if (ic->op == IPUSH || ic->op == IPOP) {
+	return 0;
+      }
+
       if (ic->op == LABEL && IC_LABEL (ic)->key == key)
 	{
-	  /* printf("findLabelBackwards = %d\n", count); */
 	  return count;
 	}
     }
@@ -2753,10 +3185,11 @@ genPlusIncr (iCode * ic)
   if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
     return FALSE;
 
-  D(emitcode (";", "genPlusIncr"));
+  D(emitcode (";     genPlusIncr",""));
 
-  /* if increment 16 bits in register */
-  if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
+  /* 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))) &&
       (size > 1) &&
       (icount == 1))
     {
@@ -2784,15 +3217,15 @@ genPlusIncr (iCode * ic)
       emitcode ("inc", "%s", aopGet (AOP (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)
-		  ,tlbl->key + 100);
+	emitcode ("cjne", "%s,#0x00,%05d$",
+		  aopGet (AOP (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)
-		    ,tlbl->key + 100);
+	  emitcode ("cjne", "a,%s,%05d$",
+		    aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE),
+		    tlbl->key + 100);
 	}
 
       emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE));
@@ -2800,13 +3233,13 @@ genPlusIncr (iCode * ic)
 	{
 	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0x00,%05d$"
-		      ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE)
-		      ,tlbl->key + 100);
+	    emitcode ("cjne", "%s,#0x00,%05d$",
+		      aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
+		      tlbl->key + 100);
 	  else
-	    emitcode ("cjne", "a,%s,%05d$"
-		      ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE)
-		      ,tlbl->key + 100);
+	    emitcode ("cjne", "a,%s,%05d$",
+		      aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE),
+		      tlbl->key + 100);
 
 	  emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE));
 	}
@@ -2814,14 +3247,14 @@ genPlusIncr (iCode * ic)
 	{
 	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0x00,%05d$"
-		      ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE)
-		      ,tlbl->key + 100);
+	    emitcode ("cjne", "%s,#0x00,%05d$",
+		      aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
+		      tlbl->key + 100);
 	  else
 	    {
-	      emitcode ("cjne", "a,%s,%05d$"
-			,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE)
-			,tlbl->key + 100);
+	      emitcode ("cjne", "a,%s,%05d$",
+			aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE),
+			tlbl->key + 100);
 	    }
 	  emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE));
 	}
@@ -2848,7 +3281,7 @@ genPlusIncr (iCode * ic)
 	{
 	  MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE));
 	  emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff);
-	  aopPut (AOP (IC_RESULT (ic)), "a", 0);
+	  aopPut (AOP (IC_RESULT (ic)), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
 	}
       else
 	{
@@ -2873,7 +3306,7 @@ outBitAcc (operand * result)
   /* if the result is a bit */
   if (AOP_TYPE (result) == AOP_CRY)
     {
-      aopPut (AOP (result), "a", 0);
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
     }
   else
     {
@@ -2890,7 +3323,7 @@ outBitAcc (operand * result)
 static void
 genPlusBits (iCode * ic)
 {
-  D(emitcode (";", "genPlusBits"));
+  D(emitcode (";     genPlusBits",""));
 
   if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
     {
@@ -2926,14 +3359,16 @@ adjustArithmeticResult (iCode * ic)
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
     aopPut (AOP (IC_RESULT (ic)),
 	    aopGet (AOP (IC_LEFT (ic)), 2, FALSE, FALSE),
-	    2);
+	    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),
-	    2);
+	    2,
+	    isOperandVolatile (IC_RESULT (ic), FALSE));
 
   if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
       AOP_SIZE (IC_LEFT (ic)) < 3 &&
@@ -2943,7 +3378,7 @@ adjustArithmeticResult (iCode * ic)
     {
       char buffer[5];
       sprintf (buffer, "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
-      aopPut (AOP (IC_RESULT (ic)), buffer, 2);
+      aopPut (AOP (IC_RESULT (ic)), buffer, 2, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 }
 #else
@@ -2960,7 +3395,8 @@ adjustArithmeticResult (iCode * ic)
     {
       aopPut (AOP (IC_RESULT (ic)),
 	      aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE),
-	      GPTRSIZE - 1);
+	      GPTRSIZE - 1,
+	      isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
   if (opIsGptr (IC_RESULT (ic)) &&
@@ -2969,7 +3405,8 @@ adjustArithmeticResult (iCode * ic)
     {
       aopPut (AOP (IC_RESULT (ic)),
 	      aopGet (AOP (IC_RIGHT (ic)), GPTRSIZE - 1, FALSE, FALSE),
-	      GPTRSIZE - 1);
+	      GPTRSIZE - 1,
+	      isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
   if (opIsGptr (IC_RESULT (ic)) &&
@@ -2980,7 +3417,7 @@ adjustArithmeticResult (iCode * ic)
     {
       char buffer[5];
       sprintf (buffer, "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
-      aopPut (AOP (IC_RESULT (ic)), buffer, GPTRSIZE - 1);
+      aopPut (AOP (IC_RESULT (ic)), buffer, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 }
 #endif
@@ -2992,10 +3429,14 @@ static void
 genPlus (iCode * ic)
 {
   int size, offset = 0;
+  int skip_bytes = 0;
+  char *add = "add";
+  asmop *leftOp, *rightOp;
+  operand * op;
 
   /* special cases :- */
 
-  D(emitcode (";", "genPlus"));
+  D(emitcode (";     genPlus",""));
 
   aopOp (IC_LEFT (ic), ic, FALSE);
   aopOp (IC_RIGHT (ic), ic, FALSE);
@@ -3041,7 +3482,7 @@ genPlus (iCode * ic)
 	    {
 	      MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
 	      emitcode ("addc", "a,#00");
-	      aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+	      aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
 	    }
 	}
       goto release;
@@ -3053,30 +3494,92 @@ genPlus (iCode * ic)
     goto release;
 
   size = getDataSize (IC_RESULT (ic));
+  leftOp = AOP(IC_LEFT(ic));
+  rightOp = AOP(IC_RIGHT(ic));
+  op=IC_LEFT(ic);
+
+  /* if this is an add for an array access
+     at a 256 byte boundary */
+  if ( 2 == size
+       && AOP_TYPE (op) == AOP_IMMD
+       && IS_SYMOP (op)
+       && IS_SPEC (OP_SYM_ETYPE (op))
+       && SPEC_ABSA (OP_SYM_ETYPE (op))
+       && (SPEC_ADDR (OP_SYM_ETYPE (op)) & 0xff) == 0
+     )
+    {
+      D(emitcode (";     genPlus aligned array",""));
+      aopPut (AOP (IC_RESULT (ic)),
+ 	      aopGet (rightOp, 0, FALSE, FALSE),
+ 	      0,
+ 	      isOperandVolatile (IC_RESULT (ic), FALSE));
 
-  while (size--)
-    {
-      if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC)
+      if( 1 == getDataSize (IC_RIGHT (ic)) )
 	{
-	  MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
-	  if (offset == 0)
-	    emitcode ("add", "a,%s",
-		      aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
-	  else
-	    emitcode ("addc", "a,%s",
-		      aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
+	  aopPut (AOP (IC_RESULT (ic)),
+		  aopGet (leftOp, 1, FALSE, FALSE),
+		  1,
+		  isOperandVolatile (IC_RESULT (ic), FALSE));
 	}
       else
-	{
-	  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
-	  if (offset == 0)
-	    emitcode ("add", "a,%s",
-		      aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
+        {
+	  MOVA (aopGet (AOP (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));
+	}
+      goto release;
+    }
+
+  /* if the lower bytes of a literal are zero skip the addition */
+  if (AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT )
+    {
+       while ((0 == ((unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) & (0xff << skip_bytes*8))) &&
+              (skip_bytes+1 < size))
+         {
+           skip_bytes++;
+	 }
+       if (skip_bytes)
+         D(emitcode (";     genPlus shortcut",""));
+    }
+
+  while (size--)
+    {
+      if( offset >= skip_bytes )
+        {
+	  if (aopGetUsesAcc (leftOp, offset) && aopGetUsesAcc (rightOp, offset))
+	    {
+	      emitcode("mov", "b,a");
+	      MOVA (aopGet (leftOp,  offset, FALSE, TRUE));
+	      emitcode("xch", "a,b");
+	      MOVA (aopGet (rightOp, offset, FALSE, TRUE));
+	      emitcode (add, "a,b");
+	    }
+	  else if (aopGetUsesAcc (leftOp, offset))
+	    {
+	      MOVA (aopGet (leftOp, offset, FALSE, TRUE));
+	      emitcode (add, "a,%s", aopGet (rightOp, offset, FALSE, TRUE));
+	    }
 	  else
-	    emitcode ("addc", "a,%s",
-		      aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
+	    {
+	      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));
+	  add = "addc";  /* further adds must propagate carry */
+        }
+      else
+        {
+          if( !sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) ||
+	      isOperandVolatile (IC_RESULT (ic), FALSE))
+	    {
+	      /* just move */
+              aopPut (AOP (IC_RESULT (ic)),
+		      aopGet (leftOp, offset, FALSE, FALSE),
+		      offset,
+		      isOperandVolatile (IC_RESULT (ic), FALSE));
+	    }
 	}
-      aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+      offset++;
     }
 
   adjustArithmeticResult (ic);
@@ -3107,10 +3610,11 @@ genMinusDec (iCode * ic)
   if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
     return FALSE;
 
-  D(emitcode (";", "genMinusDec"));
+  D(emitcode (";     genMinusDec",""));
 
-  /* if decrement 16 bits in register */
-  if (sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))) &&
+  /* if decrement >=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))) &&
       (size > 1) &&
       (icount == 1))
     {
@@ -3221,11 +3725,11 @@ addSign (operand * result, int offset, int sign)
 	  emitcode ("rlc", "a");
 	  emitcode ("subb", "a,acc");
 	  while (size--)
-	    aopPut (AOP (result), "a", offset++);
+	    aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
 	}
       else
 	while (size--)
-	  aopPut (AOP (result), zero, offset++);
+	  aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
     }
 }
 
@@ -3237,7 +3741,7 @@ genMinusBits (iCode * ic)
 {
   symbol *lbl = newiTempLabel (NULL);
 
-  D(emitcode (";", "genMinusBits"));
+  D(emitcode (";     genMinusBits",""));
 
   if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
     {
@@ -3254,7 +3758,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);
+      aopPut (AOP (IC_RESULT (ic)), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
       addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
     }
 }
@@ -3266,9 +3770,8 @@ static void
 genMinus (iCode * ic)
 {
   int size, offset = 0;
-  unsigned long lit = 0L;
 
-  D(emitcode (";", "genMinus"));
+  D(emitcode (";     genMinus",""));
 
   aopOp (IC_LEFT (ic), ic, FALSE);
   aopOp (IC_RIGHT (ic), ic, FALSE);
@@ -3290,41 +3793,62 @@ genMinus (iCode * ic)
 
   size = getDataSize (IC_RESULT (ic));
 
-  if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
-    {
-      CLRC;
-    }
-  else
+  /* if literal, add a,#-lit, else normal subb */
+  if (AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT)
     {
+      unsigned long lit = 0L;
+
       lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
       lit = -(long) lit;
-    }
 
-  /* if literal, add a,#-lit, else normal subb */
-  while (size--)
-    {
-      MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
-      if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
-	emitcode ("subb", "a,%s",
-		  aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE));
-      else
+      while (size--)
 	{
+	  MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE));
 	  /* first add without previous c */
 	  if (!offset) {
-	    if (!size && lit==-1) {
+	    if (!size && lit== (unsigned long) -1) {
 	      emitcode ("dec", "a");
 	    } else {
-	      emitcode ("add", "a,#0x%02x", 
+	      emitcode ("add", "a,#0x%02x",
 			(unsigned int) (lit & 0x0FFL));
 	    }
 	  } 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;
+
+      leftOp = AOP(IC_LEFT(ic));
+      rightOp = AOP(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");
+	    }
+	    emitcode("subb", "a,%s", aopGet(leftOp, offset, FALSE, TRUE));
+	    emitcode("cpl", "a");
+	  } else {
+	    MOVA (aopGet (leftOp, offset, FALSE, FALSE));
+	    if (offset == 0)
+	      CLRC;
+	    emitcode ("subb", "a,%s",
+		      aopGet(rightOp, offset, FALSE, TRUE));
+	  }
+
+	  aopPut (AOP (IC_RESULT (ic)), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
 	}
-      aopPut (AOP (IC_RESULT (ic)), "a", offset++);
     }
 
+
   adjustArithmeticResult (ic);
 
 release:
@@ -3342,14 +3866,13 @@ genMultbits (operand * left,
 	     operand * right,
 	     operand * result)
 {
-  D(emitcode (";", "genMultbits"));
+  D(emitcode (";     genMultbits",""));
 
   emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
   emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
   outBitC (result);
 }
 
-
 /*-----------------------------------------------------------------*/
 /* genMultOneByte : 8*8=8/16 bit multiplication                    */
 /*-----------------------------------------------------------------*/
@@ -3358,18 +3881,20 @@ genMultOneByte (operand * left,
 		operand * right,
 		operand * result)
 {
-  sym_link *opetype = operandType (result);
   symbol *lbl;
-  int size=AOP_SIZE(result);
+  int size = AOP_SIZE (result);
+  bool runtimeSign, compiletimeSign;
+  bool lUnsigned, rUnsigned;
 
-  D(emitcode (";", "genMultOneByte"));
+  D(emitcode (";     genMultOneByte",""));
 
-  if (size<1 || size>2) {
-    // this should never happen
-      fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n", 
+  if (size < 1 || size > 2)
+    {
+      /* this should never happen */
+      fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n",
 	       AOP_SIZE(result), __FILE__, lineno);
       exit (1);
-  }
+    }
 
   /* (if two literals: the value is computed before) */
   /* if one literal, literal on the right */
@@ -3378,82 +3903,171 @@ genMultOneByte (operand * left,
       operand *t = right;
       right = left;
       left = t;
-      //emitcode (";", "swapped left and right");
-    }
-
-  if (SPEC_USIGN(opetype)
-      // ignore the sign of left and right, what else can we do?
-      || (SPEC_USIGN(operandType(left)) && 
-	  SPEC_USIGN(operandType(right)))) {
-    // just an unsigned 8*8=8/16 multiply
-    //emitcode (";","unsigned");
-    emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-    MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
-    emitcode ("mul", "ab");
-    aopPut (AOP (result), "a", 0);
-    if (size==2) {
-      aopPut (AOP (result), "b", 1);
+      /* emitcode (";", "swapped left and right"); */
+    }
+  /* if no literal, unsigned on the right: shorter code */
+  if (   AOP_TYPE (right) != AOP_LIT
+      && SPEC_USIGN (getSpec (operandType (left))))
+    {
+      operand *t = right;
+      right = left;
+      left = t;
     }
-    return;
-  }
 
-  // we have to do a signed multiply
+  lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
+  rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
 
-  //emitcode (";", "signed");
-  emitcode ("clr", "F0"); // reset sign flag
-  MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+  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))
+    {
+      /* just an unsigned 8 * 8 = 8 multiply
+         or 8u * 8u = 16u */
+      /* emitcode (";","unsigned"); */
+      /* TODO: check for accumulator clash between left & right aops? */
 
-  lbl=newiTempLabel(NULL);
-  emitcode ("jnb", "acc.7,%05d$",  lbl->key+100);
-  // left side is negative, 8-bit two's complement, this fails for -128
-  emitcode ("setb", "F0"); // set sign flag
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
+      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));
+        }
+      else
+        {
+          emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+          MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+        }
 
-  emitcode ("", "%05d$:", lbl->key+100);
+      emitcode ("mul", "ab");
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      if (size == 2)
+        aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
+      return;
+    }
 
-  /* if literal */
-  if (AOP_TYPE(right)==AOP_LIT) {
-    signed char val=floatFromVal (AOP (right)->aopu.aop_lit);
-    /* AND literal negative */
-    if (val < 0) {
-      emitcode ("cpl", "F0"); // complement sign flag
-      emitcode ("mov", "b,#0x%02x", -val);
-    } else {
-      emitcode ("mov", "b,#0x%02x", val);
+  /* we have to do a signed multiply */
+  /* emitcode (";", "signed"); */
+
+  /* now sign adjust for both left & right */
+
+  /* let's see what's needed: */
+  /* apply negative sign during runtime */
+  runtimeSign = FALSE;
+  /* negative sign from literals */
+  compiletimeSign = FALSE;
+
+  if (!lUnsigned)
+    {
+      if (AOP_TYPE(left) == AOP_LIT)
+        {
+          /* signed literal */
+          signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+          if (val < 0)
+            compiletimeSign = TRUE;
+        }
+      else
+        /* signed but not literal */
+        runtimeSign = TRUE;
     }
-  } else {
-    lbl=newiTempLabel(NULL);
-    emitcode ("mov", "b,a");
-    emitcode ("mov", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-    emitcode ("jnb", "acc.7,%05d$", lbl->key+100);
-    // right side is negative, 8-bit two's complement
-    emitcode ("cpl", "F0"); // complement sign flag
-    emitcode ("cpl", "a");
-    emitcode ("inc", "a");
-    emitcode ("", "%05d$:", lbl->key+100);
-  }
-  emitcode ("mul", "ab");
-    
-  lbl=newiTempLabel(NULL);
-  emitcode ("jnb", "F0,%05d$", lbl->key+100);
-  // only ONE op was negative, we have to do a 8/16-bit two's complement
-  emitcode ("cpl", "a"); // lsb
-  if (size==1) {
-    emitcode ("inc", "a");
-  } else {
-    emitcode ("add", "a,#1");
-    emitcode ("xch", "a,b");
-    emitcode ("cpl", "a"); // msb
-    emitcode ("addc", "a,#0");
-    emitcode ("xch", "a,b");
-  }
 
-  emitcode ("", "%05d$:", lbl->key+100);
-  aopPut (AOP (result), "a", 0);
-  if (size==2) {
-    aopPut (AOP (result), "b", 1);
-  }
+  if (!rUnsigned)
+    {
+      if (AOP_TYPE(right) == AOP_LIT)
+        {
+          /* signed literal */
+          signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+          if (val < 0)
+            compiletimeSign ^= TRUE;
+        }
+      else
+        /* signed but not literal */
+        runtimeSign = TRUE;
+    }
+
+  /* initialize F0, which stores the runtime sign */
+  if (runtimeSign)
+    {
+      if (compiletimeSign)
+	emitcode ("setb", "F0"); /* set sign flag */
+      else
+	emitcode ("clr", "F0"); /* reset sign flag */
+    }
+
+  /* save the signs of the operands */
+  if (AOP_TYPE(right) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+
+      if (!rUnsigned && val < 0)
+        emitcode ("mov", "b,#0x%02x", -val);
+      else
+        emitcode ("mov", "b,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      if (rUnsigned)  /* emitcode (";", "signed"); */
+
+        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+      else
+        {
+	  MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+	  lbl = newiTempLabel (NULL);
+	  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+	  emitcode ("cpl", "F0"); /* complement sign flag */
+	  emitcode ("cpl", "a");  /* 2's complement */
+	  emitcode ("inc", "a");
+	  emitcode ("", "%05d$:", (lbl->key + 100));
+          emitcode ("mov", "b,a");
+	}
+    }
+
+  if (AOP_TYPE(left) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+
+      if (!lUnsigned && val < 0)
+        emitcode ("mov", "a,#0x%02x", -val);
+      else
+        emitcode ("mov", "a,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+
+      if (!lUnsigned)
+        {
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+          emitcode ("cpl", "F0"); /* complement sign flag */
+          emitcode ("cpl", "a"); /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "%05d$:", (lbl->key + 100));
+        }
+    }
+
+  /* now the multiplication */
+  emitcode ("mul", "ab");
+  if (runtimeSign || compiletimeSign)
+    {
+      lbl = newiTempLabel (NULL);
+      if (runtimeSign)
+        emitcode ("jnb", "F0,%05d$", (lbl->key + 100));
+      emitcode ("cpl", "a"); /* lsb 2's complement */
+      if (size != 2)
+        emitcode ("inc", "a"); /* inc doesn't set carry flag */
+      else
+        {
+          emitcode ("add", "a,#1"); /* this sets carry flag */
+          emitcode ("xch", "a,b");
+          emitcode ("cpl", "a"); /* msb 2's complement */
+          emitcode ("addc", "a,#0");
+          emitcode ("xch", "a,b");
+        }
+      emitcode ("", "%05d$:", (lbl->key + 100));
+    }
+  aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+  if (size == 2)
+    aopPut (AOP (result), "b", 1, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -3466,7 +4080,7 @@ genMult (iCode * ic)
   operand *right = IC_RIGHT (ic);
   operand *result = IC_RESULT (ic);
 
-  D(emitcode (";", "genMult"));
+  D(emitcode (";     genMult",""));
 
   /* assign the amsops */
   aopOp (left, ic, FALSE);
@@ -3486,7 +4100,7 @@ genMult (iCode * ic)
 #if 0 // one of them can be a sloc shared with the result
     if (AOP_SIZE (left) == 1 && AOP_SIZE (right) == 1)
 #else
-  if (getSize(operandType(left)) == 1 && 
+  if (getSize(operandType(left)) == 1 &&
       getSize(operandType(right)) == 1)
 #endif
     {
@@ -3500,9 +4114,9 @@ genMult (iCode * ic)
   assert (0);
 
 release:
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
-  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -3516,7 +4130,7 @@ genDivbits (operand * left,
 
   char *l;
 
-  D(emitcode (";", "genDivbits"));
+  D(emitcode (";     genDivbits",""));
 
   /* the result must be bit */
   emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
@@ -3526,7 +4140,7 @@ genDivbits (operand * left,
 
   emitcode ("div", "ab");
   emitcode ("rrc", "a");
-  aopPut (AOP (result), "c", 0);
+  aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -3537,84 +4151,189 @@ genDivOneByte (operand * left,
 	       operand * right,
 	       operand * result)
 {
-  sym_link *opetype = operandType (result);
-  char *l;
+  bool lUnsigned, rUnsigned;
+  bool runtimeSign, compiletimeSign;
   symbol *lbl;
   int size, offset;
 
-  D(emitcode (";", "genDivOneByte"));
+  D(emitcode (";     genDivOneByte",""));
+
+  /* Why is it necessary that genDivOneByte() can return an int result?
+     Have a look at:
+     
+	volatile unsigned char uc;
+	volatile signed char sc1, sc2;
+	volatile int i;
+     
+	uc  = 255;
+	sc1 = -1;
+	i = uc / sc1;
 
+     Or:
+  
+	sc1 = -128;
+	sc2 = -1;
+	i = sc1 / sc2;
+
+     In all cases a one byte result would overflow, the following cast to int
+     would return the wrong result.
+  
+     Two possible solution:
+	a) cast operands to int, if ((unsigned) / (signed)) or
+	   ((signed) / (signed))
+	b) return an 16 bit signed int; this is what we're doing here!
+  */
+  
   size = AOP_SIZE (result) - 1;
   offset = 1;
+  lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
+  rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
+
   /* signed or unsigned */
-  if (SPEC_USIGN (opetype))
+  if (lUnsigned && rUnsigned)
     {
       /* unsigned is easy */
       emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-      l = aopGet (AOP (left), 0, FALSE, FALSE);
-      MOVA (l);
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
       emitcode ("div", "ab");
-      aopPut (AOP (result), "a", 0);
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
       while (size--)
-	aopPut (AOP (result), zero, offset++);
+	aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
       return;
     }
-
+  
   /* signed is a little bit more difficult */
 
+  /* now sign adjust for both left & right */
+
+  /* let's see what's needed: */
+  /* apply negative sign during runtime */
+  runtimeSign = FALSE;
+  /* negative sign from literals */
+  compiletimeSign = FALSE;
+
+  if (!lUnsigned)
+    {
+      if (AOP_TYPE(left) == AOP_LIT)
+        {
+          /* signed literal */
+          signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+          if (val < 0)
+            compiletimeSign = TRUE;
+        }
+      else
+        /* signed but not literal */
+        runtimeSign = TRUE;
+    }
+
+  if (!rUnsigned)
+    {
+      if (AOP_TYPE(right) == AOP_LIT)
+        {
+          /* signed literal */
+          signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+          if (val < 0)
+            compiletimeSign ^= TRUE;
+        }
+      else
+        /* signed but not literal */
+        runtimeSign = TRUE;
+    }
+
+  /* initialize F0, which stores the runtime sign */
+  if (runtimeSign)
+    {
+      if (compiletimeSign)
+	emitcode ("setb", "F0"); /* set sign flag */
+      else
+	emitcode ("clr", "F0"); /* reset sign flag */
+    }
+
   /* save the signs of the operands */
-  l = aopGet (AOP (left), 0, FALSE, FALSE);
-  MOVA (l);
-  emitcode ("xrl", "a,%s", aopGet (AOP (right), 0, FALSE, TRUE));
-  emitcode ("push", "acc");	/* save it on the stack */
+  if (AOP_TYPE(right) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
 
-  /* now sign adjust for both left & right */
-  l = aopGet (AOP (right), 0, FALSE, FALSE);
-  MOVA (l);
-  lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
-  emitcode ("mov", "b,a");
+      if (!rUnsigned && val < 0)
+        emitcode ("mov", "b,#0x%02x", -val);
+      else
+        emitcode ("mov", "b,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      if (rUnsigned)
+        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+      else
+        {
+	  MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+	  lbl = newiTempLabel (NULL);
+	  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+	  emitcode ("cpl", "F0"); /* complement sign flag */
+	  emitcode ("cpl", "a");  /* 2's complement */
+	  emitcode ("inc", "a");
+	  emitcode ("", "%05d$:", (lbl->key + 100));
+          emitcode ("mov", "b,a");
+	}
+    }
 
-  /* sign adjust left side */
-  l = aopGet (AOP (left), 0, FALSE, FALSE);
-  MOVA (l);
+  if (AOP_TYPE(left) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
 
-  lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
+      if (!lUnsigned && val < 0)
+        emitcode ("mov", "a,#0x%02x", -val);
+      else
+        emitcode ("mov", "a,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+
+      if (!lUnsigned)
+        {
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+          emitcode ("cpl", "F0"); /* complement sign flag */
+          emitcode ("cpl", "a");  /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "%05d$:", (lbl->key + 100));
+        }
+    }
 
   /* now the division */
   emitcode ("div", "ab");
-  /* we are interested in the lower order
-     only */
-  emitcode ("mov", "b,a");
-  lbl = newiTempLabel (NULL);
-  emitcode ("pop", "acc");
-  /* if there was an over flow we don't
-     adjust the sign of the result */
-  emitcode ("jb", "ov,%05d$", (lbl->key + 100));
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
-  CLRC;
-  emitcode ("clr", "a");
-  emitcode ("subb", "a,b");
-  emitcode ("mov", "b,a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
 
-  /* now we are done */
-  aopPut (AOP (result), "b", 0);
-  if (size > 0)
+  if (runtimeSign || compiletimeSign)
     {
-      emitcode ("mov", "c,b.7");
-      emitcode ("subb", "a,acc");
-    }
-  while (size--)
-    aopPut (AOP (result), "a", offset++);
+      lbl = newiTempLabel (NULL);
+      if (runtimeSign)
+        emitcode ("jnb", "F0,%05d$", (lbl->key + 100));
+      emitcode ("cpl", "a"); /* lsb 2's complement */
+      emitcode ("inc", "a");
+      emitcode ("", "%05d$:", (lbl->key + 100));
 
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      if (size > 0)
+	{
+	  /* msb is 0x00 or 0xff depending on the sign */
+	  if (runtimeSign)
+	    {
+	      emitcode ("mov", "c,F0");
+	      emitcode ("subb", "a,acc");
+	      while (size--)
+	        aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+	    }
+	  else /* compiletimeSign */
+	    while (size--)
+	      aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+	}
+    }
+  else
+    {
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      while (size--)
+	aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3627,7 +4346,7 @@ genDiv (iCode * ic)
   operand *right = IC_RIGHT (ic);
   operand *result = IC_RESULT (ic);
 
-  D(emitcode (";", "genDiv"));
+  D(emitcode (";     genDiv",""));
 
   /* assign the amsops */
   aopOp (left, ic, FALSE);
@@ -3654,8 +4373,8 @@ genDiv (iCode * ic)
   /* should have been converted to function call */
   assert (0);
 release:
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -3670,7 +4389,7 @@ genModbits (operand * left,
 
   char *l;
 
-  D(emitcode (";", "genModbits"));
+  D(emitcode (";     genModbits",""));
 
   /* the result must be bit */
   emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
@@ -3681,7 +4400,7 @@ genModbits (operand * left,
   emitcode ("div", "ab");
   emitcode ("mov", "a,b");
   emitcode ("rrc", "a");
-  aopPut (AOP (result), "c", 0);
+  aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -3692,73 +4411,133 @@ genModOneByte (operand * left,
 	       operand * right,
 	       operand * result)
 {
-  sym_link *opetype = operandType (result);
-  char *l;
+  bool lUnsigned, rUnsigned;
+  bool runtimeSign, compiletimeSign;
   symbol *lbl;
+  int size, offset;
 
-  D(emitcode (";", "genModOneByte"));
+  D(emitcode (";     genModOneByte",""));
 
+  size = AOP_SIZE (result) - 1;
+  offset = 1;
+  lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
+  rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
+  
   /* signed or unsigned */
-  if (SPEC_USIGN (opetype))
+  if (lUnsigned && rUnsigned)
     {
       /* unsigned is easy */
       emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-      l = aopGet (AOP (left), 0, FALSE, FALSE);
-      MOVA (l);
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
       emitcode ("div", "ab");
-      aopPut (AOP (result), "b", 0);
+      aopPut (AOP (result), "b", 0, isOperandVolatile (result, FALSE));
+      while (size--)
+	aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
       return;
     }
 
   /* signed is a little bit more difficult */
 
-  /* save the signs of the operands */
-  l = aopGet (AOP (left), 0, FALSE, FALSE);
-  MOVA (l);
-
-  emitcode ("xrl", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-  emitcode ("push", "acc");	/* save it on the stack */
-
   /* now sign adjust for both left & right */
-  l = aopGet (AOP (right), 0, FALSE, FALSE);
-  MOVA (l);
 
-  lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
-  emitcode ("mov", "b,a");
+  /* 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);
 
+      if (!rUnsigned && val < 0)
+        emitcode ("mov", "b,#0x%02x", -val);
+      else
+        emitcode ("mov", "b,#0x%02x", (unsigned char) val);
+    }
+  else /* not literal */
+    {
+      if (rUnsigned)
+        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+      else
+        {
+	  MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+	  lbl = newiTempLabel (NULL);
+	  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+	  emitcode ("cpl", "a"); /* 2's complement */
+	  emitcode ("inc", "a");
+	  emitcode ("", "%05d$:", (lbl->key + 100));
+          emitcode ("mov", "b,a");
+	}
+    }
+
+  /* let's see what's needed: */
+  /* apply negative sign during runtime */
+  runtimeSign = FALSE;
+  /* negative sign from literals */
+  compiletimeSign = FALSE;
+  
   /* sign adjust left side */
-  l = aopGet (AOP (left), 0, FALSE, FALSE);
-  MOVA (l);
+  if (AOP_TYPE(left) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
 
-  lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
+      if (!lUnsigned && val < 0)
+	{
+          compiletimeSign = TRUE; /* set sign flag */
+          emitcode ("mov", "a,#0x%02x", -val);
+        }
+      else
+        emitcode ("mov", "a,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
 
-  /* now the multiplication */
-  emitcode ("div", "ab");
-  /* we are interested in the lower order
-     only */
-  lbl = newiTempLabel (NULL);
-  emitcode ("pop", "acc");
-  /* if there was an over flow we don't
-     adjust the sign of the result */
-  emitcode ("jb", "ov,%05d$", (lbl->key + 100));
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
-  CLRC;
-  emitcode ("clr", "a");
-  emitcode ("subb", "a,b");
-  emitcode ("mov", "b,a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
+      if (!lUnsigned)
+        {
+          runtimeSign = TRUE;
+          emitcode ("clr", "F0"); /* clear sign flag */
 
-  /* now we are done */
-  aopPut (AOP (result), "b", 0);
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+          emitcode ("setb", "F0"); /* set sign flag */
+          emitcode ("cpl", "a");   /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "%05d$:", (lbl->key + 100));
+        }
+    }
 
+  /* now the modulus */
+  emitcode ("div", "ab");
+  
+  if (runtimeSign || compiletimeSign)
+    {
+      emitcode ("mov", "a,b");
+      lbl = newiTempLabel (NULL);
+      if (runtimeSign)
+        emitcode ("jnb", "F0,%05d$", (lbl->key + 100));
+      emitcode ("cpl", "a"); /* 2's complement */
+      emitcode ("inc", "a");
+      emitcode ("", "%05d$:", (lbl->key + 100));
+     
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
+      if (size > 0)
+	{
+	  /* msb is 0x00 or 0xff depending on the sign */
+	  if (runtimeSign)
+	    {
+	      emitcode ("mov", "c,F0");
+	      emitcode ("subb", "a,acc");
+	      while (size--)
+	        aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+	    }
+	  else /* compiletimeSign */
+	    while (size--)
+	      aopPut (AOP (result), "#0xff", offset++, isOperandVolatile (result, FALSE));
+	}
+    }
+  else
+    {
+      aopPut (AOP (result), "b", 0, isOperandVolatile (result, FALSE));
+      while (size--)
+	aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3771,7 +4550,7 @@ genMod (iCode * ic)
   operand *right = IC_RIGHT (ic);
   operand *result = IC_RESULT (ic);
 
-  D(emitcode (";", "genMod"));
+  D(emitcode (";     genMod",""));
 
   /* assign the amsops */
   aopOp (left, ic, FALSE);
@@ -3799,8 +4578,8 @@ genMod (iCode * ic)
   assert (0);
 
 release:
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -3814,7 +4593,7 @@ genIfxJump (iCode * ic, char *jval)
   symbol *tlbl = newiTempLabel (NULL);
   char *inst;
 
-  D(emitcode (";", "genIfxJump"));
+  D(emitcode (";     genIfxJump",""));
 
   /* if true label then we jump if condition
      supplied is true */
@@ -3851,15 +4630,16 @@ genCmp (operand * left, operand * right,
 {
   int size, offset = 0;
   unsigned long lit = 0L;
+  bool rightInB;
 
-  D(emitcode (";", "genCmp"));
+  D(emitcode (";     genCmp",""));
 
   /* if left & right are bit variables */
   if (AOP_TYPE (left) == AOP_CRY &&
       AOP_TYPE (right) == AOP_CRY)
     {
       emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-      emitcode ("anl", "c,/%s", AOP (left)->aopu.aop_dir);
+      emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
     }
   else
     {
@@ -3908,6 +4688,9 @@ genCmp (operand * left, operand * right,
 	  CLRC;
 	  while (size--)
 	    {
+	      rightInB = aopGetUsesAcc(AOP (right), offset);
+	      if (rightInB)
+		emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
 	      MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
 	      if (sign && size == 0)
 		{
@@ -3921,20 +4704,27 @@ genCmp (operand * left, operand * right,
 		    }
 		  else
 		    {
-		      emitcode ("mov", "b,%s", aopGet (AOP (right), offset++, FALSE, FALSE));
+		      if (!rightInB)
+		        emitcode ("mov", "b,%s", aopGet (AOP (right), offset, FALSE, FALSE));
 		      emitcode ("xrl", "b,#0x80");
 		      emitcode ("subb", "a,b");
 		    }
 		}
 	      else
-		emitcode ("subb", "a,%s", aopGet (AOP (right), offset++, FALSE, FALSE));
+		{
+		  if (rightInB)
+		    emitcode ("subb", "a,b");
+		  else
+		    emitcode ("subb", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE));
+		}
+	      offset++;
 	    }
 	}
     }
 
 release:
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
     {
       outBitC (result);
@@ -3962,7 +4752,7 @@ genCmpGt (iCode * ic, iCode * ifx)
   sym_link *letype, *retype;
   int sign;
 
-  D(emitcode (";", "genCmpGt"));
+  D(emitcode (";     genCmpGt",""));
 
   left = IC_LEFT (ic);
   right = IC_RIGHT (ic);
@@ -3970,7 +4760,8 @@ genCmpGt (iCode * ic, iCode * ifx)
 
   letype = getSpec (operandType (left));
   retype = getSpec (operandType (right));
-  sign = !(SPEC_USIGN (letype) | SPEC_USIGN (retype));
+  sign = !((SPEC_USIGN (letype) && !(IS_CHAR (letype) && IS_LITERAL (letype))) ||
+           (SPEC_USIGN (retype) && !(IS_CHAR (retype) && IS_LITERAL (retype))));
   /* assign the amsops */
   aopOp (left, ic, FALSE);
   aopOp (right, ic, FALSE);
@@ -3991,7 +4782,7 @@ genCmpLt (iCode * ic, iCode * ifx)
   sym_link *letype, *retype;
   int sign;
 
-  D(emitcode (";", "genCmpLt"));
+  D(emitcode (";     genCmpLt",""));
 
   left = IC_LEFT (ic);
   right = IC_RIGHT (ic);
@@ -3999,8 +4790,8 @@ genCmpLt (iCode * ic, iCode * ifx)
 
   letype = getSpec (operandType (left));
   retype = getSpec (operandType (right));
-  sign = !(SPEC_USIGN (letype) | SPEC_USIGN (retype));
-
+  sign = !((SPEC_USIGN (letype) && !(IS_CHAR (letype) && IS_LITERAL (letype))) ||
+           (SPEC_USIGN (retype) && !(IS_CHAR (retype) && IS_LITERAL (retype))));
   /* assign the amsops */
   aopOp (left, ic, FALSE);
   aopOp (right, ic, FALSE);
@@ -4025,18 +4816,21 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
      if the right is in a pointer register and left
      is not */
   if ((AOP_TYPE (left) == AOP_LIT) ||
+      (AOP_TYPE (left) == AOP_IMMD) ||
       (IS_AOP_PREG (right) && !IS_AOP_PREG (left)))
     {
       operand *t = right;
       right = left;
       left = t;
     }
+
   if (AOP_TYPE (right) == AOP_LIT)
     lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
 
   /* if the right side is a literal then anything goes */
   if (AOP_TYPE (right) == AOP_LIT &&
-      AOP_TYPE (left) != AOP_DIR)
+      AOP_TYPE (left) != AOP_DIR  &&
+      AOP_TYPE (left) != AOP_IMMD)
     {
       while (size--)
 	{
@@ -4052,6 +4846,8 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
      if the left is a pointer register & right is not */
   else if (AOP_TYPE (right) == AOP_REG ||
 	   AOP_TYPE (right) == AOP_DIR ||
+	   AOP_TYPE (right) == AOP_LIT ||
+           AOP_TYPE (right) == AOP_IMMD ||
 	   (AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) ||
 	   (IS_AOP_PREG (left) && !IS_AOP_PREG (right)))
     {
@@ -4108,7 +4904,7 @@ genCmpEq (iCode * ic, iCode * ifx)
 {
   operand *left, *right, *result;
 
-  D(emitcode (";", "genCmpEq"));
+  D(emitcode (";     genCmpEq",""));
 
   aopOp ((left = IC_LEFT (ic)), ic, FALSE);
   aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
@@ -4246,7 +5042,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);
+	  aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
 	  goto release;
 	}
       if (ifx)
@@ -4262,8 +5058,8 @@ genCmpEq (iCode * ic, iCode * ifx)
     }
 
 release:
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -4293,22 +5089,24 @@ ifxForOp (operand * op, iCode * ic)
 /* hasInc - operand is incremented before any other use            */
 /*-----------------------------------------------------------------*/
 static iCode *
-hasInc (operand *op, iCode *ic)
+hasInc (operand *op, iCode *ic,int osize)
 {
   sym_link *type = operandType(op);
   sym_link *retype = getSpec (type);
   iCode *lic = ic->next;
   int isize ;
-  
+
   /* this could from a cast, e.g.: "(char xdata *) 0x7654;" */
   if (!IS_SYMOP(op)) return NULL;
 
   if (IS_BITVAR(retype)||!IS_PTR(type)) return NULL;
-  isize = getSize(type->next);
+  if (IS_AGGREGATE(type->next)) return NULL;
+  if (osize != (isize = getSize(type->next))) return NULL;
+
   while (lic) {
     /* if operand of the form op = op + <sizeof *op> */
     if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) &&
-	isOperandEqual(IC_RESULT(lic),op) && 
+	isOperandEqual(IC_RESULT(lic),op) &&
 	isOperandLiteral(IC_RIGHT(lic)) &&
 	operandLitValue(IC_RIGHT(lic)) == isize) {
       return lic;
@@ -4318,7 +5116,7 @@ hasInc (operand *op, iCode *ic)
       return NULL;
     }
     /* if GOTO or IFX */
-    if (lic->op == IFX || lic->op == GOTO) break;
+    if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break;
     lic = lic->next;
   }
   return NULL;
@@ -4333,7 +5131,7 @@ genAndOp (iCode * ic)
   operand *left, *right, *result;
   symbol *tlbl;
 
-  D(emitcode (";", "genAndOp"));
+  D(emitcode (";     genAndOp",""));
 
   /* note here that && operations that are in an
      if statement are taken away by backPatchLabels
@@ -4360,8 +5158,8 @@ genAndOp (iCode * ic)
       outBitAcc (result);
     }
 
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -4375,7 +5173,7 @@ genOrOp (iCode * ic)
   operand *left, *right, *result;
   symbol *tlbl;
 
-  D(emitcode (";", "genOrOp"));
+  D(emitcode (";     genOrOp",""));
 
   /* note here that || operations that are in an
      if statement are taken away by backPatchLabels
@@ -4402,8 +5200,8 @@ genOrOp (iCode * ic)
       outBitAcc (result);
     }
 
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -4486,7 +5284,7 @@ genAnd (iCode * ic, iCode * ifx)
   int bytelit = 0;
   char buffer[10];
 
-  D(emitcode (";", "genAnd"));
+  D(emitcode (";     genAnd",""));
 
   aopOp ((left = IC_LEFT (ic)), ic, FALSE);
   aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
@@ -4649,6 +5447,8 @@ genAnd (iCode * ic, iCode * ifx)
 	    {
 	      if (ifx)
 		jmpTrueOrFalse (ifx, tlbl);
+              else
+	        emitcode ("", "%05d$:", tlbl->key + 100);
 	      goto release;
 	    }
 	}
@@ -4666,12 +5466,14 @@ genAnd (iCode * ic, iCode * ifx)
 	      if ((bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL)) == 0x0FF)
 		continue;
 	      else if (bytelit == 0)
-		aopPut (AOP (result), zero, offset);
+		{
+		  aopPut (AOP (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);
+		  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 		}
 	      else
 		emitcode ("anl", "%s,%s",
@@ -4688,7 +5490,7 @@ genAnd (iCode * ic, iCode * ifx)
 		  if (IS_AOP_PREG (result))
 		    {
 		      emitcode ("anl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-		      aopPut (AOP (result), "a", offset);
+		      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 
 		    }
 		  else
@@ -4737,6 +5539,8 @@ genAnd (iCode * ic, iCode * ifx)
 	    }
 	  else if (ifx)
 	    jmpTrueOrFalse (ifx, tlbl);
+          else
+	    emitcode ("", "%05d$:", tlbl->key + 100);
 	}
       else
 	{
@@ -4750,12 +5554,16 @@ genAnd (iCode * ic, iCode * ifx)
 		    {
 		      aopPut (AOP (result),
 			      aopGet (AOP (left), offset, FALSE, FALSE),
-			      offset);
+			      offset,
+			      isOperandVolatile (result, FALSE));
 		      continue;
 		    }
 		  else if (bytelit == 0)
 		    {
-		      aopPut (AOP (result), zero, offset);
+		      /* dummy read of volatile operand */
+		      if (isOperandVolatile (left, FALSE))
+			MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+		      aopPut (AOP (result), zero, offset, isOperandVolatile (result, FALSE));
 		      continue;
 		    }
 		}
@@ -4769,14 +5577,14 @@ genAnd (iCode * ic, iCode * ifx)
 		  emitcode ("anl", "a,%s",
 			    aopGet (AOP (left), offset, FALSE, FALSE));
 		}
-	      aopPut (AOP (result), "a", offset);
+	      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 	    }
 	}
     }
 
 release:
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -4790,7 +5598,7 @@ genOr (iCode * ic, iCode * ifx)
   int size, offset = 0;
   unsigned long lit = 0L;
 
-  D(emitcode (";", "genOr"));
+  D(emitcode (";     genOr",""));
 
   aopOp ((left = IC_LEFT (ic)), ic, FALSE);
   aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
@@ -4841,7 +5649,7 @@ genOr (iCode * ic, iCode * ifx)
     {
       if (AOP_TYPE (right) == AOP_LIT)
 	{
-	  // c = bit & literal;
+	  // c = bit | literal;
 	  if (lit)
 	    {
 	      // lit != 0 => result = 1
@@ -4949,12 +5757,18 @@ genOr (iCode * ic, iCode * ifx)
 	  if (AOP_TYPE (right) == AOP_LIT)
 	    {
 	      if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
-		continue;
+		{
+		  /* dummy read of volatile operand */
+		  if (isOperandVolatile (left, FALSE))
+		    MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+		  else
+        	    continue;
+		}
 	      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);
+		  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 		}
 	      else
 		emitcode ("orl", "%s,%s",
@@ -4971,7 +5785,7 @@ genOr (iCode * ic, iCode * ifx)
 		  if (IS_AOP_PREG (left))
 		    {
 		      emitcode ("orl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-		      aopPut (AOP (result), "a", offset);
+		      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 		    }
 		  else
 		    emitcode ("orl", "%s,a",
@@ -5013,6 +5827,8 @@ genOr (iCode * ic, iCode * ifx)
 	    }
 	  else if (ifx)
 	    jmpTrueOrFalse (ifx, tlbl);
+	  else
+	    emitcode ("", "%05d$:", tlbl->key + 100);
 	}
       else
 	for (; (size--); offset++)
@@ -5025,7 +5841,8 @@ genOr (iCode * ic, iCode * ifx)
 		  {
 		    aopPut (AOP (result),
 			    aopGet (AOP (left), offset, FALSE, FALSE),
-			    offset);
+			    offset,
+			    isOperandVolatile (result, FALSE));
 		    continue;
 		  }
 	      }
@@ -5039,13 +5856,13 @@ genOr (iCode * ic, iCode * ifx)
 		emitcode ("orl", "a,%s",
 			  aopGet (AOP (left), offset, FALSE, FALSE));
 	      }
-	    aopPut (AOP (result), "a", offset);
+	    aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 	  }
     }
 
 release:
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -5059,7 +5876,7 @@ genXor (iCode * ic, iCode * ifx)
   int size, offset = 0;
   unsigned long lit = 0L;
 
-  D(emitcode (";", "genXor"));
+  D(emitcode (";     genXor",""));
 
   aopOp ((left = IC_LEFT (ic)), ic, FALSE);
   aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
@@ -5206,7 +6023,7 @@ genXor (iCode * ic, iCode * ifx)
 		{
 		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
 		  emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-		  aopPut (AOP (result), "a", offset);
+		  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 		}
 	      else
 		emitcode ("xrl", "%s,%s",
@@ -5223,7 +6040,7 @@ genXor (iCode * ic, iCode * ifx)
 		  if (IS_AOP_PREG (left))
 		    {
 		      emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE));
-		      aopPut (AOP (result), "a", offset);
+		      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 		    }
 		  else
 		    emitcode ("xrl", "%s,a",
@@ -5285,7 +6102,8 @@ genXor (iCode * ic, iCode * ifx)
 		  {
 		    aopPut (AOP (result),
 			    aopGet (AOP (left), offset, FALSE, FALSE),
-			    offset);
+			    offset,
+			    isOperandVolatile (result, FALSE));
 		    continue;
 		  }
 	      }
@@ -5299,13 +6117,13 @@ genXor (iCode * ic, iCode * ifx)
 		emitcode ("xrl", "a,%s",
 			  aopGet (AOP (left), offset, FALSE, TRUE));
 	      }
-	    aopPut (AOP (result), "a", offset);
+	    aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 	  }
     }
 
 release:
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -5317,7 +6135,7 @@ genInline (iCode * ic)
 {
   char *buffer, *bp, *bp1;
 
-  D(emitcode (";", "genInline"));
+  D(emitcode (";     genInline",""));
 
   _G.inLine += (!options.asmpeep);
 
@@ -5363,7 +6181,7 @@ genRRC (iCode * ic)
   int size, offset = 0;
   char *l;
 
-  D(emitcode (";", "genRRC"));
+  D(emitcode (";     genRRC",""));
 
   /* rotate right with carry */
   left = IC_LEFT (ic);
@@ -5387,7 +6205,7 @@ genRRC (iCode * ic)
       MOVA (l);
       emitcode ("rrc", "a");
       if (AOP_SIZE (result) > 1)
-	aopPut (AOP (result), "a", offset--);
+	aopPut (AOP (result), "a", offset--, isOperandVolatile (result, FALSE));
     }
   /* now we need to put the carry into the
      highest order byte of the result */
@@ -5398,7 +6216,7 @@ genRRC (iCode * ic)
     }
   emitcode ("mov", "acc.7,c");
  release:
-  aopPut (AOP (result), "a", AOP_SIZE (result) - 1);
+  aopPut (AOP (result), "a", AOP_SIZE (result) - 1, isOperandVolatile (result, FALSE));
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
@@ -5413,7 +6231,7 @@ genRLC (iCode * ic)
   int size, offset = 0;
   char *l;
 
-  D(emitcode (";", "genRLC"));
+  D(emitcode (";     genRLC",""));
 
   /* rotate right with carry */
   left = IC_LEFT (ic);
@@ -5434,14 +6252,14 @@ genRLC (iCode * ic)
       }
       emitcode ("add", "a,acc");
       if (AOP_SIZE (result) > 1)
-	aopPut (AOP (result), "a", offset++);
+	aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
       while (size--)
 	{
 	  l = aopGet (AOP (left), offset, FALSE, FALSE);
 	  MOVA (l);
 	  emitcode ("rlc", "a");
 	  if (AOP_SIZE (result) > 1)
-	    aopPut (AOP (result), "a", offset++);
+	    aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
 	}
     }
   /* now we need to put the carry into the
@@ -5453,7 +6271,7 @@ genRLC (iCode * ic)
     }
   emitcode ("mov", "acc.0,c");
  release:
-  aopPut (AOP (result), "a", 0);
+  aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
@@ -5466,7 +6284,7 @@ genGetHbit (iCode * ic)
 {
   operand *left, *result;
 
-  D(emitcode (";", "genGetHbit"));
+  D(emitcode (";     genGetHbit",""));
 
   left = IC_LEFT (ic);
   result = IC_RESULT (ic);
@@ -5492,6 +6310,66 @@ genGetHbit (iCode * ic)
   freeAsmop (result, NULL, ic, TRUE);
 }
 
+/*-----------------------------------------------------------------*/
+/* genSwap - generates code to swap nibbles or bytes               */
+/*-----------------------------------------------------------------*/
+static void
+genSwap (iCode * ic)
+{
+  operand *left, *result;
+
+  D(emitcode (";     genSwap",""));
+
+  left = IC_LEFT (ic);
+  result = IC_RESULT (ic);
+  aopOp (left, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  switch (AOP_SIZE (left))
+    {
+    case 1: /* swap nibbles in byte */
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
+      emitcode ("swap", "a");
+      aopPut (AOP (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),
+		  0, isOperandVolatile (result, FALSE));
+	  aopPut (AOP (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))
+	    {
+	      emitcode ("mov", "b,a");
+              reg = "b";
+            }
+	  aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
+		  0, isOperandVolatile (result, FALSE));
+	  aopPut (AOP (result), reg, 1, isOperandVolatile (result, FALSE));
+	}
+      else
+	{
+	  aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE),
+		  0, isOperandVolatile (result, FALSE));
+	  aopPut (AOP (result), aopGet (AOP (left), 0, FALSE, FALSE),
+		  1, isOperandVolatile (result, FALSE));
+	}
+      break;
+    default:
+      wassertl(FALSE, "unsupported SWAP operand size");
+    }
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+
 /*-----------------------------------------------------------------*/
 /* AccRol - rotate left accumulator by known count                 */
 /*-----------------------------------------------------------------*/
@@ -5630,7 +6508,7 @@ shiftR1Left2Result (operand * left, int offl,
     AccSRsh (shCount);
   else
     AccRsh (shCount);
-  aopPut (AOP (result), "a", offr);
+  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -5645,7 +6523,7 @@ shiftL1Left2Result (operand * left, int offl,
   MOVA (l);
   /* shift left accumulator */
   AccLsh (shCount);
-  aopPut (AOP (result), "a", offr);
+  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -5663,19 +6541,19 @@ movLeft2Result (operand * left, int offl,
       if (*l == '@' && (IS_AOP_PREG (result)))
 	{
 	  emitcode ("mov", "a,%s", l);
-	  aopPut (AOP (result), "a", offr);
+	  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
 	}
       else
 	{
 	  if (!sign)
-	    aopPut (AOP (result), l, offr);
+	    aopPut (AOP (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);
+		  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
 		}
 	    }
 	}
@@ -5771,16 +6649,16 @@ AccAXLsh (char *x, int shCount)
       AccAXRrl1 (x);		// BCCCCCCD:D000000B
       AccAXRrl1 (x);		// BBCCCCCC:DD000000
 #else
-      emitcode("rrc","a"); 
-      emitcode("xch","a,%s", x); 
-      emitcode("rrc","a"); 
-      emitcode("mov","c,acc.0"); //<< get correct bit 
-      emitcode("xch","a,%s", x); 
-
-      emitcode("rrc","a"); 
-      emitcode("xch","a,%s", x); 
-      emitcode("rrc","a"); 
-      emitcode("xch","a,%s", x); 
+      emitcode("rrc","a");
+      emitcode("xch","a,%s", x);
+      emitcode("rrc","a");
+      emitcode("mov","c,acc.0"); //<< get correct bit
+      emitcode("xch","a,%s", x);
+
+      emitcode("rrc","a");
+      emitcode("xch","a,%s", x);
+      emitcode("rrc","a");
+      emitcode("xch","a,%s", x);
 #endif
       break;
     case 7:			// a:x <<= 7
@@ -5855,6 +6733,7 @@ AccAXRsh (char *x, int shCount)
       emitcode ("mov", "c,acc.7");
       AccAXLrl1 (x);		// ABBBBBBC:CDDDDDDA
 
+      emitcode ("mov", "c,acc.7");
       AccAXLrl1 (x);		// BBBBBBCC:DDDDDDAA
 
       emitcode ("xch", "a,%s", x);	// DDDDDDAA:BBBBBBCC
@@ -5944,6 +6823,7 @@ AccAXRshS (char *x, int shCount)
       emitcode ("mov", "c,acc.7");
       AccAXLrl1 (x);		// ABBBBBBC:CDDDDDDA
 
+      emitcode ("mov", "c,acc.7");
       AccAXLrl1 (x);		// BBBBBBCC:DDDDDDAA
 
       emitcode ("xch", "a,%s", x);	// DDDDDDAA:BBBBBBCC
@@ -6001,7 +6881,7 @@ shiftL2Left2Result (operand * left, int offl,
     }
   /* ax << shCount (x = lsb(result)) */
   AccAXLsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
-  aopPut (AOP (result), "a", offr + MSB16);
+  aopPut (AOP (result), "a", offr + MSB16, isOperandVolatile (result, FALSE));
 }
 
 
@@ -6031,7 +6911,7 @@ shiftR2Left2Result (operand * left, int offl,
   else
     AccAXRsh (aopGet (AOP (result), offr, FALSE, FALSE), shCount);
   if (getDataSize (result) > 1)
-    aopPut (AOP (result), "a", offr + MSB16);
+    aopPut (AOP (result), "a", offr + MSB16, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -6047,7 +6927,7 @@ shiftLLeftOrResult (operand * left, int offl,
   /* or with result */
   emitcode ("orl", "a,%s", aopGet (AOP (result), offr, FALSE, FALSE));
   /* back to result */
-  aopPut (AOP (result), "a", offr);
+  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -6063,7 +6943,7 @@ shiftRLeftOrResult (operand * left, int offl,
   /* or with result */
   emitcode ("orl", "a,%s", aopGet (AOP (result), offr, FALSE, FALSE));
   /* back to result */
-  aopPut (AOP (result), "a", offr);
+  aopPut (AOP (result), "a", offr, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -6072,7 +6952,7 @@ shiftRLeftOrResult (operand * left, int offl,
 static void
 genlshOne (operand * result, operand * left, int shCount)
 {
-  D(emitcode (";", "genlshOne"));
+  D(emitcode (";     genlshOne",""));
 
   shiftL1Left2Result (left, LSB, result, LSB, shCount);
 }
@@ -6085,7 +6965,7 @@ genlshTwo (operand * result, operand * left, int shCount)
 {
   int size;
 
-  D(emitcode (";", "genlshTwo"));
+  D(emitcode (";     genlshTwo",""));
 
   size = getDataSize (result);
 
@@ -6101,7 +6981,7 @@ genlshTwo (operand * result, operand * left, int shCount)
 	  else
 	    movLeft2Result (left, LSB, result, MSB16, 0);
 	}
-      aopPut (AOP (result), zero, LSB);
+      aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
     }
 
   /*  1 <= shCount <= 7 */
@@ -6134,7 +7014,7 @@ shiftLLong (operand * left, operand * result, int offr)
 	emitcode ("xch", "a,%s",
 		  aopGet (AOP (left), LSB + offr, FALSE, FALSE));
       else
-	aopPut (AOP (result), "a", LSB + offr);
+	aopPut (AOP (result), "a", LSB + offr, isOperandVolatile (result, FALSE));
     }
 
   if (size >= MSB16 + offr)
@@ -6150,7 +7030,7 @@ shiftLLong (operand * left, operand * result, int offr)
 	emitcode ("xch", "a,%s",
 		  aopGet (AOP (left), MSB16 + offr, FALSE, FALSE));
       else
-	aopPut (AOP (result), "a", MSB16 + offr);
+	aopPut (AOP (result), "a", MSB16 + offr, isOperandVolatile (result, FALSE));
     }
 
   if (size >= MSB24 + offr)
@@ -6166,7 +7046,7 @@ shiftLLong (operand * left, operand * result, int offr)
 	emitcode ("xch", "a,%s",
 		  aopGet (AOP (left), MSB24 + offr, FALSE, FALSE));
       else
-	aopPut (AOP (result), "a", MSB24 + offr);
+	aopPut (AOP (result), "a", MSB24 + offr, isOperandVolatile (result, FALSE));
     }
 
   if (size > MSB32 + offr)
@@ -6177,10 +7057,10 @@ shiftLLong (operand * left, operand * result, int offr)
 	  MOVA (l);
 	}
       emitcode ("rlc", "a");
-      aopPut (AOP (result), "a", MSB32 + offr);
+      aopPut (AOP (result), "a", MSB32 + offr, isOperandVolatile (result, FALSE));
     }
   if (offr != LSB)
-    aopPut (AOP (result), zero, LSB);
+    aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
 }
 
 /*-----------------------------------------------------------------*/
@@ -6191,7 +7071,7 @@ genlshFour (operand * result, operand * left, int shCount)
 {
   int size;
 
-  D(emitcode (";", "genlshFour"));
+  D(emitcode (";     genlshFour",""));
 
   size = AOP_SIZE (result);
 
@@ -6205,9 +7085,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);
-      aopPut (AOP (result), zero, MSB16);
-      aopPut (AOP (result), zero, MSB24);
+      aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
+      aopPut (AOP (result), zero, MSB16, isOperandVolatile (result, FALSE));
+      aopPut (AOP (result), zero, MSB24, isOperandVolatile (result, FALSE));
       return;
     }
 
@@ -6224,8 +7104,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);
-      aopPut (AOP (result), zero, LSB);
+      aopPut (AOP (result), zero, MSB16, isOperandVolatile (result, FALSE));
+      aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
       return;
     }
 
@@ -6248,7 +7128,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);
+	      aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
 	    }
 	  else if (shCount == 1)
 	    shiftLLong (left, result, MSB16);
@@ -6257,7 +7137,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);
+	      aopPut (AOP (result), zero, LSB, isOperandVolatile (result, FALSE));
 	    }
 	}
     }
@@ -6290,7 +7170,7 @@ genLeftShiftLiteral (operand * left,
   int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
   int size;
 
-  D(emitcode (";", "genLeftShiftLiteral"));
+  D(emitcode (";     genLeftShiftLiteral",""));
 
   freeAsmop (right, NULL, ic, TRUE);
 
@@ -6315,7 +7195,7 @@ genLeftShiftLiteral (operand * left,
 
   else if (shCount >= (size * 8))
     while (size--)
-      aopPut (AOP (result), zero, size);
+      aopPut (AOP (result), zero, size, isOperandVolatile (result, FALSE));
   else
     {
       switch (size)
@@ -6332,7 +7212,8 @@ genLeftShiftLiteral (operand * left,
 	  genlshFour (result, left, shCount);
 	  break;
 	default:
-	  fprintf(stderr, "*** ack! mystery literal shift!\n");
+	  werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+		  "*** ack! mystery literal shift!\n");
 	  break;
 	}
     }
@@ -6351,7 +7232,7 @@ genLeftShift (iCode * ic)
   char *l;
   symbol *tlbl, *tlbl1;
 
-  D(emitcode (";", "genLeftShift"));
+  D(emitcode (";     genLeftShift",""));
 
   right = IC_RIGHT (ic);
   left = IC_LEFT (ic);
@@ -6394,10 +7275,10 @@ genLeftShift (iCode * ic)
 	    {
 
 	      emitcode ("mov", "a,%s", l);
-	      aopPut (AOP (result), "a", offset);
+	      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 	    }
 	  else
-	    aopPut (AOP (result), l, offset);
+	    aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
 	  offset++;
 	}
     }
@@ -6419,7 +7300,7 @@ genLeftShift (iCode * ic)
       emitcode ("add", "a,acc");
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
-      aopPut (AOP (result), "a", 0);
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -6430,13 +7311,13 @@ genLeftShift (iCode * ic)
   l = aopGet (AOP (result), offset, FALSE, FALSE);
   MOVA (l);
   emitcode ("add", "a,acc");
-  aopPut (AOP (result), "a", offset++);
+  aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
   while (--size)
     {
       l = aopGet (AOP (result), offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rlc", "a");
-      aopPut (AOP (result), "a", offset++);
+      aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
     }
   reAdjustPreg (AOP (result));
 
@@ -6454,7 +7335,7 @@ static void
 genrshOne (operand * result, operand * left,
 	   int shCount, int sign)
 {
-  D(emitcode (";", "genrshOne"));
+  D(emitcode (";     genrshOne",""));
 
   shiftR1Left2Result (left, LSB, result, LSB, shCount, sign);
 }
@@ -6466,7 +7347,7 @@ static void
 genrshTwo (operand * result, operand * left,
 	   int shCount, int sign)
 {
-  D(emitcode (";", "genrshTwo"));
+  D(emitcode (";     genrshTwo",""));
 
   /* if shCount >= 8 */
   if (shCount >= 8)
@@ -6501,15 +7382,20 @@ shiftRLong (operand * left, int offl,
   }
 
   MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
-  
+
   if (offl==MSB16) {
     // shift is > 8
     if (sign) {
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
-      emitcode ("xch", "a,%s", aopGet(AOP(left), MSB32, FALSE, FALSE));
+      if (isSameRegs)
+        emitcode ("xch", "a,%s", aopGet(AOP(left), MSB32, FALSE, FALSE));
+      else {
+        aopPut (AOP (result), "a", MSB32, isOperandVolatile (result, FALSE));
+        MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
+      }
     } else {
-      aopPut (AOP(result), zero, MSB32);
+      aopPut (AOP(result), zero, MSB32, isOperandVolatile (result, FALSE));
     }
   }
 
@@ -6524,7 +7410,7 @@ shiftRLong (operand * left, int offl,
   if (isSameRegs && offl==MSB16) {
     emitcode ("xch", "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE));
   } else {
-    aopPut (AOP (result), "a", MSB32);
+    aopPut (AOP (result), "a", MSB32-offl, isOperandVolatile (result, FALSE));
     MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
   }
 
@@ -6532,17 +7418,17 @@ shiftRLong (operand * left, int offl,
   if (isSameRegs && offl==1) {
     emitcode ("xch", "a,%s",aopGet (AOP (left), MSB16, FALSE, FALSE));
   } else {
-    aopPut (AOP (result), "a", MSB24);
+    aopPut (AOP (result), "a", MSB24-offl, isOperandVolatile (result, FALSE));
     MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
   }
   emitcode ("rrc", "a");
-  aopPut (AOP (result), "a", MSB16 - offl);
+  aopPut (AOP (result), "a", MSB16 - offl, isOperandVolatile (result, FALSE));
 
   if (offl == LSB)
     {
       MOVA (aopGet (AOP (left), LSB, FALSE, FALSE));
       emitcode ("rrc", "a");
-      aopPut (AOP (result), "a", LSB);
+      aopPut (AOP (result), "a", LSB, isOperandVolatile (result, FALSE));
     }
 }
 
@@ -6553,7 +7439,7 @@ static void
 genrshFour (operand * result, operand * left,
 	    int shCount, int sign)
 {
-  D(emitcode (";", "genrshFour"));
+  D(emitcode (";     genrshFour",""));
 
   /* if shifting more that 3 bytes */
   if (shCount >= 24)
@@ -6628,7 +7514,7 @@ genRightShiftLiteral (operand * left,
   int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
   int size;
 
-  D(emitcode (";", "genRightShiftLiteral"));
+  D(emitcode (";     genRightShiftLiteral",""));
 
   freeAsmop (right, NULL, ic, TRUE);
 
@@ -6653,9 +7539,10 @@ genRightShiftLiteral (operand * left,
 
   else if (shCount >= (size * 8))
     {
-      if (sign)
+      if (sign) {
 	/* get sign in acc.7 */
 	MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE));
+      }
       addSign (result, LSB, sign);
     }
   else
@@ -6676,10 +7563,9 @@ genRightShiftLiteral (operand * left,
 	default:
 	  break;
 	}
-
-      freeAsmop (left, NULL, ic, TRUE);
-      freeAsmop (result, NULL, ic, TRUE);
     }
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6693,7 +7579,7 @@ genSignedRightShift (iCode * ic)
   char *l;
   symbol *tlbl, *tlbl1;
 
-  D(emitcode (";", "genSignedRightShift"));
+  D(emitcode (";     genSignedRightShift",""));
 
   /* we do it the hard way put the shift count in b
      and loop thru preserving the sign */
@@ -6737,10 +7623,10 @@ genSignedRightShift (iCode * ic)
 	    {
 
 	      emitcode ("mov", "a,%s", l);
-	      aopPut (AOP (result), "a", offset);
+	      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 	    }
 	  else
-	    aopPut (AOP (result), l, offset);
+	    aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
 	  offset++;
 	}
     }
@@ -6751,7 +7637,7 @@ genSignedRightShift (iCode * ic)
 
   size = AOP_SIZE (result);
   offset = size - 1;
-  emitcode ("mov", "a,%s", aopGet (AOP (left), offset, FALSE, FALSE));
+  MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
   emitcode ("rlc", "a");
   emitcode ("mov", "ov,c");
   /* if it is only one byte then */
@@ -6765,7 +7651,7 @@ genSignedRightShift (iCode * ic)
       emitcode ("rrc", "a");
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
-      aopPut (AOP (result), "a", 0);
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -6778,7 +7664,7 @@ genSignedRightShift (iCode * ic)
       l = aopGet (AOP (result), offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");
-      aopPut (AOP (result), "a", offset--);
+      aopPut (AOP (result), "a", offset--, isOperandVolatile (result, FALSE));
     }
   reAdjustPreg (AOP (result));
   emitcode ("", "%05d$:", tlbl1->key + 100);
@@ -6796,18 +7682,18 @@ static void
 genRightShift (iCode * ic)
 {
   operand *right, *left, *result;
-  sym_link *retype;
+  sym_link *letype;
   int size, offset;
   char *l;
   symbol *tlbl, *tlbl1;
 
-  D(emitcode (";", "genRightShift"));
+  D(emitcode (";     genRightShift",""));
 
   /* if signed then we do it the hard way preserve the
      sign bit moving it inwards */
-  retype = getSpec (operandType (IC_RESULT (ic)));
+  letype = getSpec (operandType (IC_LEFT (ic)));
 
-  if (!SPEC_USIGN (retype))
+  if (!SPEC_USIGN (letype))
     {
       genSignedRightShift (ic);
       return;
@@ -6861,10 +7747,10 @@ genRightShift (iCode * ic)
 	    {
 
 	      emitcode ("mov", "a,%s", l);
-	      aopPut (AOP (result), "a", offset);
+	      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 	    }
 	  else
-	    aopPut (AOP (result), l, offset);
+	    aopPut (AOP (result), l, offset, isOperandVolatile (result, FALSE));
 	  offset++;
 	}
     }
@@ -6885,7 +7771,7 @@ genRightShift (iCode * ic)
       emitcode ("rrc", "a");
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
-      aopPut (AOP (result), "a", 0);
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -6898,7 +7784,7 @@ genRightShift (iCode * ic)
       l = aopGet (AOP (result), offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");
-      aopPut (AOP (result), "a", offset--);
+      aopPut (AOP (result), "a", offset--, isOperandVolatile (result, FALSE));
     }
   reAdjustPreg (AOP (result));
 
@@ -6911,116 +7797,137 @@ release:
 }
 
 /*-----------------------------------------------------------------*/
-/* genUnpackBits - generates code for unpacking bits               */
+/* emitPtrByteGet - emits code to get a byte into A through a      */
+/*                  pointer register (R0, R1, or DPTR). The        */
+/*                  original value of A can be preserved in B.     */
 /*-----------------------------------------------------------------*/
 static void
-genUnpackBits (operand * result, char *rname, int ptype)
+emitPtrByteGet (char *rname, int p_type, bool preserveAinB)
 {
-  int shCnt;
-  int rlen = 0;
-  sym_link *etype;
-  int offset = 0;
-  int rsize;
-
-  D(emitcode (";", "genUnpackBits"));
-
-  etype = getSpec (operandType (result));
-  rsize = getSize (operandType (result));
-  /* read the first byte  */
-  switch (ptype)
+  switch (p_type)
     {
-
-    case POINTER:
     case IPOINTER:
+    case POINTER:
+      if (preserveAinB)
+        emitcode ("mov", "b,a");
       emitcode ("mov", "a,@%s", rname);
       break;
 
     case PPOINTER:
+      if (preserveAinB)
+        emitcode ("mov", "b,a");
       emitcode ("movx", "a,@%s", rname);
       break;
 
     case FPOINTER:
+      if (preserveAinB)
+        emitcode ("mov", "b,a");
       emitcode ("movx", "a,@dptr");
       break;
 
     case CPOINTER:
+      if (preserveAinB)
+        emitcode ("mov", "b,a");
       emitcode ("clr", "a");
       emitcode ("movc", "a,@a+dptr");
       break;
 
     case GPOINTER:
+      if (preserveAinB)
+        {
+          emitcode ("push", "b");
+          emitcode ("push", "acc");
+        }
       emitcode ("lcall", "__gptrget");
+      if (preserveAinB)
+        emitcode ("pop", "b");
       break;
     }
+}
 
-  rlen = SPEC_BLEN (etype);
-
-  /* if we have bitdisplacement then it fits   */
-  /* into this byte completely or if length is */
-  /* less than a byte                          */
-  if ((shCnt = SPEC_BSTR (etype)) ||
-      (SPEC_BLEN (etype) <= 8))
-    {
-
-      /* shift right acc */
-      AccRsh (shCnt);
-
-      emitcode ("anl", "a,#0x%02x",
-		((unsigned char) -1) >> (8 - SPEC_BLEN (etype)));
-      aopPut (AOP (result), "a", offset++);
-      goto finish;
-    }
-
-  /* bit field did not fit in a byte  */
-  aopPut (AOP (result), "a", offset++);
-
-  while (1)
+/*-----------------------------------------------------------------*/
+/* emitPtrByteSet - emits code to set a byte from src through a    */
+/*                  pointer register (R0, R1, or DPTR).            */
+/*-----------------------------------------------------------------*/
+static void
+emitPtrByteSet (char *rname, int p_type, char *src)
+{
+  switch (p_type)
     {
+    case IPOINTER:
+    case POINTER:
+      if (*src=='@')
+        {
+          MOVA (src);
+          emitcode ("mov", "@%s,a", rname);
+        }
+      else
+        emitcode ("mov", "@%s,%s", rname, src);
+      break;
 
-      switch (ptype)
-	{
-	case POINTER:
-	case IPOINTER:
-	  emitcode ("inc", "%s", rname);
-	  emitcode ("mov", "a,@%s", rname);
-	  break;
+    case PPOINTER:
+      MOVA (src);
+      emitcode ("movx", "@%s,a", rname);
+      break;
 
-	case PPOINTER:
-	  emitcode ("inc", "%s", rname);
-	  emitcode ("movx", "a,@%s", rname);
-	  break;
+    case FPOINTER:
+      MOVA (src);
+      emitcode ("movx", "@dptr,a");
+      break;
 
-	case FPOINTER:
-	  emitcode ("inc", "dptr");
-	  emitcode ("movx", "a,@dptr");
-	  break;
+    case GPOINTER:
+      MOVA (src);
+      emitcode ("lcall", "__gptrput");
+      break;
+    }
+}
 
-	case CPOINTER:
-	  emitcode ("clr", "a");
-	  emitcode ("inc", "dptr");
-	  emitcode ("movc", "a,@a+dptr");
-	  break;
+/*-----------------------------------------------------------------*/
+/* genUnpackBits - generates code for unpacking bits               */
+/*-----------------------------------------------------------------*/
+static void
+genUnpackBits (operand * result, char *rname, int ptype)
+{
+  int offset = 0;	/* result byte offset */
+  int rsize;		/* result size */
+  int rlen = 0;		/* remaining bitfield length */
+  sym_link *etype;	/* bitfield type information */
+  int blen;		/* bitfield length */
+  int bstr;		/* bitfield starting bit within byte */
 
-	case GPOINTER:
-	  emitcode ("inc", "dptr");
-	  emitcode ("lcall", "__gptrget");
-	  break;
-	}
+  D(emitcode (";     genUnpackBits",""));
 
-      rlen -= 8;
-      /* if we are done */
-      if (rlen < 8)
-	break;
+  etype = getSpec (operandType (result));
+  rsize = getSize (operandType (result));
+  blen = SPEC_BLEN (etype);
+  bstr = SPEC_BSTR (etype);
 
-      aopPut (AOP (result), "a", offset++);
+  /* If the bitfield length is less than a byte */
+  if (blen < 8)
+    {
+      emitPtrByteGet (rname, ptype, FALSE);
+      AccRsh (bstr);
+      emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (8 - blen));
+      aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+      goto finish;
+    }
 
+  /* Bit field did not fit in a byte. Copy all
+     but the partial byte at the end.  */
+  for (rlen=blen;rlen>=8;rlen-=8)
+    {
+      emitPtrByteGet (rname, ptype, FALSE);
+      aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+      if (rlen>8)
+        emitcode ("inc", "%s", rname);
     }
 
+  /* Handle the partial byte at the end */
   if (rlen)
     {
-      //  emitcode("anl","a,#0x%02x",((unsigned char)-1)>>(rlen));
-      AccLsh (8 - rlen);
-      aopPut (AOP (result), "a", offset++);
+      emitPtrByteGet (rname, ptype, FALSE);
+      emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (8-rlen));
+      aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
     }
 
 finish:
@@ -7028,9 +7935,8 @@ finish:
     {
       rsize -= offset;
       while (rsize--)
-	aopPut (AOP (result), zero, offset++);
+	aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
     }
-  return;
 }
 
 
@@ -7046,7 +7952,7 @@ genDataPointerGet (operand * left,
   char buffer[256];
   int size, offset = 0;
 
-  D(emitcode (";", "genDataPointerGet"));
+  D(emitcode (";     genDataPointerGet",""));
 
   aopOp (result, ic, TRUE);
 
@@ -7059,7 +7965,7 @@ genDataPointerGet (operand * left,
 	sprintf (buffer, "(%s + %d)", l + 1, offset);
       else
 	sprintf (buffer, "%s", l + 1);
-      aopPut (AOP (result), buffer, offset++);
+      aopPut (AOP (result), buffer, offset++, isOperandVolatile (result, FALSE));
     }
 
   freeAsmop (left, NULL, ic, TRUE);
@@ -7082,7 +7988,7 @@ genNearPointerGet (operand * left,
   sym_link *ltype = operandType (left);
   char buffer[80];
 
-  D(emitcode (";", "genNearPointerGet"));
+  D(emitcode (";     genNearPointerGet",""));
 
   rtype = operandType (result);
   retype = getSpec (rtype);
@@ -7090,37 +7996,56 @@ genNearPointerGet (operand * left,
   aopOp (left, ic, FALSE);
 
   /* if left is rematerialisable and
-     result is not bit variable type and
+     result is not bitfield variable type and
      the left is pointer to data space i.e
      lower 128 bytes of space */
   if (AOP_TYPE (left) == AOP_IMMD &&
-      !IS_BITVAR (retype) &&
+      !IS_BITFIELD (retype) &&
       DCL_TYPE (ltype) == POINTER)
     {
       genDataPointerGet (left, result, ic);
       return;
     }
 
-  /* if the value is already in a pointer register
+ /* if the value is already in a pointer register
      then don't need anything more */
   if (!AOP_INPREG (AOP (left)))
     {
-      /* otherwise get a free pointer register */
-      aop = newAsmop (0);
-      preg = getFreePtr (ic, &aop, FALSE);
-      emitcode ("mov", "%s,%s",
-		preg->name,
-		aopGet (AOP (left), 0, FALSE, TRUE));
-      rname = preg->name;
+      if (IS_AOP_PREG (left))
+	{
+	  // Aha, it is a pointer, just in disguise.
+	  rname = aopGet (AOP (left), 0, FALSE, FALSE);
+	  if (*rname != '@')
+	    {
+	      fprintf(stderr, "probable internal error: unexpected rname @ %s:%d\n",
+		      __FILE__, __LINE__);
+	    }
+	  else
+	    {
+	      // Expected case.
+	      emitcode ("mov", "a%s,%s", rname + 1, rname);
+	      rname++;  // skip the '@'.
+	    }
+	}
+      else
+	{
+	  /* otherwise get a free pointer register */
+	  aop = newAsmop (0);
+	  preg = getFreePtr (ic, &aop, FALSE);
+	  emitcode ("mov", "%s,%s",
+		    preg->name,
+		    aopGet (AOP (left), 0, FALSE, TRUE));
+	  rname = preg->name;
+	}
     }
   else
     rname = aopGet (AOP (left), 0, FALSE, FALSE);
-  
+
   //aopOp (result, ic, FALSE);
   aopOp (result, ic, result?TRUE:FALSE);
 
   /* if bitfield then unpack the bits */
-  if (IS_BITVAR (retype))
+  if (IS_BITFIELD (retype))
     genUnpackBits (result, rname, POINTER);
   else
     {
@@ -7134,12 +8059,12 @@ genNearPointerGet (operand * left,
 	    {
 
 	      emitcode ("mov", "a,@%s", rname);
-	      aopPut (AOP (result), "a", offset);
+	      aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 	    }
 	  else
 	    {
 	      sprintf (buffer, "@%s", rname);
-	      aopPut (AOP (result), buffer, offset);
+	      aopPut (AOP (result), buffer, offset, isOperandVolatile (result, FALSE));
 	    }
 	  offset++;
 	  if (size || pi)
@@ -7151,9 +8076,9 @@ genNearPointerGet (operand * left,
   if (aop)       /* we had to allocate for this iCode */
     {
       if (pi) { /* post increment present */
-	aopPut(AOP ( left ),rname,0);
+	aopPut(AOP ( left ),rname,0, isOperandVolatile (left, FALSE));
       }
-      freeAsmop (NULL, aop, ic, TRUE);
+      freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
     }
   else
     {
@@ -7175,8 +8100,8 @@ genNearPointerGet (operand * left,
     }
 
   /* done */
+  freeAsmop (result, NULL, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
   freeAsmop (left, NULL, ic, TRUE);
-  freeAsmop (result, NULL, ic, TRUE);
   if (pi) pi->generated = 1;
 }
 
@@ -7194,7 +8119,7 @@ genPagedPointerGet (operand * left,
   char *rname;
   sym_link *rtype, *retype;
 
-  D(emitcode (";", "genPagedPointerGet"));
+  D(emitcode (";     genPagedPointerGet",""));
 
   rtype = operandType (result);
   retype = getSpec (rtype);
@@ -7219,7 +8144,7 @@ genPagedPointerGet (operand * left,
   aopOp (result, ic, FALSE);
 
   /* if bitfield then unpack the bits */
-  if (IS_BITVAR (retype))
+  if (IS_BITFIELD (retype))
     genUnpackBits (result, rname, PPOINTER);
   else
     {
@@ -7231,7 +8156,7 @@ genPagedPointerGet (operand * left,
 	{
 
 	  emitcode ("movx", "a,@%s", rname);
-	  aopPut (AOP (result), "a", offset);
+	  aopPut (AOP (result), "a", offset, isOperandVolatile (result, FALSE));
 
 	  offset++;
 
@@ -7243,7 +8168,7 @@ genPagedPointerGet (operand * left,
   /* now some housekeeping stuff */
   if (aop) /* we had to allocate for this iCode */
     {
-      if (pi) aopPut ( AOP (left), rname, 0);
+      if (pi) aopPut ( AOP (left), rname, 0, isOperandVolatile (left, FALSE));
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -7272,6 +8197,66 @@ genPagedPointerGet (operand * left,
 
 }
 
+/*--------------------------------------------------------------------*/
+/* loadDptrFromOperand - load dptr (and optionally B) from operand op */
+/*--------------------------------------------------------------------*/
+static void
+loadDptrFromOperand (operand *op, bool loadBToo)
+{
+  if (AOP_TYPE (op) != AOP_STR)
+    {
+      /* if this is remateriazable */
+      if (AOP_TYPE (op) == AOP_IMMD)
+	{
+	  emitcode ("mov", "dptr,%s", aopGet (AOP (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));
+	      else
+                {
+                  wassertl(FALSE, "need pointerCode");
+                  emitcode ("", "; mov b,???");
+                  /* genPointerGet and genPointerSet originally did different
+                  ** things for this case. Both seem wrong.
+                  ** from genPointerGet:
+		  **  emitcode ("mov", "b,#%d", pointerCode (retype));
+                  ** from genPointerSet:
+		  **  emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE));
+                  */
+                }
+            }
+	}
+      else if (AOP_TYPE (op) == AOP_DPTR)
+	{
+	  if (loadBToo)
+	    {
+	      MOVA (aopGet (AOP (op), 0, FALSE, FALSE));
+	      emitcode ("push", "acc");
+	      MOVA (aopGet (AOP (op), 1, FALSE, FALSE));
+	      emitcode ("push", "acc");
+	      emitcode ("mov", "b,%s", aopGet (AOP (op), 2, FALSE, FALSE));
+	      emitcode ("pop", "dph");
+	      emitcode ("pop", "dpl");
+	    }
+	  else
+	    {
+	      MOVA (aopGet (AOP (op), 0, FALSE, FALSE));
+	      emitcode ("push", "acc");
+	      emitcode ("mov", "dph,%s", aopGet (AOP (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));
+	  if (loadBToo)
+	    emitcode ("mov", "b,%s", aopGet (AOP (op), 2, FALSE, FALSE));
+	}
+    }
+}
+
 /*-----------------------------------------------------------------*/
 /* genFarPointerGet - gget value from far space                    */
 /*-----------------------------------------------------------------*/
@@ -7282,28 +8267,16 @@ genFarPointerGet (operand * left,
   int size, offset;
   sym_link *retype = getSpec (operandType (result));
 
-  D(emitcode (";", "genFarPointerGet"));
-
-  aopOp (left, ic, FALSE);
-
-  /* if the operand is already in dptr
-     then we do nothing else we move the value to dptr */
-  if (AOP_TYPE (left) != AOP_STR)
-    {
-      /* if this is remateriazable */
-      if (AOP_TYPE (left) == AOP_IMMD)
-	emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE));
-      else
-	{			/* we need to get it byte by byte */
-	  emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE));
-	  emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE));
-	}
-    }
-  /* so dptr know contains the address */
+  D(emitcode (";     genFarPointerGet",""));
+
+  aopOp (left, ic, FALSE);
+  loadDptrFromOperand (left, FALSE);
+
+  /* so dptr now contains the address */
   aopOp (result, ic, FALSE);
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype))
+  if (IS_BITFIELD (retype))
     genUnpackBits (result, "dptr", FPOINTER);
   else
     {
@@ -7313,15 +8286,15 @@ genFarPointerGet (operand * left,
       while (size--)
 	{
 	  emitcode ("movx", "a,@dptr");
-	  aopPut (AOP (result), "a", offset++);
+	  aopPut (AOP (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);
-    aopPut ( AOP (left), "dph", 1);
+    aopPut ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
+    aopPut ( AOP (left), "dph", 1, isOperandVolatile (left, FALSE));
     pi->generated = 1;
   }
   freeAsmop (left, NULL, ic, TRUE);
@@ -7338,28 +8311,16 @@ genCodePointerGet (operand * left,
   int size, offset;
   sym_link *retype = getSpec (operandType (result));
 
-  D(emitcode (";", "genCodePointerGet"));
+  D(emitcode (";     genCodePointerGet",""));
 
   aopOp (left, ic, FALSE);
+  loadDptrFromOperand (left, FALSE);
 
-  /* if the operand is already in dptr
-     then we do nothing else we move the value to dptr */
-  if (AOP_TYPE (left) != AOP_STR)
-    {
-      /* if this is remateriazable */
-      if (AOP_TYPE (left) == AOP_IMMD)
-	emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE));
-      else
-	{			/* we need to get it byte by byte */
-	  emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE));
-	  emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE));
-	}
-    }
-  /* so dptr know contains the address */
+  /* so dptr now contains the address */
   aopOp (result, ic, FALSE);
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype))
+  if (IS_BITFIELD (retype))
     genUnpackBits (result, "dptr", CPOINTER);
   else
     {
@@ -7368,17 +8329,25 @@ genCodePointerGet (operand * left,
 
       while (size--)
 	{
-	  emitcode ("clr", "a");
-	  emitcode ("movc", "a,@a+dptr");
-	  aopPut (AOP (result), "a", offset++);
-	  if (size || pi)
-	    emitcode ("inc", "dptr");
+	  if (pi)
+	    {
+	      emitcode ("clr", "a");
+	      emitcode ("movc", "a,@a+dptr");
+	      aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+   	      emitcode ("inc", "dptr");
+	    }
+	  else
+	    {
+	      emitcode ("mov", "a,#0x%02x", offset);
+	      emitcode ("movc", "a,@a+dptr");
+	      aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
+	    }
 	}
     }
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR) {
-    aopPut ( AOP (left), "dpl", 0);
-    aopPut ( AOP (left), "dph", 1);
+    aopPut ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
+    aopPut ( AOP (left), "dph", 1, isOperandVolatile (left, FALSE));
     pi->generated = 1;
   }
   freeAsmop (left, NULL, ic, TRUE);
@@ -7395,35 +8364,16 @@ genGenPointerGet (operand * left,
   int size, offset;
   sym_link *retype = getSpec (operandType (result));
 
-  D(emitcode (";", "genGenPointerGet"));
+  D(emitcode (";     genGenPointerGet",""));
 
   aopOp (left, ic, FALSE);
+  loadDptrFromOperand (left, TRUE);
 
-  /* if the operand is already in dptr
-     then we do nothing else we move the value to dptr */
-  if (AOP_TYPE (left) != AOP_STR)
-    {
-      /* if this is remateriazable */
-      if (AOP_TYPE (left) == AOP_IMMD)
-	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE));
-	  if (AOP(left)->aopu.aop_immd.from_cast_remat) 
-		  emitcode ("mov", "b,%s",aopGet(AOP (left), AOP_SIZE(left)-1, FALSE, FALSE));
-	  else
-		  emitcode ("mov", "b,#%d", pointerCode (retype));
-	}
-      else
-	{			/* we need to get it byte by byte */
-	  emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE));
-	  emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE));
-	  emitcode ("mov", "b,%s", aopGet (AOP (left), 2, FALSE, FALSE));
-	}
-    }
   /* so dptr know contains the address */
   aopOp (result, ic, FALSE);
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype))
+  if (IS_BITFIELD (retype))
     genUnpackBits (result, "dptr", GPOINTER);
   else
     {
@@ -7433,16 +8383,15 @@ genGenPointerGet (operand * left,
       while (size--)
 	{
 	  emitcode ("lcall", "__gptrget");
-	  aopPut (AOP (result), "a", offset++);
+	  aopPut (AOP (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);
-    aopPut ( AOP (left), "dph", 1);
-    aopPut ( AOP (left), "b", 2);
+    aopPut ( AOP (left), "dpl", 0, isOperandVolatile (left, FALSE));
+    aopPut ( AOP (left), "dph", 1, isOperandVolatile (left, FALSE));
     pi->generated = 1;
   }
   freeAsmop (left, NULL, ic, TRUE);
@@ -7459,7 +8408,7 @@ genPointerGet (iCode * ic, iCode *pi)
   sym_link *type, *etype;
   int p_type;
 
-  D(emitcode (";", "genPointerGet"));
+  D(emitcode (";     genPointerGet",""));
 
   left = IC_LEFT (ic);
   result = IC_RESULT (ic);
@@ -7481,7 +8430,7 @@ genPointerGet (iCode * ic, iCode *pi)
   if (p_type == GPOINTER && OP_SYMBOL(left)->remat &&
       IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) {
 	  left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
-	  type =   type = operandType (left);
+	  type = operandType (left);
 	  p_type = DCL_TYPE (type);
   }
   /* now that we have the pointer type we assign
@@ -7513,6 +8462,8 @@ genPointerGet (iCode * ic, iCode *pi)
 
 }
 
+
+
 /*-----------------------------------------------------------------*/
 /* genPackBits - generates code for packed bit storage             */
 /*-----------------------------------------------------------------*/
@@ -7521,168 +8472,125 @@ genPackBits (sym_link * etype,
 	     operand * right,
 	     char *rname, int p_type)
 {
-  int shCount = 0;
-  int offset = 0;
-  int rLen = 0;
-  int blen, bstr;
-  char *l;
+  int offset = 0;	/* source byte offset */
+  int rlen = 0;		/* remaining bitfield length */
+  int blen;		/* bitfield length */
+  int bstr;		/* bitfield starting bit within byte */
+  int litval;		/* source literal value (if AOP_LIT) */
+  unsigned char mask;	/* bitmask within current byte */
 
-  D(emitcode (";", "genPackBits"));
+  D(emitcode (";     genPackBits",""));
 
   blen = SPEC_BLEN (etype);
   bstr = SPEC_BSTR (etype);
 
-  l = aopGet (AOP (right), offset++, FALSE, FALSE);
-  MOVA (l);
-
-  /* if the bit lenth is less than or    */
-  /* it exactly fits a byte then         */
-  if (SPEC_BLEN (etype) <= 8)
-    {
-      shCount = SPEC_BSTR (etype);
-
-      /* shift left acc */
-      AccLsh (shCount);
-
-      if (SPEC_BLEN (etype) < 8)
-	{			/* if smaller than a byte */
-
-
-	  switch (p_type)
-	    {
-	    case POINTER:
-	      emitcode ("mov", "b,a");
-	      emitcode ("mov", "a,@%s", rname);
-	      break;
-
-	    case FPOINTER:
-	      emitcode ("mov", "b,a");
-	      emitcode ("movx", "a,@dptr");
-	      break;
-
-	    case GPOINTER:
-	      emitcode ("push", "b");
-	      emitcode ("push", "acc");
-	      emitcode ("lcall", "__gptrget");
-	      emitcode ("pop", "b");
-	      break;
-	    }
-
-	  emitcode ("anl", "a,#0x%02x", (unsigned char)
-		    ((unsigned char) (0xFF << (blen + bstr)) |
-		     (unsigned char) (0xFF >> (8 - bstr))));
-	  emitcode ("orl", "a,b");
-	  if (p_type == GPOINTER)
-	    emitcode ("pop", "b");
-	}
-    }
-
-  switch (p_type)
+  /* If the bitfield length is less than a byte */
+  if (blen < 8)
     {
-    case POINTER:
-      emitcode ("mov", "@%s,a", rname);
-      break;
-
-    case FPOINTER:
-      emitcode ("movx", "@dptr,a");
-      break;
+      mask = ((unsigned char) (0xFF << (blen + bstr)) |
+	      (unsigned char) (0xFF >> (8 - bstr)));
 
-    case GPOINTER:
-      emitcode ("lcall", "__gptrput");
-      break;
+      if (AOP_TYPE (right) == AOP_LIT)
+        {
+          /* Case with a bitfield length <8 and literal source
+          */
+          litval = (int) floatFromVal (AOP (right)->aopu.aop_lit);
+          litval <<= bstr;
+          litval &= (~mask) & 0xff;
+          emitPtrByteGet (rname, p_type, FALSE);
+          if ((mask|litval)!=0xff)
+            emitcode ("anl","a,#0x%02x", mask);
+          if (litval)
+            emitcode ("orl","a,#0x%02x", litval);
+        }
+      else
+        {
+          if ((blen==1) && (p_type!=GPOINTER))
+            {
+              /* Case with a bitfield length == 1 and no generic pointer
+              */
+              if (AOP_TYPE (right) == AOP_CRY)
+                emitcode ("mov", "c,%s", AOP(right)->aopu.aop_dir);
+              else
+                {
+                  MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+                  emitcode ("rrc","a");
+                }
+              emitPtrByteGet (rname, p_type, FALSE);
+              emitcode ("mov","acc.%d,c",bstr);
+            }
+          else
+            {
+              /* Case with a bitfield length < 8 and arbitrary source
+              */
+              MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+              /* shift and mask source value */
+              AccLsh (bstr);
+              emitcode ("anl", "a,#0x%02x", (~mask) & 0xff);
+
+    	      /* transfer A to B and get next byte */
+              emitPtrByteGet (rname, p_type, TRUE);
+
+              emitcode ("anl", "a,#0x%02x", mask);
+              emitcode ("orl", "a,b");
+              if (p_type == GPOINTER)
+                emitcode ("pop", "b");
+           }
+        }
+
+      emitPtrByteSet (rname, p_type, "a");
+      return;
     }
 
-  /* if we r done */
-  if (SPEC_BLEN (etype) <= 8)
-    return;
-
-  emitcode ("inc", "%s", rname);
-  rLen = SPEC_BLEN (etype);
-
-  /* now generate for lengths greater than one byte */
-  while (1)
+  /* Bit length is greater than 7 bits. In this case, copy  */
+  /* all except the partial byte at the end                 */
+  for (rlen=blen;rlen>=8;rlen-=8)
     {
-
-      l = aopGet (AOP (right), offset++, FALSE, TRUE);
-
-      rLen -= 8;
-      if (rLen < 8)
-	break;
-
-      switch (p_type)
-	{
-	case POINTER:
-	  if (*l == '@')
-	    {
-	      MOVA (l);
-	      emitcode ("mov", "@%s,a", rname);
-	    }
-	  else
-	    emitcode ("mov", "@%s,%s", rname, l);
-	  break;
-
-	case FPOINTER:
-	  MOVA (l);
-	  emitcode ("movx", "@dptr,a");
-	  break;
-
-	case GPOINTER:
-	  MOVA (l);
-	  emitcode ("lcall", "__gptrput");
-	  break;
-	}
-      emitcode ("inc", "%s", rname);
+      emitPtrByteSet (rname, p_type,
+                      aopGet (AOP (right), offset++, FALSE, TRUE) );
+      if (rlen>8)
+        emitcode ("inc", "%s", rname);
     }
 
-  MOVA (l);
-
-  /* last last was not complete */
-  if (rLen)
+  /* If there was a partial byte at the end */
+  if (rlen)
     {
-      /* save the byte & read byte */
-      switch (p_type)
-	{
-	case POINTER:
-	  emitcode ("mov", "b,a");
-	  emitcode ("mov", "a,@%s", rname);
-	  break;
+      mask = (((unsigned char) -1 << rlen) & 0xff);
 
-	case FPOINTER:
-	  emitcode ("mov", "b,a");
-	  emitcode ("movx", "a,@dptr");
-	  break;
+      if (AOP_TYPE (right) == AOP_LIT)
+        {
+          /* Case with partial byte and literal source
+          */
+          litval = (int) floatFromVal (AOP (right)->aopu.aop_lit);
+          litval >>= (blen-rlen);
+          litval &= (~mask) & 0xff;
+          emitPtrByteGet (rname, p_type, FALSE);
+          if ((mask|litval)!=0xff)
+            emitcode ("anl","a,#0x%02x", mask);
+          if (litval)
+            emitcode ("orl","a,#0x%02x", litval);
+        }
+      else
+        {
+          /* Case with partial byte and arbitrary source
+          */
+          MOVA (aopGet (AOP (right), offset++, FALSE, FALSE));
+          emitcode ("anl", "a,#0x%02x", (~mask) & 0xff);
 
-	case GPOINTER:
-	  emitcode ("push", "b");
-	  emitcode ("push", "acc");
-	  emitcode ("lcall", "__gptrget");
-	  emitcode ("pop", "b");
-	  break;
-	}
+	  /* transfer A to B and get next byte */
+          emitPtrByteGet (rname, p_type, TRUE);
 
-      emitcode ("anl", "a,#0x%02x", (((unsigned char) -1 << rLen) & 0xff));
-      emitcode ("orl", "a,b");
+          emitcode ("anl", "a,#0x%02x", mask);
+          emitcode ("orl", "a,b");
+          if (p_type == GPOINTER)
+            emitcode ("pop", "b");
+        }
+      emitPtrByteSet (rname, p_type, "a");
     }
 
-  if (p_type == GPOINTER)
-    emitcode ("pop", "b");
-
-  switch (p_type)
-    {
-
-    case POINTER:
-      emitcode ("mov", "@%s,a", rname);
-      break;
+}
 
-    case FPOINTER:
-      emitcode ("movx", "@dptr,a");
-      break;
 
-    case GPOINTER:
-      emitcode ("lcall", "__gptrput");
-      break;
-    }
-}
 /*-----------------------------------------------------------------*/
 /* genDataPointerSet - remat pointer to data space                 */
 /*-----------------------------------------------------------------*/
@@ -7694,7 +8602,7 @@ genDataPointerSet (operand * right,
   int size, offset = 0;
   char *l, buffer[256];
 
-  D(emitcode (";", "genDataPointerSet"));
+  D(emitcode (";     genDataPointerSet",""));
 
   aopOp (right, ic, FALSE);
 
@@ -7729,7 +8637,7 @@ genNearPointerSet (operand * right,
   sym_link *retype, *letype;
   sym_link *ptype = operandType (result);
 
-  D(emitcode (";", "genNearPointerSet"));
+  D(emitcode (";     genNearPointerSet",""));
 
   retype = getSpec (operandType (right));
   letype = getSpec (ptype);
@@ -7745,7 +8653,7 @@ genNearPointerSet (operand * right,
       genDataPointerSet (right, result, ic);
       return;
     }
-  
+
   /* if the value is already in a pointer register
      then don't need anything more */
   if (!AOP_INPREG (AOP (result)))
@@ -7765,6 +8673,7 @@ genNearPointerSet (operand * right,
 	    else
 	    {
 		// Expected case.
+	        emitcode ("mov", "a%s,%s", rname + 1, rname);
 		rname++;  // skip the '@'.
 	    }
 	}
@@ -7785,10 +8694,10 @@ genNearPointerSet (operand * right,
     }
 
   aopOp (right, ic, FALSE);
-    
+
   /* if bitfield then unpack the bits */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, rname, POINTER);
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
+    genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, rname, POINTER);
   else
     {
       /* we have can just get the values */
@@ -7814,7 +8723,8 @@ genNearPointerSet (operand * right,
   /* now some housekeeping stuff */
   if (aop) /* we had to allocate for this iCode */
     {
-      if (pi) aopPut (AOP (result),rname,0);
+      if (pi)
+        aopPut (AOP (result), rname, 0, isOperandVolatile (result, FALSE));
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -7856,7 +8766,7 @@ genPagedPointerSet (operand * right,
   char *rname, *l;
   sym_link *retype, *letype;
 
-  D(emitcode (";", "genPagedPointerSet"));
+  D(emitcode (";     genPagedPointerSet",""));
 
   retype = getSpec (operandType (right));
   letype = getSpec (operandType (result));
@@ -7881,8 +8791,8 @@ genPagedPointerSet (operand * right,
   aopOp (right, ic, FALSE);
 
   /* if bitfield then unpack the bits */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, rname, PPOINTER);
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
+    genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, rname, PPOINTER);
   else
     {
       /* we have can just get the values */
@@ -7906,7 +8816,8 @@ genPagedPointerSet (operand * right,
   /* now some housekeeping stuff */
   if (aop) /* we had to allocate for this iCode */
     {
-      if (pi) aopPut (AOP (result),rname,0);
+      if (pi)
+        aopPut (AOP (result), rname, 0, isOperandVolatile (result, FALSE));
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -7946,29 +8857,17 @@ genFarPointerSet (operand * right,
   sym_link *retype = getSpec (operandType (right));
   sym_link *letype = getSpec (operandType (result));
 
-  D(emitcode (";", "genFarPointerSet"));
+  D(emitcode (";     genFarPointerSet",""));
 
   aopOp (result, ic, FALSE);
+  loadDptrFromOperand (result, FALSE);
 
-  /* if the operand is already in dptr
-     then we do nothing else we move the value to dptr */
-  if (AOP_TYPE (result) != AOP_STR)
-    {
-      /* if this is remateriazable */
-      if (AOP_TYPE (result) == AOP_IMMD)
-	emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE));
-      else
-	{			/* we need to get it byte by byte */
-	  emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE));
-	  emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE));
-	}
-    }
   /* so dptr know contains the address */
   aopOp (right, ic, FALSE);
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", FPOINTER);
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
+    genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, "dptr", FPOINTER);
   else
     {
       size = AOP_SIZE (right);
@@ -7984,8 +8883,8 @@ genFarPointerSet (operand * right,
 	}
     }
   if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
-    aopPut (AOP(result),"dpl",0);
-    aopPut (AOP(result),"dph",1);
+    aopPut (AOP(result), "dpl", 0, isOperandVolatile (result, FALSE));
+    aopPut (AOP(result), "dph", 1, isOperandVolatile (result, FALSE));
     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);
@@ -8003,36 +8902,17 @@ genGenPointerSet (operand * right,
   sym_link *retype = getSpec (operandType (right));
   sym_link *letype = getSpec (operandType (result));
 
-  D(emitcode (";", "genGenPointerSet"));
+  D(emitcode (";     genGenPointerSet",""));
 
   aopOp (result, ic, FALSE);
+  loadDptrFromOperand (result, TRUE);
 
-  /* if the operand is already in dptr
-     then we do nothing else we move the value to dptr */
-  if (AOP_TYPE (result) != AOP_STR)
-    {
-      /* if this is remateriazable */
-      if (AOP_TYPE (result) == AOP_IMMD)
-	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE));
-	  if (AOP(result)->aopu.aop_immd.from_cast_remat) 
-		  emitcode ("mov", "b,%s",aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE));
-	  else 
-		  emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE));
-	}
-      else
-	{			/* we need to get it byte by byte */
-	  emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE));
-	  emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE));
-	  emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE));
-	}
-    }
   /* so dptr know contains the address */
   aopOp (right, ic, FALSE);
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", GPOINTER);
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
+    genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, "dptr", GPOINTER);
   else
     {
       size = AOP_SIZE (right);
@@ -8049,9 +8929,8 @@ genGenPointerSet (operand * right,
     }
 
   if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
-    aopPut (AOP(result),"dpl",0);
-    aopPut (AOP(result),"dph",1);
-    aopPut (AOP(result),"b",2);
+    aopPut (AOP(result), "dpl", 0, isOperandVolatile (result, FALSE));
+    aopPut (AOP(result), "dph", 1, isOperandVolatile (result, FALSE));
     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);
@@ -8068,7 +8947,7 @@ genPointerSet (iCode * ic, iCode *pi)
   sym_link *type, *etype;
   int p_type;
 
-  D(emitcode (";", "genPointerSet"));
+  D(emitcode (";     genPointerSet",""));
 
   right = IC_RIGHT (ic);
   result = IC_RESULT (ic);
@@ -8092,7 +8971,7 @@ genPointerSet (iCode * ic, iCode *pi)
   if (p_type == GPOINTER && OP_SYMBOL(result)->remat &&
       IS_CAST_ICODE(OP_SYMBOL(result)->rematiCode)) {
 	  result = IC_RIGHT(OP_SYMBOL(result)->rematiCode);
-	  type =   type = operandType (result);
+	  type = operandType (result);
 	  p_type = DCL_TYPE (type);
   }
   /* now that we have the pointer type we assign
@@ -8116,6 +8995,10 @@ genPointerSet (iCode * ic, iCode *pi)
     case GPOINTER:
       genGenPointerSet (right, result, ic, pi);
       break;
+
+    default:
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+	      "genPointerSet: illegal pointer type");
     }
 
 }
@@ -8129,7 +9012,7 @@ genIfx (iCode * ic, iCode * popIc)
   operand *cond = IC_COND (ic);
   int isbit = 0;
 
-  D(emitcode (";", "genIfx"));
+  D(emitcode (";     genIfx",""));
 
   aopOp (cond, ic, FALSE);
 
@@ -8166,7 +9049,7 @@ genAddrOf (iCode * ic)
   symbol *sym = OP_SYMBOL (IC_LEFT (ic));
   int size, offset;
 
-  D(emitcode (";", "genAddrOf"));
+  D(emitcode (";     genAddrOf",""));
 
   aopOp (IC_RESULT (ic), ic, FALSE);
 
@@ -8183,12 +9066,12 @@ genAddrOf (iCode * ic)
 	  emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ?
 					 ((char) (sym->stack - _G.nRegsSaved)) :
 					 ((char) sym->stack)) & 0xff);
-	  aopPut (AOP (IC_RESULT (ic)), "a", 0);
+	  aopPut (AOP (IC_RESULT (ic)), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
 	}
       else
 	{
 	  /* we can just move _bp */
-	  aopPut (AOP (IC_RESULT (ic)), "_bp", 0);
+	  aopPut (AOP (IC_RESULT (ic)), "_bp", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
 	}
       /* fill the result with zero */
       size = AOP_SIZE (IC_RESULT (ic)) - 1;
@@ -8196,7 +9079,7 @@ genAddrOf (iCode * ic)
       offset = 1;
       while (size--)
 	{
-	  aopPut (AOP (IC_RESULT (ic)), zero, offset++);
+	  aopPut (AOP (IC_RESULT (ic)), zero, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
 	}
 
       goto release;
@@ -8215,7 +9098,7 @@ genAddrOf (iCode * ic)
 		 offset * 8);
       else
 	sprintf (s, "#%s", sym->rname);
-      aopPut (AOP (IC_RESULT (ic)), s, offset++);
+      aopPut (AOP (IC_RESULT (ic)), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
     }
 
 release:
@@ -8233,7 +9116,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   int offset = 0;
   char *l;
 
-  D(emitcode (";", "genFarFarAssign"));
+  D(emitcode (";     genFarFarAssign",""));
 
   /* first push the right side on to the stack */
   while (size--)
@@ -8250,7 +9133,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   while (size--)
     {
       emitcode ("pop", "acc");
-      aopPut (AOP (result), "a", --offset);
+      aopPut (AOP (result), "a", --offset, isOperandVolatile (result, FALSE));
     }
   freeAsmop (result, NULL, ic, FALSE);
 
@@ -8266,13 +9149,15 @@ genAssign (iCode * ic)
   int size, offset;
   unsigned long lit = 0L;
 
-  D(emitcode(";","genAssign"));
+  D(emitcode(";     genAssign",""));
 
   result = IC_RESULT (ic);
   right = IC_RIGHT (ic);
 
   /* if they are the same */
-  if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
+  if (operandsEqu (result, right) &&
+      !isOperandVolatile (result, FALSE) &&
+      !isOperandVolatile (right, FALSE))
     return;
 
   aopOp (right, ic, FALSE);
@@ -8290,7 +9175,9 @@ genAssign (iCode * ic)
   aopOp (result, ic, TRUE);
 
   /* if they are the same registers */
-  if (sameRegs (AOP (right), AOP (result)))
+  if (sameRegs (AOP (right), AOP (result)) &&
+      !isOperandVolatile (result, FALSE) &&
+      !isOperandVolatile (right, FALSE))
     goto release;
 
   /* if the result is a bit */
@@ -8302,9 +9189,9 @@ genAssign (iCode * ic)
       if (AOP_TYPE (right) == AOP_LIT)
 	{
 	  if (((int) operandLitValue (right)))
-	    aopPut (AOP (result), one, 0);
+	    aopPut (AOP (result), one, 0, isOperandVolatile (result, FALSE));
 	  else
-	    aopPut (AOP (result), zero, 0);
+	    aopPut (AOP (result), zero, 0, isOperandVolatile (result, FALSE));
 	  goto release;
 	}
 
@@ -8312,13 +9199,13 @@ genAssign (iCode * ic)
       if (AOP_TYPE (right) == AOP_CRY)
 	{
 	  emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-	  aopPut (AOP (result), "c", 0);
+	  aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
 	  goto release;
 	}
 
       /* we need to or */
       toBoolean (right);
-      aopPut (AOP (result), "a", 0);
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
@@ -8338,11 +9225,12 @@ genAssign (iCode * ic)
       while (size--)
 	{
 	  if ((unsigned int) ((lit >> (size * 8)) & 0x0FFL) == 0)
-	    aopPut (AOP (result), "a", size);
+	    aopPut (AOP (result), "a", size, isOperandVolatile (result, FALSE));
 	  else
 	    aopPut (AOP (result),
 		    aopGet (AOP (right), size, FALSE, FALSE),
-		    size);
+		    size,
+		    isOperandVolatile (result, FALSE));
 	}
     }
   else
@@ -8351,7 +9239,8 @@ genAssign (iCode * ic)
 	{
 	  aopPut (AOP (result),
 		  aopGet (AOP (right), offset, FALSE, FALSE),
-		  offset);
+		  offset,
+		  isOperandVolatile (result, FALSE));
 	  offset++;
 	}
     }
@@ -8370,7 +9259,7 @@ genJumpTab (iCode * ic)
   symbol *jtab;
   char *l;
 
-  D(emitcode (";", "genJumpTab"));
+  D(emitcode (";     genJumpTab",""));
 
   aopOp (IC_JTCOND (ic), ic, FALSE);
   /* get the condition into accumulator */
@@ -8404,7 +9293,7 @@ genCast (iCode * ic)
   operand *right = IC_RIGHT (ic);
   int size, offset;
 
-  D(emitcode(";", "genCast"));
+  D(emitcode(";     genCast",""));
 
   /* if they are equivalent then do nothing */
   if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
@@ -8413,18 +9302,19 @@ genCast (iCode * ic)
   aopOp (right, ic, FALSE);
   aopOp (result, ic, FALSE);
 
-  /* if the result is a bit */
-  // if (AOP_TYPE (result) == AOP_CRY /* works only for true symbols */
-  if (IS_BITVAR(OP_SYMBOL(result)->type))
+  /* 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 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);
+	    aopPut (AOP (result), one, 0, isOperandVolatile (result, FALSE));
 	  else
-	    aopPut (AOP (result), zero, 0);
+	    aopPut (AOP (result), zero, 0, isOperandVolatile (result, FALSE));
 
 	  goto release;
 	}
@@ -8433,16 +9323,17 @@ genCast (iCode * ic)
       if (AOP_TYPE (right) == AOP_CRY)
 	{
 	  emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-	  aopPut (AOP (result), "c", 0);
+	  aopPut (AOP (result), "c", 0, isOperandVolatile (result, FALSE));
 	  goto release;
 	}
 
       /* we need to or */
       toBoolean (right);
-      aopPut (AOP (result), "a", 0);
+      aopPut (AOP (result), "a", 0, isOperandVolatile (result, FALSE));
       goto release;
     }
 
+
   /* if they are the same size : or less */
   if (AOP_SIZE (result) <= AOP_SIZE (right))
     {
@@ -8458,7 +9349,8 @@ genCast (iCode * ic)
 	{
 	  aopPut (AOP (result),
 		  aopGet (AOP (right), offset, FALSE, FALSE),
-		  offset);
+		  offset,
+		  isOperandVolatile (result, FALSE));
 	  offset++;
 	}
       goto release;
@@ -8476,8 +9368,6 @@ genCast (iCode * ic)
       /* pointer to generic pointer */
       if (IS_GENPTR (ctype))
 	{
-	  char *l = zero;
-
 	  if (IS_PTR (type))
 	    p_type = DCL_TYPE (type);
 	  else
@@ -8498,36 +9388,24 @@ genCast (iCode * ic)
 	    {
 	      aopPut (AOP (result),
 		      aopGet (AOP (right), offset, FALSE, FALSE),
-		      offset);
+		      offset,
+		      isOperandVolatile (result, FALSE));
 	      offset++;
 	    }
 	  /* the last byte depending on type */
-	  switch (p_type)
 	    {
-	    case IPOINTER:
-	    case POINTER:
-	      l = zero;
-	      break;
-	    case FPOINTER:
-	      l = one;
-	      break;
-	    case CPOINTER:
-	      l = "#0x02";
-	      break;
-	    case GPOINTER:
-	      l = "0x03";
-	      break;
-	    case PPOINTER: // what the fck is this?
-	      l = "#0x03";
-	      break;
+		int gpVal = pointerTypeToGPByte(p_type, NULL, NULL);
+		char gpValStr[10];
 
-	    default:
-	      /* this should never happen */
-	      werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-		      "got unknown pointer type");
-	      exit (1);
+		if (gpVal == -1)
+		{
+		    // pointerTypeToGPByte will have bitched.
+		    exit(1);
+		}
+
+		sprintf(gpValStr, "#0x%d", gpVal);
+		aopPut (AOP (result), gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
 	    }
-	  aopPut (AOP (result), l, GPTRSIZE - 1);
 	  goto release;
 	}
 
@@ -8538,7 +9416,8 @@ genCast (iCode * ic)
 	{
 	  aopPut (AOP (result),
 		  aopGet (AOP (right), offset, FALSE, FALSE),
-		  offset);
+		  offset,
+		  isOperandVolatile (result, FALSE));
 	  offset++;
 	}
       goto release;
@@ -8553,17 +9432,18 @@ genCast (iCode * ic)
     {
       aopPut (AOP (result),
 	      aopGet (AOP (right), offset, FALSE, FALSE),
-	      offset);
+	      offset,
+	      isOperandVolatile (result, FALSE));
       offset++;
     }
 
   /* now depending on the sign of the source && destination */
   size = AOP_SIZE (result) - AOP_SIZE (right);
   /* if unsigned or not an integral type */
-  if (SPEC_USIGN (rtype) || !IS_SPEC (rtype) || AOP_TYPE(right)==AOP_CRY)
+  if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE(right)==AOP_CRY)
     {
       while (size--)
-	aopPut (AOP (result), zero, offset++);
+	aopPut (AOP (result), zero, offset++, isOperandVolatile (result, FALSE));
     }
   else
     {
@@ -8574,7 +9454,7 @@ genCast (iCode * ic)
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
-	aopPut (AOP (result), "a", offset++);
+	aopPut (AOP (result), "a", offset++, isOperandVolatile (result, FALSE));
     }
 
   /* we are done hurray !!!! */
@@ -8595,7 +9475,7 @@ genDjnz (iCode * ic, iCode * ifx)
   if (!ifx)
     return 0;
 
-  D(emitcode (";", "genDjnz"));
+  D(emitcode (";     genDjnz",""));
 
   /* if the if condition has a false label
      then we cannot save */
@@ -8629,7 +9509,7 @@ genDjnz (iCode * ic, iCode * ifx)
        * it back after the decrement.
        */
       char *rByte = aopGet(AOP(IC_RESULT(ic)), 0, FALSE, FALSE);
-      
+
       if (strcmp(rByte, "a"))
       {
            /* Something is hopelessly wrong */
@@ -8642,14 +9522,14 @@ genDjnz (iCode * ic, iCode * ifx)
            return 0;
       }
       emitcode ("dec", "%s", rByte);
-      aopPut(AOP(IC_RESULT(ic)), rByte, 0);
+      aopPut(AOP(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));
-      emitcode ("mov", "a,%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
+      MOVA (aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
       emitcode ("jnz", "%05d$", lbl->key + 100);
     }
   else
@@ -8673,100 +9553,204 @@ genDjnz (iCode * ic, iCode * ifx)
 static void
 genReceive (iCode * ic)
 {
-  D(emitcode (";", "genReceive"));
+    int size = getSize (operandType (IC_RESULT (ic)));
+    int offset = 0;
+  D(emitcode (";     genReceive",""));
 
-  if (isOperandInFarSpace (IC_RESULT (ic)) &&
-      (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
-       IS_TRUE_SYMOP (IC_RESULT (ic))))
-    {
+  if (ic->argreg == 1) { /* first parameter */
+      if (isOperandInFarSpace (IC_RESULT (ic)) &&
+	  (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
+	   IS_TRUE_SYMOP (IC_RESULT (ic)))) {
 
-      int size = getSize (operandType (IC_RESULT (ic)));
-      int offset = fReturnSizeMCS51 - size;
-      while (size--)
-	{
-	  emitcode ("push", "%s", (strcmp (fReturn[fReturnSizeMCS51 - offset - 1], "a") ?
-				fReturn[fReturnSizeMCS51 - offset - 1] : "acc"));
-	  offset++;
-	}
+	  regs *tempRegs[4];
+	  int receivingA = 0;
+	  int roffset = 0;
+
+	  for (offset = 0; offset<size; offset++)
+	    if (!strcmp (fReturn[offset], "a"))
+	      receivingA = 1;
+
+	  if (!receivingA)
+	    {
+	      if (size==1 || getTempRegs(tempRegs, size-1, ic))
+		{
+		  for (offset = size-1; offset>0; offset--)
+		    emitcode("mov","%s,%s", tempRegs[roffset++]->name, fReturn[offset]);
+		  emitcode("mov","a,%s", fReturn[0]);
+		  _G.accInUse++;
+		  aopOp (IC_RESULT (ic), ic, FALSE);
+		  _G.accInUse--;
+		  aopPut (AOP (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,
+			    isOperandVolatile (IC_RESULT (ic), FALSE));
+		  goto release;
+		}
+	    }
+	  else
+	    {
+	      if (getTempRegs(tempRegs, size, ic))
+		{
+		  for (offset = 0; offset<size; offset++)
+		    emitcode("mov","%s,%s", tempRegs[offset]->name, fReturn[offset]);
+		  aopOp (IC_RESULT (ic), ic, FALSE);
+		  for (offset = 0; offset<size; offset++)
+		    aopPut (AOP (IC_RESULT (ic)), tempRegs[offset]->name, offset,
+			    isOperandVolatile (IC_RESULT (ic), FALSE));
+		  goto release;
+		}
+	    }
+
+	  offset = fReturnSizeMCS51 - 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--) {
+	      emitcode ("pop", "acc");
+	      aopPut (AOP (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 */
+      int rb1off ;
       aopOp (IC_RESULT (ic), ic, FALSE);
-      size = AOP_SIZE (IC_RESULT (ic));
-      offset = 0;
-      while (size--)
+      rb1off = ic->argreg;
+      while (size--) {
+	  aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+      }
+  }
+
+release:
+  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDummyRead - generate code for dummy read of volatiles        */
+/*-----------------------------------------------------------------*/
+static void
+genDummyRead (iCode * ic)
+{
+  operand *op;
+  int size, offset;
+
+  D(emitcode(";     genDummyRead",""));
+
+  op = IC_RIGHT (ic);
+  if (op && IS_SYMOP (op))
+    {
+      aopOp (op, ic, FALSE);
+
+      /* if the result is a bit */
+      if (AOP_TYPE (op) == AOP_CRY)
+        emitcode ("mov", "c,%s", AOP (op)->aopu.aop_dir);
+      else
 	{
-	  emitcode ("pop", "acc");
-	  aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+	  /* bit variables done */
+	  /* general case */
+	  size = AOP_SIZE (op);
+	  offset = 0;
+	  while (size--)
+	  {
+	    MOVA (aopGet (AOP (op), offset, FALSE, FALSE));
+	    offset++;
+	  }
 	}
 
+      freeAsmop (op, NULL, ic, TRUE);
     }
-  else
+
+  op = IC_LEFT (ic);
+  if (op && IS_SYMOP (op))
     {
-      _G.accInUse++;
-      aopOp (IC_RESULT (ic), ic, FALSE);
-      _G.accInUse--;
-      assignResultValue (IC_RESULT (ic));
-    }
+      aopOp (op, ic, FALSE);
 
-  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+      /* if the result is a bit */
+      if (AOP_TYPE (op) == AOP_CRY)
+        emitcode ("mov", "c,%s", AOP (op)->aopu.aop_dir);
+      else
+	{
+	  /* bit variables done */
+	  /* general case */
+	  size = AOP_SIZE (op);
+	  offset = 0;
+	  while (size--)
+	  {
+	    MOVA (aopGet (AOP (op), offset, FALSE, FALSE));
+	    offset++;
+	  }
+	}
+
+      freeAsmop (op, NULL, ic, TRUE);
+    }
 }
 
 /*-----------------------------------------------------------------*/
-/* gen51AggregateAssign - copy complete array's or structures            */
+/* genCritical - generate code for start of a critical sequence    */
 /*-----------------------------------------------------------------*/
-void gen51AggregateAssign(iCode *ic) {
-  operand *left=IC_LEFT(ic);
-  operand *right=IC_RIGHT(ic);
-  char *fromName=OP_SYMBOL(right)->rname;
-  char *toName=OP_SYMBOL(left)->rname;
-  int fromSize=getSize(OP_SYMBOL(right)->type);
-  int toSize=getSize(OP_SYMBOL(left)->type);
-  int count=toSize;
+static void
+genCritical (iCode *ic)
+{
+  symbol *tlbl = newiTempLabel (NULL);
 
-  D(emitcode (";", "gen51AggregateAssign"));
+  D(emitcode(";     genCritical",""));
 
-  if (SPEC_OCLS(OP_SYMBOL(left)->etype)!=xdata ||
-      SPEC_OCLS(OP_SYMBOL(right)->etype)!=code) {
-    // well, this code isn't used yet from anywhere else as for initialising
-    fprintf (stderr, "*** error: %s:%d can only assign aggregates from cseg to xseg for now\n", ic->filename, ic->lineno);
-    exit (457);
-  }
+  if (IC_RESULT (ic))
+    aopOp (IC_RESULT (ic), ic, TRUE);
 
-  if (fromSize!=toSize) {
-    fprintf (stderr, "*** error: %s:%d aggregates have different size\n",
-	     ic->filename, ic->lineno);
-    exit (821);
-  }
+  emitcode ("setb", "c");
+  emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
+  emitcode ("clr", "c");
+  emitcode ("", "%05d$:", (tlbl->key + 100));
 
-#if 1
-  // use the generic memcpy() for now
-  emitcode (";", "initialize %s", OP_SYMBOL(IC_LEFT(ic))->name);
-  emitcode ("mov", "dptr,#_memcpy_PARM_2");
-  emitcode ("mov", "a,#%s", fromName);
-  emitcode ("movx", "@dptr,a");
-  emitcode ("inc", "dptr");
-  emitcode ("mov", "a,#(%s>>8)", fromName);
-  emitcode ("movx", "@dptr,a");
-  emitcode ("inc", "dptr");
-  emitcode ("mov", "a,#%02x;	only from cseg for now", 2);
-  emitcode ("movx", "@dptr,a");
-  emitcode ("mov", "dptr,#_memcpy_PARM_3");
-  emitcode ("mov", "a,#(%d>>0);	number of bytes", count);
-  emitcode ("movx", "@dptr,a");
-  emitcode ("inc", "dptr");
-  emitcode ("mov", "a,#(%d>>8)", count);
-  emitcode ("movx", "@dptr,a");
-  emitcode ("mov", "dptr,#%s", toName);
-  emitcode ("mov", "b,#%02x;	only to xseg for now", 1);
-  emitcode ("lcall", "_memcpy");
-#else
-  // more efficient, but will require the native_memcpy_cs2xs
-  emitcode ("mov", "r0,#%s", fromName);
-  emitcode ("mov", "r1,#(%s>>8)", fromName);
-  emitcode ("mov", "r2,#%s", toName);
-  emitcode ("mov", "r3,#(%s>>8)", toName);
-  emitcode ("mov", "r4,#%d", count);
-  emitcode ("mov", "r5,#(%d>>8)", count);
-  emitcode ("lcall", "_native_memcpy_cs2xs");
-#endif
+  if (IC_RESULT (ic))
+    outBitC (IC_RESULT (ic)); /* save old ea in an operand */
+  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);
+}
+
+/*-----------------------------------------------------------------*/
+/* genEndCritical - generate code for end of a critical sequence   */
+/*-----------------------------------------------------------------*/
+static void
+genEndCritical (iCode *ic)
+{
+  D(emitcode(";     genEndCritical",""));
+
+  if (IC_RIGHT (ic))
+    {
+      aopOp (IC_RIGHT (ic), ic, FALSE);
+      if (AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
+        {
+	  emitcode ("mov", "c,%s", IC_RIGHT (ic)->aop->aopu.aop_dir);
+          emitcode ("mov", "ea,c");
+        }
+      else
+        {
+          MOVA (aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE));
+          emitcode ("rrc", "a");
+          emitcode ("mov", "ea,c");
+        }
+      freeAsmop (IC_RIGHT (ic), NULL, ic, TRUE);
+    }
+  else
+    {
+      emitcode ("pop", "psw"); /* restore ea via c in psw on top of stack */
+      emitcode ("mov", "ea,c");
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -8777,17 +9761,18 @@ gen51Code (iCode * lic)
 {
   iCode *ic;
   int cln = 0;
+  /* int cseq = 0; */
 
+  _G.currentFunc = NULL;
   lineHead = lineCurr = NULL;
 
   /* print the allocation information */
-  if (allocInfo)
+  if (allocInfo && currFunc)
     printAllocInfo (currFunc, codeOutFile);
   /* if debug information required */
-  /*     if (options.debug && currFunc) { */
   if (options.debug && currFunc)
     {
-      cdbSymbol (currFunc, cdbFile, FALSE, TRUE);
+      debugFile->writeFunction(currFunc);
       _G.debugLine = 1;
       if (IS_STATIC (currFunc->etype))
 	emitcode ("", "F%s$%s$0$0 ==.", moduleName, currFunc->name);
@@ -8804,8 +9789,9 @@ gen51Code (iCode * lic)
 
   for (ic = lic; ic; ic = ic->next)
     {
+      _G.current_iCode = ic;
 
-      if (cln != ic->lineno)
+      if (ic->lineno && cln != ic->lineno)
 	{
 	  if (options.debug)
 	    {
@@ -8815,9 +9801,30 @@ gen51Code (iCode * lic)
 			ic->level, ic->block);
 	      _G.debugLine = 0;
 	    }
-	  emitcode (";", "%s %d", ic->filename, ic->lineno);
+	  if (!options.noCcodeInAsm) {
+	    emitcode ("", ";%s:%d: %s", ic->filename, ic->lineno,
+		      printCLine(ic->filename, ic->lineno));
+	  }
 	  cln = ic->lineno;
 	}
+      #if 0
+      if (ic->seqPoint && ic->seqPoint != cseq)
+        {
+	  emitcode ("", "; sequence point %d", ic->seqPoint);
+	  cseq = ic->seqPoint;
+	}
+      #endif
+      if (options.iCodeInAsm) {
+	char regsInUse[80];
+	int i;
+
+	for (i=0; i<8; i++) {
+	  sprintf (&regsInUse[i],
+		   "%c", ic->riu & (1<<i) ? i+'0' : '-');
+	}
+	regsInUse[i]=0;
+	emitcode("", "; [%s] ic:%d: %s", regsInUse, ic->seq, printILine(ic));
+      }
       /* if the result is marked as
          spilt and rematerializable or code for
          this has already been generated then
@@ -8975,12 +9982,12 @@ gen51Code (iCode * lic)
 	  break;
 
 	case GET_VALUE_AT_ADDRESS:
-	  genPointerGet (ic, hasInc(IC_LEFT(ic),ic));
+	  genPointerGet (ic, hasInc(IC_LEFT(ic),ic,getSize(operandType(IC_RESULT(ic)))));
 	  break;
 
 	case '=':
 	  if (POINTER_SET (ic))
-	    genPointerSet (ic, hasInc (IC_RESULT(ic),ic));
+	    genPointerSet (ic, hasInc (IC_RESULT(ic),ic,getSize(operandType(IC_RIGHT(ic)))));
 	  else
 	    genAssign (ic);
 	  break;
@@ -9009,8 +10016,20 @@ gen51Code (iCode * lic)
 	  addSet (&_G.sendSet, ic);
 	  break;
 
-	case ARRAYINIT:
-	  gen51AggregateAssign(ic);
+	case DUMMY_READ_VOLATILE:
+	  genDummyRead (ic);
+	  break;
+
+	case CRITICAL:
+	  genCritical (ic);
+	  break;
+
+	case ENDCRITICAL:
+	  genEndCritical (ic);
+	  break;
+
+	case SWAP:
+	  genSwap (ic);
 	  break;
 
 	default:
@@ -9018,6 +10037,7 @@ gen51Code (iCode * lic)
 	}
     }
 
+  _G.current_iCode = NULL;
 
   /* now we are ready to call the
      peep hole optimizer */