X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fds390%2Fgen.c;h=436a490b7767c136ee758698d06a74da268e52a1;hb=4aaeb0f34f305307c495ba6ce9c25eb492f131c1;hp=dca1d9e0ebbff09cc1c6257eaac7274bdda18c51;hpb=25685f554f3a93314f54b966b12a4c16165fb3e9;p=fw%2Fsdcc

diff --git a/src/ds390/gen.c b/src/ds390/gen.c
index dca1d9e0..436a490b 100644
--- a/src/ds390/gen.c
+++ b/src/ds390/gen.c
@@ -36,23 +36,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
-
 #define BETTER_LITERAL_SHIFT
 
 char *aopLiteral (value * val, int offset);
@@ -109,22 +92,9 @@ 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) { \
-    	         char *_mova_tmp = strdup(x); \
-                 if (strcmp(_mova_tmp,"a") && strcmp(_mova_tmp,"acc")) \
-                 { \
-                    emitcode("mov","a,%s",_mova_tmp); \
-                 } \
-                 free(_mova_tmp); \
-                }
-#define MOVB(x) { char *_movb_tmp = strdup(x); \
-                 if (strcmp(_movb_tmp,"b")) \
-                 { \
-                    emitcode("mov","b,%s",_movb_tmp); \
-                 } \
-                 free(_movb_tmp); \
-                }
+#define MOVA(x) _movA(x)
+#define MOVB(x) _movB(x)
+                
 #define CLRC    emitcode("clr","c")
 #define SETC    emitcode("setb","c")
 
@@ -210,6 +180,30 @@ emitcode (char *inst, char *fmt,...)
     va_end (ap);
 }
 
+//
+// Move the passed value into A unless it is already there.
+// 
+static void
+_movA(const char *s)
+{
+    if (strcmp(s,"a") && strcmp(s,"acc"))
+    { 
+	emitcode("mov","a,%s",s);
+    } 
+}
+
+//
+// Move the passed value into B unless it is already there.
+// 
+static void
+_movB(const char *s)
+{
+    if (strcmp(s,"b"))
+    { 
+	emitcode("mov","b,%s",s);
+    } 
+}
+
 /*-----------------------------------------------------------------*/
 /* getFreePtr - returns r0 or r1 whichever is free or can be pushed */
 /*-----------------------------------------------------------------*/
@@ -444,6 +438,72 @@ 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                                   */
 /*-----------------------------------------------------------------*/
@@ -452,6 +512,7 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 {
   asmop *aop;
   memmap *space = SPEC_OCLS (sym->etype);
+  int accuse = leftRightUseAcc (ic);
 
   /* if already has one */
   if (sym->aop)
@@ -473,10 +534,10 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 
 	  if (sym->onStack)
 	    {
-	      if (_G.accInUse)
+	      if (_G.accInUse || accuse)
 		emitcode ("push", "acc");
 
-	      if (_G.bInUse)
+	      if (_G.bInUse || (accuse>1))
 		emitcode ("push", "b");
 
 	      emitcode ("mov", "a,_bp");
@@ -487,10 +548,10 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 	      emitcode ("mov", "%s,a",
 			aop->aopu.aop_ptr->name);
 
-	      if (_G.bInUse)
+	      if (_G.bInUse || (accuse>1))
 		emitcode ("pop", "b");
 
-	      if (_G.accInUse)
+	      if (_G.accInUse || accuse)
 		emitcode ("pop", "acc");
 	    }
 	  else
@@ -524,14 +585,20 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 	if (stack_val < 0 && stack_val > -5) { /* between -5 & -1 */
 	    if (useDP2) {
 		if (options.model == MODEL_FLAT24)
-		    emitcode ("mov", "dpx1,#!constbyte", (options.stack_loc >> 16) & 0xff);
-		TR_DPTR("#2");
+		{
+		    emitcode ("mov", "dpx1,#!constbyte",
+			      (options.stack_loc >> 16) & 0xff);
+		}
 		emitcode ("mov", "dph1,_bpx+1");
+		
 		emitcode ("mov", "dpl1,_bpx");
 		emitcode ("mov","dps,#1");
 	    } else {
 		if (options.model == MODEL_FLAT24)
-		    emitcode ("mov", "dpx,#!constbyte", (options.stack_loc >> 16) & 0xff);
+		{
+		    emitcode ("mov", "dpx,#!constbyte",
+			      (options.stack_loc >> 16) & 0xff);
+		}
 		emitcode ("mov", "dph,_bpx+1");
 		emitcode ("mov", "dpl,_bpx");
 	    }
@@ -543,10 +610,10 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 		emitcode("mov","dps,#0");
 	    }
 	}  else {
-	    if (_G.accInUse)
+	    if (_G.accInUse || accuse)
 		emitcode ("push", "acc");
 	    
-	    if (_G.bInUse)
+	    if (_G.bInUse || (accuse>1))
 		emitcode ("push", "b");
 	
 	    emitcode ("mov", "a,_bpx");
@@ -557,21 +624,26 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 	    emitcode ("subb","a,#!constbyte",(stack_val >> 8) & 0xff);
 	    if (useDP2) {
 		if (options.model == MODEL_FLAT24)
-		    emitcode ("mov", "dpx1,#!constbyte", (options.stack_loc >> 16) & 0xff);
-		TR_DPTR("#2");
+		{
+		    emitcode ("mov", "dpx1,#!constbyte",
+			      (options.stack_loc >> 16) & 0xff);
+		}
 		emitcode ("mov", "dph1,a");
 		emitcode ("mov", "dpl1,b");
 	    } else {
 		if (options.model == MODEL_FLAT24)
-		    emitcode ("mov", "dpx,#!constbyte", (options.stack_loc >> 16) & 0xff);
+		{
+		    emitcode ("mov", "dpx,#!constbyte",
+			      (options.stack_loc >> 16) & 0xff);
+		}
 		emitcode ("mov", "dph,a");
 		emitcode ("mov", "dpl,b");
 	    }
 	    
-	    if (_G.bInUse)
+	    if (_G.bInUse || (accuse>1))
 		emitcode ("pop", "b");
 	    
-	    if (_G.accInUse)
+	    if (_G.accInUse || accuse)
 		emitcode ("pop", "acc");
 	}
 	sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
@@ -597,14 +669,14 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
     }
 
   /* special case for a function */
-  if (IS_FUNC (sym->type))
+  if (IS_FUNC (sym->type) && !(sym->isitmp))
     {
       sym->aop = aop = newAsmop (AOP_IMMD);
-      aop->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname);	
+      aop->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname);
       aop->size = FPTRSIZE;
       return aop;
     }
-  
+
   /* only remaining is far space */
   /* in which case DPTR gets the address */
   sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
@@ -666,7 +738,7 @@ aopForRemat (symbol * sym)
 		"(%s %c 0x%04x)",
 		OP_SYMBOL (IC_LEFT (ic))->rname,
 		val >= 0 ? '+' : '-',
-		abs (val) & 0xffff);
+		abs (val) & 0xffffff);
   }
   else 
   {
@@ -934,13 +1006,22 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2)
 	  aop->aopu.dptr = sym->dptr;
 	  return ;
       }
-      /* else spill location  */
-      if (sym->usl.spillLoc && 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, useDP2);
+      
+      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, useDP2);
+	  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;
     }
@@ -1110,6 +1191,8 @@ aopGet (asmop *aop,
   /* depending on type */
   switch (aop->type)
     {
+    case AOP_DUMMY:
+      return zero;
 
     case AOP_R0:
     case AOP_R1:
@@ -1150,11 +1233,11 @@ aopGet (asmop *aop,
       if (saveAcc)
 	{
 	    TR_AP("#1");
-	    if (aop->type != AOP_DPTR2)
-	    {
-		if (saveAccWarn) { fprintf(stderr, "saveAcc for DPTR...\n"); }
-		emitcode(";", "spanky: saveAcc for DPTR");
-	    }
+//	    if (aop->type != AOP_DPTR2)
+//	    {
+//		if (saveAccWarn) { fprintf(stderr, "saveAcc for DPTR...\n"); }
+//		emitcode(";", "spanky: saveAcc for DPTR");
+//	    }
 	    
 	    emitcode ("xch", "a, %s", saveAcc);
 	}
@@ -1193,10 +1276,10 @@ aopGet (asmop *aop,
 	{
        TR_AP("#2");
 	      emitcode ("xch", "a, %s", saveAcc);
-	      if (strcmp(saveAcc, "_ap"))
-	      {
-		  emitcode(";", "spiffy: non _ap return from aopGet.");
-	      }
+//	      if (strcmp(saveAcc, "_ap"))
+//	      {
+//		  emitcode(";", "spiffy: non _ap return from aopGet.");
+//	      }
 		  
 	      return saveAcc;
 	}
@@ -1311,6 +1394,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)
 	{
@@ -1602,49 +1689,6 @@ reAdjustPreg (asmop * aop)
       emitcode("nop", "; workaround for DS80C390 div bug.");  \
     }
 
-/*-----------------------------------------------------------------*/
-/* 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;
-
-  _startLazyDPSEvaluation ();
-  l = aopGet (op->aop, offset++, FALSE, FALSE, NULL);
-  MOVA (l);
-
-  while (size--)
-    {
-      emitcode ("orl", "a,%s",
-		aopGet (op->aop,
-			offset++, FALSE, FALSE,
-			DP2_RESULT_REG));
-    }
-  _endLazyDPSEvaluation ();
-
-  tlbl = newiTempLabel (NULL);
-  aopPut (res->aop, one, 1);
-  emitcode ("jz", "!tlabel", (tlbl->key + 100));
-  aopPut (res->aop, zero, 1);
-  emitcode ("", "!tlabeldef", (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       */
@@ -1770,7 +1814,7 @@ toBoolean (operand * oper)
       else
 	{
 	  emitcode ("orl", "a,%s",
-		    aopGet (AOP (oper), offset++, FALSE, FALSE, DP2_RESULT_REG));
+		    aopGet (AOP (oper), offset++, FALSE, FALSE, NULL));
 	}
     }
   _endLazyDPSEvaluation ();
@@ -1794,7 +1838,6 @@ static void
 genNot (iCode * ic)
 {
   symbol *tlbl;
-  sym_link *optype = operandType (IC_LEFT (ic));
 
   D (emitcode (";", "genNot "););
 
@@ -1811,13 +1854,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);
@@ -1925,7 +1961,7 @@ genUminus (iCode * ic)
 
   /* assign asmops */
   aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
-  aopOp (IC_RESULT (ic), ic, TRUE, AOP_USESDPTR(IC_LEFT (ic)));
+  aopOp (IC_RESULT (ic), ic, TRUE, (AOP_TYPE(IC_LEFT (ic)) == AOP_DPTR));
 
   /* if both in bit space then special
      case */
@@ -2042,11 +2078,14 @@ saveRegisters (iCode * lic)
 
   /* if the registers have been saved already then
      do nothing */
-  if (ic->regsSaved || IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic)))) return ;
+  if (ic->regsSaved 
+      || (IS_SYMOP(IC_LEFT(ic)) && IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic))) && !TARGET_IS_DS400) )
+    return ;
 
   /* special case if DPTR alive across a function call then must save it 
      even though callee saves */
-  if (IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
+  if (IS_SYMOP(IC_LEFT(ic)) &&
+      IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
       int i;
       rsave = newBitVect(ic->rMask->size);
       for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
@@ -2151,7 +2190,24 @@ assignResultValue (operand * oper)
 {
   int offset = 0;
   int size = AOP_SIZE (oper);
+  bool pushedAcc = FALSE;
 
+  if (size == fReturnSizeDS390)
+  {
+      /* I don't think this case can ever happen... */
+      /* ACC is the last part of this. If writing the result
+       * uses AC, we must preserve it.
+       */
+      if (AOP_NEEDSACC(oper))
+      {
+	  emitcode(";", "assignResultValue special case for ACC.");
+	  emitcode("push", "acc");
+	  pushedAcc = TRUE;
+	  size--;
+      }
+  }
+    
+    
   _startLazyDPSEvaluation ();
   while (size--)
     {
@@ -2159,6 +2215,12 @@ assignResultValue (operand * oper)
       offset++;
     }
   _endLazyDPSEvaluation ();
+    
+  if (pushedAcc)
+    {
+	emitcode("pop", "acc");
+	aopPut(AOP(oper), "a", offset);
+    }
 }
 
 
@@ -2492,6 +2554,18 @@ static void genSend(set *sendSet)
     }
 }
 
+static void
+adjustEsp(const char *reg)
+{
+    emitcode ("anl","%s,#3", reg);
+    if (TARGET_IS_DS400)
+    {
+	emitcode ("orl","%s,#!constbyte",
+		  reg,
+		  (options.stack_loc >> 8) & 0xff);
+    }
+}
+
 /*-----------------------------------------------------------------*/
 /* genCall - generates a call statement                            */
 /*-----------------------------------------------------------------*/
@@ -2508,7 +2582,7 @@ genCall (iCode * ic)
      the same register bank then we need to save the
      destination registers on the stack */
   dtype = operandType (IC_LEFT (ic));
-  if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
+  if (currFunc && dtype && (!IFFUNC_ISNAKED(dtype) || TARGET_IS_DS400) &&
       (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
       IFFUNC_ISISR (currFunc->type))
   {
@@ -2590,9 +2664,9 @@ genCall (iCode * ic)
 	}
       else
 	{
-	  _G.accInUse++;
+	  _G.bInUse++;
 	  aopOp (IC_RESULT (ic), ic, FALSE, TRUE);
-	  _G.accInUse--;
+	  _G.bInUse--;
 
 	  assignResultValue (IC_RESULT (ic));
 
@@ -2617,7 +2691,7 @@ genCall (iCode * ic)
 	      emitcode ("subb","a,#!constbyte",ic->parmBytes & 0xff);
 	      emitcode ("mov","sp,a");
 	      emitcode ("mov","a,esp");
-	      emitcode ("anl","a,#3");
+	      adjustEsp("a");
 	      emitcode ("subb","a,#!constbyte",(ic->parmBytes >> 8) & 0xff);
 	      emitcode ("mov","esp,a");	  
 	      UNPROTECT_SP;
@@ -2664,7 +2738,7 @@ genPcall (iCode * ic)
      the same register bank then we need to save the
      destination registers on the stack */
   dtype = operandType (IC_LEFT (ic));
-  if (currFunc && dtype && !IFFUNC_ISNAKED(dtype) &&
+  if (currFunc && dtype && (!IFFUNC_ISNAKED(dtype) || TARGET_IS_DS400) &&
       IFFUNC_ISISR (currFunc->type) &&
       (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype))) {
     saveRBank (FUNC_REGBANK (dtype), ic, TRUE);
@@ -2735,7 +2809,7 @@ genPcall (iCode * ic)
 	      emitcode ("subb","a,#!constbyte",ic->parmBytes & 0xff);
 	      emitcode ("mov","sp,a");
 	      emitcode ("mov","a,esp");
-	      emitcode ("anl","a,#3");
+	      adjustEsp("a");
 	      emitcode ("subb","a,#!constbyte",(ic->parmBytes >> 8) & 0xff);
 	      emitcode ("mov","esp,a");	  
 	      UNPROTECT_SP;
@@ -2791,22 +2865,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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -2838,9 +2912,6 @@ genFunction (iCode * ic)
   
   if (options.stack_probe) 
       emitcode ("lcall","__stack_probe");
-  /* 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 */
@@ -3018,7 +3089,7 @@ genFunction (iCode * ic)
 	             }
 	        }
 	    }
-	    // jwk: this needs a closer look
+	    // TODO: this needs a closer look
 	    SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
 	}
     }
@@ -3062,7 +3133,7 @@ genFunction (iCode * ic)
 	  emitcode ("push","_bpx+1");
 	  emitcode ("mov","_bpx,%s",spname);
 	  emitcode ("mov","_bpx+1,esp");
-	  emitcode ("anl","_bpx+1,#3");
+	  adjustEsp("_bpx+1");
       } else {
 	  if (options.useXstack) {
 	      emitcode ("mov", "r0,%s", spname);
@@ -3091,7 +3162,7 @@ genFunction (iCode * ic)
 	      emitcode ("add","a,#!constbyte", ((short) sym->stack & 0xff));
 	      emitcode ("mov","sp,a");
 	      emitcode ("mov","a,esp");
-	      emitcode ("anl","a,#3");
+	      adjustEsp("a");
 	      emitcode ("addc","a,#!constbyte", (((short) sym->stack) >> 8) & 0xff);
 	      emitcode ("mov","esp,a");
 	      UNPROTECT_SP;
@@ -3119,6 +3190,17 @@ genFunction (iCode * ic)
       emitcode ("add", "a,#!constbyte", ((char) sym->xstack & 0xff));
       emitcode ("mov", "_spx,a");
     }
+  
+  /* 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 */
+    }
 
 }
 
@@ -3138,6 +3220,12 @@ genEndFunction (iCode * ic)
       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) &&
        (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
 
@@ -3241,7 +3329,6 @@ 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;
 	  
@@ -3283,9 +3370,6 @@ 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) {
 	  _G.debugLine = 1;
@@ -3303,9 +3387,6 @@ genEndFunction (iCode * ic)
     }
   else
     {
-      if (IFFUNC_ISCRITICAL (sym->type))
-	emitcode ("setb", "ea");
-
       if (IFFUNC_CALLEESAVES(sym->type))
 	{
 	  int i;
@@ -3795,11 +3876,21 @@ bool aopOp3(iCode * ic)
 //	       AOP_IS_DPTRn(IC_LEFT(ic)) ? "true" : "false",
 //	       AOP_IS_DPTRn(IC_RIGHT(ic)) ? "true" : "false",
 //	       AOP_IS_DPTRn(IC_RESULT(ic)) ? "true" : "false");
-//      );      
-
+//      );
     
-    // Right uses DPTR unless left or result is an AOP_STR.
-    aopOp (IC_RIGHT(ic),ic,FALSE, AOP_IS_STR(IC_LEFT(ic)) || AOP_IS_STR(IC_RESULT(ic)));
+    // Right uses DPTR unless left or result is an AOP_STR; however,
+    // if right is an AOP_STR, it must use DPTR regardless.
+    if ((AOP_IS_STR(IC_LEFT(ic)) || AOP_IS_STR(IC_RESULT(ic)))
+     && !AOP_IS_STR(IC_RIGHT(ic)))
+    {
+	useDp2 = TRUE;
+    }
+    else
+    {
+	useDp2 = FALSE;
+    }
+	
+    aopOp (IC_RIGHT(ic),ic,FALSE, useDp2);
     
     // if the right used DPTR, left MUST use DPTR2.
     // if the right used DPTR2, left MUST use DPTR.
@@ -3950,7 +4041,7 @@ genPlus (iCode * ic)
   if ( AOP_IS_STR(IC_LEFT(ic)) &&
       isOperandLiteral(IC_RIGHT(ic)) && OP_SYMBOL(IC_RESULT(ic))->ruonly) {
       aopOp (IC_RIGHT (ic), ic, TRUE, FALSE);
-      size = floatFromVal (AOP (IC_RIGHT(ic))->aopu.aop_lit);
+      size = (int)floatFromVal (AOP (IC_RIGHT(ic))->aopu.aop_lit);
       if (size <= 9) {
 	  while (size--) emitcode ("inc","dptr");
       } else {
@@ -4052,10 +4143,10 @@ genPlus (iCode * ic)
 	  MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL));
 	  if (offset == 0)
 	    emitcode ("add", "a,%s",
-		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, DP2_RESULT_REG));
+		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
 	  else
 	    emitcode ("addc", "a,%s",
-		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, DP2_RESULT_REG));
+		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
 	}
       else
 	{
@@ -4200,7 +4291,7 @@ genMinusDec (iCode * ic)
 	  emitcode ("mov", "a,#!constbyte",0xff);
 	  emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
       }
-      l = aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, NULL, NULL);
+      l = aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, NULL);
       emitcode ("dec", "%s", l);
       if (size > 2)
 	{
@@ -4219,7 +4310,7 @@ genMinusDec (iCode * ic)
 		emitcode ("mov", "a,#!constbyte",0xff);
 		emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
 	    }
-	    l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, NULL, NULL);
+	    l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL);
 	    emitcode ("dec", "%s", l);
 	}
       if (size > 3)
@@ -4239,7 +4330,7 @@ genMinusDec (iCode * ic)
 		emitcode ("mov", "a,#!constbyte",0xff);
 		emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
 	    }	    
-	    l = aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, NULL, NULL);
+	    l = aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, NULL);
 	    emitcode ("dec", "%s", l);
 	}
       if (emitTlbl)
@@ -4536,7 +4627,7 @@ genMultOneByte (operand * left,
 
   /* if literal */
   if (AOP_TYPE(right)==AOP_LIT) {
-    signed char val=floatFromVal (AOP (right)->aopu.aop_lit);
+    signed char val=(signed char)floatFromVal (AOP (right)->aopu.aop_lit);
     /* AND literal negative */
     if ((int) val < 0) {
       emitcode ("cpl", "F0"); // complement sign flag
@@ -4617,7 +4708,7 @@ static void genMultTwoByte (operand *left, operand *right,
 	if (!umult) {
 		emitcode("clr","F0");
 		if (AOP_TYPE(right) == AOP_LIT) {
-			int val=floatFromVal (AOP (right)->aopu.aop_lit);
+			int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
 			if (val < 0) {
 				emitcode("setb","F0");
 				val = -val;
@@ -4960,7 +5051,7 @@ static void genDivTwoByte (operand *left, operand *right,
 	/* load up MB with right */
 	if (!umult) {
 		if (AOP_TYPE(right) == AOP_LIT) {
-			int val=floatFromVal (AOP (right)->aopu.aop_lit);
+			int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
 			if (val < 0) {
 				lbl = newiTempLabel(NULL);
 				emitcode ("jbc","F0,!tlabel",lbl->key+100);
@@ -5217,7 +5308,7 @@ static void genModTwoByte (operand *left, operand *right,
 	/* load up MB with right */
 	if (!umult) {
 		if (AOP_TYPE(right) == AOP_LIT) {
-			int val=floatFromVal (AOP (right)->aopu.aop_lit);
+			int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
 			if (val < 0) {
 				val = -val;
 			} 
@@ -5371,7 +5462,7 @@ genCmp (operand * left, operand * right,
       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
     {
@@ -5569,6 +5660,7 @@ 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;
@@ -5597,7 +5689,7 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
 	{
 	  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 	  emitcode ("cjne", "a,%s,!tlabel",
-		    aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG),
+		    aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 		    lbl->key + 100);
 	  offset++;
 	}
@@ -5607,6 +5699,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)))
     {
@@ -6293,6 +6387,8 @@ genAnd (iCode * ic, iCode * ifx)
 	    {
 	      if (ifx)
 		jmpTrueOrFalse (ifx, tlbl);
+              else
+	        emitcode ("", "!tlabeldef", tlbl->key + 100);
 	      goto release;
 	    }
 	}
@@ -6321,7 +6417,7 @@ genAnd (iCode * ic, iCode * ifx)
 	      else
 		emitcode ("anl", "%s,%s",
 			  aopGet (AOP (left), offset, FALSE, TRUE, NULL),
-			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
+			  aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 	    }
 	  else
 	    {
@@ -6383,6 +6479,8 @@ genAnd (iCode * ic, iCode * ifx)
 	    }
 	  else if (ifx)
 	    jmpTrueOrFalse (ifx, tlbl);
+          else
+	    emitcode ("", "!tlabeldef", tlbl->key + 100);
 	}
       else
 	{
@@ -6701,6 +6799,8 @@ genOr (iCode * ic, iCode * ifx)
 	    }
 	  else if (ifx)
 	    jmpTrueOrFalse (ifx, tlbl);
+          else
+	    emitcode ("", "!tlabeldef", tlbl->key + 100);
 	}
       else
 	{
@@ -7237,6 +7337,65 @@ 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, FALSE);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
+  
+  _startLazyDPSEvaluation ();
+  switch (AOP_SIZE (left))
+    {
+    case 1: /* swap nibbles in byte */
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+      emitcode ("swap", "a");
+      aopPut (AOP (result), "a", 0);
+      break;
+    case 2: /* swap bytes in word */
+      if (AOP_TYPE(left) == AOP_REG && sameRegs(AOP(left), AOP(result)))
+	{
+	  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+	  aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0);
+	  aopPut (AOP (result), "a", 1);
+	}
+      else if (operandsEqu (left, result))
+	{
+          char * reg = "a";
+	  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+	  if (AOP_NEEDSACC (left) || AOP_NEEDSACC (result))
+	    {
+	      emitcode ("mov", "b,a");
+              reg = "b";
+              _G.bInUse=1;
+            }
+	  aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0);
+	  aopPut (AOP (result), reg, 1);
+          _G.bInUse=0;
+	}
+      else
+	{
+	  aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0);
+	  aopPut (AOP (result), aopGet (AOP (left), 0, FALSE, FALSE, NULL), 1);
+	}
+      break;
+    default:
+      wassertl(FALSE, "unsupported SWAP operand size");
+    }
+  _endLazyDPSEvaluation ();
+  
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
 /*-----------------------------------------------------------------*/
 /* AccRol - rotate left accumulator by known count                 */
 /*-----------------------------------------------------------------*/
@@ -7879,8 +8038,6 @@ shiftR2Left2Result (operand * left, int offl,
 }
 #endif
 
-#if 0
-//REMOVE ME!!!
 /*-----------------------------------------------------------------*/
 /* shiftLLeftOrResult - shift left one byte from left, or to result */
 /*-----------------------------------------------------------------*/
@@ -7897,7 +8054,6 @@ shiftLLeftOrResult (operand * left, int offl,
   /* back to result */
   aopPut (AOP (result), "a", offr);
 }
-#endif
 
 #if 0
 //REMOVE ME!!!
@@ -8432,8 +8588,6 @@ genrshTwo (operand * result, operand * left,
 }
 #endif
 
-#if 0
-//REMOVE ME!!!
 /*-----------------------------------------------------------------*/
 /* shiftRLong - shift right one long from left to result           */
 /* offl = LSB or MSB16                                             */
@@ -8449,7 +8603,7 @@ shiftRLong (operand * left, int offl,
     werror(E_INTERNAL_ERROR, __FILE__, __LINE__);
   }
 
-  MOVA (aopGet (AOP (left), MSB32, FALSE, NULL));
+  MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE, NULL));
   
   if (offl==MSB16) {
     // shift is > 8
@@ -8457,7 +8611,7 @@ shiftRLong (operand * left, int offl,
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       emitcode ("xch", "a,%s",
-		aopGet(AOP(left), MSB32, FALSE, DP2_RESULT_REG));
+		aopGet(AOP(left), MSB32, FALSE, FALSE, DP2_RESULT_REG));
     } else {
       aopPut (AOP(result), zero, MSB32);
     }
@@ -8473,34 +8627,31 @@ shiftRLong (operand * left, int offl,
 
   if (isSameRegs && offl==MSB16) {
     emitcode ("xch",
-	      "a,%s",aopGet (AOP (left), MSB24, FALSE, DP2_RESULT_REG));
+	      "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE, DP2_RESULT_REG));
   } else {
     aopPut (AOP (result), "a", MSB32);
-    MOVA (aopGet (AOP (left), MSB24, FALSE, NULL));
+    MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE, NULL));
   }
 
   emitcode ("rrc", "a");
   if (isSameRegs && offl==1) {
     emitcode ("xch", "a,%s",
-	      aopGet (AOP (left), MSB16, FALSE, DP2_RESULT_REG));
+	      aopGet (AOP (left), MSB16, FALSE, FALSE, DP2_RESULT_REG));
   } else {
     aopPut (AOP (result), "a", MSB24);
-    MOVA (aopGet (AOP (left), MSB16, FALSE, NULL));
+    MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE, NULL));
   }
   emitcode ("rrc", "a");
   aopPut (AOP (result), "a", MSB16 - offl);
 
   if (offl == LSB)
     {
-      MOVA (aopGet (AOP (left), LSB, FALSE, NULL));
+      MOVA (aopGet (AOP (left), LSB, FALSE, FALSE, NULL));
       emitcode ("rrc", "a");
       aopPut (AOP (result), "a", LSB);
     }
 }
-#endif
 
-#if 0
-//REMOVE ME!!!
 /*-----------------------------------------------------------------*/
 /* genrshFour - shift four byte by a known amount != 0             */
 /*-----------------------------------------------------------------*/
@@ -8508,22 +8659,24 @@ 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)
     {
       shCount -= 24;
+      _startLazyDPSEvaluation();
       if (shCount)
 	shiftR1Left2Result (left, MSB32, result, LSB, shCount, sign);
       else
 	movLeft2Result (left, MSB32, result, LSB, sign);
       addSign (result, MSB16, sign);
+      _endLazyDPSEvaluation();
     }
   else if (shCount >= 16)
     {
       shCount -= 16;
+      _startLazyDPSEvaluation();
       if (shCount)
 	shiftR2Left2Result (left, MSB24, result, LSB, shCount, sign);
       else
@@ -8532,12 +8685,16 @@ genrshFour (operand * result, operand * left,
 	  movLeft2Result (left, MSB32, result, MSB16, sign);
 	}
       addSign (result, MSB24, sign);
+      _endLazyDPSEvaluation();
     }
   else if (shCount >= 8)
     {
       shCount -= 8;
+      _startLazyDPSEvaluation();
       if (shCount == 1)
-	shiftRLong (left, MSB16, result, sign);
+	{
+	    shiftRLong (left, MSB16, result, sign);
+	}
       else if (shCount == 0)
 	{
 	  movLeft2Result (left, MSB16, result, LSB, 0);
@@ -8553,9 +8710,11 @@ genrshFour (operand * result, operand * left,
 	  shiftR1Left2Result (left, MSB32, result, MSB24, shCount, sign);
 	  addSign (result, MSB32, sign);
 	}
+	_endLazyDPSEvaluation();
     }
   else
-    {				/* 1 <= shCount <= 7 */
+    {	
+	/* 1 <= shCount <= 7 */
       if (shCount <= 2)
 	{
 	  shiftRLong (left, LSB, result, sign);
@@ -8570,7 +8729,6 @@ genrshFour (operand * result, operand * left,
 	}
     }
 }
-#endif
 
 #ifdef BETTER_LITERAL_SHIFT
 /*-----------------------------------------------------------------*/
@@ -8594,9 +8752,10 @@ genRightShiftLiteral (operand * left,
   if ((shCount != 0)
    && (shCount < (size * 8))
    && (size != 1)
-   && (size != 2))
+   && (size != 2)
+   && (size != 4))
   {
-      D(emitcode (";", "genRightShiftLiteral wimping out"););	
+      D(emitcode (";", "genRightShiftLiteral wimping out"););
       return FALSE;
   }
 
@@ -8643,7 +8802,7 @@ genRightShiftLiteral (operand * left,
 	case 2:
 	  genrshTwo (result, left, shCount, sign);
 	  break;
-#if 0
+#if 1
 	case 4:
 	  genrshFour (result, left, shCount, sign);
 	  break;
@@ -8790,7 +8949,7 @@ static void
 genRightShift (iCode * ic)
 {
   operand *right, *left, *result;
-  sym_link *retype;
+  sym_link *letype;
   int size, offset;
   char *l;
   symbol *tlbl, *tlbl1;
@@ -8799,9 +8958,9 @@ genRightShift (iCode * ic)
 
   /* 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;
@@ -8922,116 +9081,148 @@ release:
   freeAsmop (result, NULL, ic, TRUE);
 }
 
+
 /*-----------------------------------------------------------------*/
-/* 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;
-  sym_link *etype;
-  int offset = 0;
-
-  D (emitcode (";", "genUnpackBits "););
-
-  etype = getSpec (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;
     }
+}
 
-  /* if we have bitdisplacement then it fits   */
-  /* into this byte completely or if length is */
-  /* less than a byte                          */
-  if (((shCnt = SPEC_BSTR (etype)) != 0) || (SPEC_BLEN (etype) <= 8))
+/*-----------------------------------------------------------------*/
+/* 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;
 
-      /* shift right acc */
-      AccRsh (shCnt);
-
-      emitcode ("anl", "a,#!constbyte",
-		((unsigned char) -1) >> (8 - SPEC_BLEN (etype)));
-      aopPut (AOP (result), "a", offset);
-      return;
-    }
+    case PPOINTER:
+      MOVA (src);
+      emitcode ("movx", "@%s,a", rname);
+      break;
+      
+    case FPOINTER:
+      MOVA (src);
+      emitcode ("movx", "@dptr,a");
+      break;
 
-  /* bit field did not fit in a byte  */
-  rlen = SPEC_BLEN (etype) - 8;
-  aopPut (AOP (result), "a", offset++);
-
-  while (1)
-    {
-
-      switch (ptype)
-	{
-	case POINTER:
-	case IPOINTER:
-	  emitcode ("inc", "%s", rname);
-	  emitcode ("mov", "a,@%s", rname);
-	  break;
-
-	case PPOINTER:
-	  emitcode ("inc", "%s", rname);
-	  emitcode ("movx", "a,@%s", rname);
-	  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);
 
+  /* If the bitfield length is less than a byte */
+  if (blen < 8)
+    {
+      emitPtrByteGet (rname, ptype, FALSE);
+      AccRsh (bstr);
+      emitcode ("anl", "a,#!constbyte", ((unsigned char) -1) >> (8 - blen));
       aopPut (AOP (result), "a", offset++);
+      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++);
+      if (rlen>8)
+        emitcode ("inc", "%s", rname);
     }
 
+  /* Handle the partial byte at the end */
   if (rlen)
     {
-      emitcode ("anl", "a,#!constbyte", ((unsigned char) -1) >> (rlen));
-      aopPut (AOP (result), "a", offset);
+      emitPtrByteGet (rname, ptype, FALSE);
+      emitcode ("anl", "a,#!constbyte", ((unsigned char) -1) >> (8-rlen));
+      aopPut (AOP (result), "a", offset++);
     }
 
-  return;
+finish:
+  if (offset < rsize)
+    {
+      rsize -= offset;
+      while (rsize--)
+	aopPut (AOP (result), zero, offset++);
+    }
 }
 
 
@@ -9315,8 +9506,7 @@ genFarPointerGet (operand * left,
 	  else
 	    {
 	      /* We need to generate a load to DPTR indirect through DPTR. */
-	      D (emitcode (";", "genFarPointerGet -- indirection special case.");
-		);
+	      D (emitcode (";", "genFarPointerGet -- indirection special case."););
 	      emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, NULL));
 	      emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, NULL));
 	      if (options.model == MODEL_FLAT24)
@@ -9375,15 +9565,18 @@ genFarPointerGet (operand * left,
     }
   if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) {
       if (!AOP_INDPTRn(left)) {
+	  _startLazyDPSEvaluation ();
 	  aopPut ( AOP (left), "dpl", 0);
 	  aopPut ( AOP (left), "dph", 1);
 	  if (options.model == MODEL_FLAT24)
 	      aopPut ( AOP (left), "dpx", 2);
+	  _endLazyDPSEvaluation ();
       }
     pi->generated = 1;
-  } else if ((OP_SYMBOL(left)->ruonly || AOP_INDPTRn(left)) && 
+  } else if ((AOP_IS_STR(left) || AOP_INDPTRn(left)) && 
 	     AOP_SIZE(result) > 1 &&
-	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+	     IS_SYMOP(left) &&
+	     (OP_SYMBOL(left)->liveTo > ic->seq || ic->depth)) {
       
       size = AOP_SIZE (result) - 1;
       if (AOP_INDPTRn(left)) {
@@ -9433,8 +9626,7 @@ genCodePointerGet (operand * left,
 	  else
 	    {
 	      /* We need to generate a load to DPTR indirect through DPTR. */
-	      D (emitcode (";", "gencodePointerGet -- indirection special case.");
-		);
+	      D (emitcode (";", "gencodePointerGet -- indirection special case."););
 	      emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, NULL));
 	      emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, NULL));
 	      if (options.model == MODEL_FLAT24)
@@ -9494,10 +9686,14 @@ genCodePointerGet (operand * left,
     }
   if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) {
       if (!AOP_INDPTRn(left)) {
+	  _startLazyDPSEvaluation ();
+	  
 	  aopPut ( AOP (left), "dpl", 0);
 	  aopPut ( AOP (left), "dph", 1);
 	  if (options.model == MODEL_FLAT24)
 	      aopPut ( AOP (left), "dpx", 2);
+
+	  _endLazyDPSEvaluation ();
       }
       pi->generated = 1;
   } else if ((OP_SYMBOL(left)->ruonly || AOP_INDPTRn(left)) && 
@@ -9610,12 +9806,17 @@ genGenPointerGet (operand * left,
     }
 
   if (pi && AOP_TYPE (left) != AOP_IMMD) {
+    _startLazyDPSEvaluation ();
+      
     aopPut ( AOP (left), "dpl", 0);
     aopPut ( AOP (left), "dph", 1);
     if (options.model == MODEL_FLAT24) {
 	aopPut ( AOP (left), "dpx", 2);
 	aopPut ( AOP (left), "b", 3);	
     } else  aopPut ( AOP (left), "b", 2);	
+    
+    _endLazyDPSEvaluation ();
+      
     pi->generated = 1;
   } else if (OP_SYMBOL(left)->ruonly && AOP_SIZE(result) > 1 &&
 	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
@@ -9700,162 +9901,125 @@ genPackBits (sym_link * etype,
 	     operand * right,
 	     char *rname, int p_type)
 {
-  int offset = 0;
-  int rLen;
-  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",""));
 
   blen = SPEC_BLEN (etype);
   bstr = SPEC_BSTR (etype);
 
-  MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
-
-  /* if the bit lenth is less than or    */
-  /* it exactly fits a byte then         */
-  if (SPEC_BLEN (etype) <= 8)
-    {
-      /* shift left acc */
-      AccLsh (SPEC_BSTR (etype));
-
-      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,#!constbyte", (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;
+      mask = ((unsigned char) (0xFF << (blen + bstr)) |
+	      (unsigned char) (0xFF >> (8 - bstr)));
 
-    case FPOINTER:
-      emitcode ("movx", "@dptr,a");
-      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,#!constbyte", mask);
+          if (litval)
+            emitcode ("orl","a,#!constbyte", 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, NULL));
+                  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, NULL));
+              /* shift and mask source value */
+              AccLsh (bstr);
+              emitcode ("anl", "a,#!constbyte", (~mask) & 0xff);
+
+    	      /* transfer A to B and get next byte */
+              emitPtrByteGet (rname, p_type, TRUE);
+
+              emitcode ("anl", "a,#!constbyte", mask);
+              emitcode ("orl", "a,b");
+              if (p_type == GPOINTER)
+                emitcode ("pop", "b");
+           }
+        }
 
-    case GPOINTER:
-      emitcode ("lcall", "__gptrput");
-      break;
+      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, NULL);
-
-      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, NULL) );
+      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;
-
-	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,#!constbyte", ((unsigned char) -1 << rLen));
-      emitcode ("orl", "a,b");
+      mask = (((unsigned char) -1 << rlen) & 0xff);
+      
+      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,#!constbyte", mask);
+          if (litval)
+            emitcode ("orl","a,#!constbyte", litval);
+        }
+      else
+        {
+          /* Case with partial byte and arbitrary source
+          */
+          MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
+          emitcode ("anl", "a,#!constbyte", (~mask) & 0xff);
+
+	  /* transfer A to B and get next byte */
+          emitPtrByteGet (rname, p_type, TRUE);
+
+          emitcode ("anl", "a,#!constbyte", 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                 */
 /*-----------------------------------------------------------------*/
@@ -10186,10 +10350,14 @@ genFarPointerSet (operand * right,
   
   if (dopi && pi && AOP_TYPE (result) != AOP_IMMD) {
       if (!AOP_INDPTRn(result)) {
+	  _startLazyDPSEvaluation ();
+	  
 	  aopPut (AOP(result),"dpl",0);
 	  aopPut (AOP(result),"dph",1);
 	  if (options.model == MODEL_FLAT24)
 	      aopPut (AOP(result),"dpx",2);
+
+	  _endLazyDPSEvaluation ();
       }
       pi->generated=1;
   } else if ((OP_SYMBOL(result)->ruonly || AOP_INDPTRn(result)) && 
@@ -10254,33 +10422,63 @@ genGenPointerSet (operand * right,
 	}
       _endLazyDPSEvaluation ();
     }
-  /* so dptr know contains the address */
+  /* so dptr + b now contains the address */
+  _G.bInUse++;
   aopOp (right, ic, FALSE, TRUE);
+  _G.bInUse--;
+    
 
   /* if bit then unpack */
   if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", GPOINTER);
+    {
+	genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", GPOINTER);
+    }
   else
     {
-      size = AOP_SIZE (right);
-      offset = 0;
+	size = AOP_SIZE (right);
+	offset = 0;
 
-      _startLazyDPSEvaluation ();
-      while (size--)
+	_startLazyDPSEvaluation ();
+	while (size--)
 	{
-	  MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
-
-	  genSetDPTR (0);
-	  _flushLazyDPS ();
+	    if (size)
+	    {
+		// Set two bytes at a time, passed in _AP & A.
+		// dptr will be incremented ONCE by __gptrputWord.
+		//
+		// Note: any change here must be coordinated
+		// with the implementation of __gptrputWord
+		// in device/lib/_gptrput.c
+		emitcode("mov", "_ap, %s", 
+			 aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
+		MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
+		
+		genSetDPTR (0);
+		_flushLazyDPS ();
+		emitcode ("lcall", "__gptrputWord");
+		size--;
+	    }
+	    else
+	    {
+		// Only one byte to put.
+		MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
 
-	  emitcode ("lcall", "__gptrput");
-	  if (size || (pi && AOP_TYPE (result) != AOP_IMMD))
-	    emitcode ("inc", "dptr");
+		genSetDPTR (0);
+		_flushLazyDPS ();		
+		emitcode ("lcall", "__gptrput");
+	    }
+	    
+	    if (size || (pi && AOP_TYPE (result) != AOP_IMMD))
+	    {
+		emitcode ("inc", "dptr");
+	    }
 	}
-      _endLazyDPSEvaluation ();
+	_endLazyDPSEvaluation ();
     }
 
   if (pi && AOP_TYPE (result) != AOP_IMMD) {
+      _startLazyDPSEvaluation ();
+      
       aopPut (AOP(result),"dpl",0);
       aopPut (AOP(result),"dph",1);
       if (options.model == MODEL_FLAT24) {
@@ -10289,6 +10487,8 @@ genGenPointerSet (operand * right,
       } else {
 	  aopPut (AOP(result),"b",2);
       }
+      _endLazyDPSEvaluation ();
+      
       pi->generated=1;
   } else if (OP_SYMBOL(result)->ruonly && AOP_SIZE(right) > 1 &&
 	     (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
@@ -10436,6 +10636,8 @@ genAddrOf (iCode * ic)
       /* if 10 bit stack */
       if (options.stack10bit) {
 	  char buff[10];
+	  int  offset;
+	  
 	  tsprintf(buff, sizeof(buff), 
 		   "#!constbyte",(options.stack_loc >> 16) & 0xff);
 	  /* if it has an offset then we need to compute it */
@@ -10454,9 +10656,13 @@ genAddrOf (iCode * ic)
 					     ((char) sym->stack )) & 0xff);
 	      emitcode ("mov", "b,a");
 	      emitcode ("mov", "a,_bpx+1");
-	      emitcode ("addc","a,#!constbyte", (((sym->stack < 0) ? 
-					      ((short) (sym->stack - _G.nRegsSaved)) :
-					      ((short) sym->stack )) >> 8) & 0xff);
+	      
+	      offset = (((sym->stack < 0) ? 
+			 ((short) (sym->stack - _G.nRegsSaved)) :
+			 ((short) sym->stack )) >> 8) & 0xff;
+	  
+	      emitcode ("addc","a,#!constbyte", offset);
+
 	      aopPut (AOP (IC_RESULT (ic)), "b", 0);
 	      aopPut (AOP (IC_RESULT (ic)), "a", 1);
 	      aopPut (AOP (IC_RESULT (ic)), buff, 2);
@@ -10503,13 +10709,13 @@ genAddrOf (iCode * ic)
       if (offset) {
 	  switch (offset) {
 	  case 1:
-	      tsprintf(s, sizeof(s), "!his",sym->rname);
+	      tsprintf(s, sizeof(s), "#!his",sym->rname);
 	      break;
 	  case 2:
-	      tsprintf(s, sizeof(s), "!hihis",sym->rname);
+	      tsprintf(s, sizeof(s), "#!hihis",sym->rname);
 	      break;
 	  case 3:
-	      tsprintf(s, sizeof(s), "!hihihis",sym->rname);
+	      tsprintf(s, sizeof(s), "#!hihihis",sym->rname);
 	      break;
 	  default: /* should not need this (just in case) */
 	      SNPRINTF (s, sizeof(s), "#(%s >> %d)",
@@ -10530,6 +10736,7 @@ release:
 
 }
 
+#if 0 // obsolete, and buggy for != xdata
 /*-----------------------------------------------------------------*/
 /* genArrayInit - generates code for address of                       */
 /*-----------------------------------------------------------------*/
@@ -10638,6 +10845,7 @@ genArrayInit (iCode * ic)
     
     freeAsmop (IC_LEFT(ic), NULL, ic, TRUE);
 }
+#endif
 
 /*-----------------------------------------------------------------*/
 /* genFarFarAssign - assignment when both are in far space         */
@@ -10910,11 +11118,11 @@ genCast (iCode * ic)
     return;
 
   aopOp (right, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_USESDPTR(right));
+  aopOp (result, ic, FALSE, (AOP_TYPE(right) == AOP_DPTR));
 
   /* 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 (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 */
@@ -11087,7 +11295,7 @@ genCast (iCode * ic)
   /* also, if the source is a bit, we don't need to sign extend, because
    * it can't possibly have set the sign bit.
    */
-  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--)
 	{
@@ -11201,53 +11409,55 @@ genDjnz (iCode * ic, iCode * ifx)
 static void
 genReceive (iCode * ic)
 {
-
     int size = getSize (operandType (IC_RESULT (ic)));
     int offset = 0;
     int rb1off ;
     
-    D (emitcode (";", "genReceive ");
-       );
+    D (emitcode (";", "genReceive "););
 
-  if (ic->argreg == 1) { /* first parameter */
-      if (isOperandInFarSpace (IC_RESULT (ic)) &&
-	  (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
-	   IS_TRUE_SYMOP (IC_RESULT (ic))))
-	  {
-	      offset = fReturnSizeDS390 - size;
-	      while (size--)
-		  {
-		      emitcode ("push", "%s", (strcmp (fReturn[fReturnSizeDS390 - offset - 1], "a") ?
-					       fReturn[fReturnSizeDS390 - offset - 1] : "acc"));
-		      offset++;
-		  }
-	      aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
-	      size = AOP_SIZE (IC_RESULT (ic));
-	      offset = 0;
-	      while (size--)
-		  {
-		      emitcode ("pop", "acc");
-		      aopPut (AOP (IC_RESULT (ic)), "a", offset++);
-		  }
-	      
-	  } else {
-	      _G.accInUse++;
-	      aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
-	      _G.accInUse--;
-	      assignResultValue (IC_RESULT (ic));
-	  }
-  } else { /* second receive onwards */
-      /* this gets a little tricky since unused recevies will be
+    if (ic->argreg == 1) 
+    {
+	/* first parameter */
+	if (AOP_IS_STR(IC_RESULT(ic)))
+	{
+	    /* Nothing to do: it's already in the proper place. */
+	    return;
+	}
+	else
+	{
+	    bool useDp2;
+	    
+	    useDp2 = isOperandInFarSpace (IC_RESULT (ic)) &&
+		(OP_SYMBOL (IC_RESULT (ic))->isspilt ||
+		 IS_TRUE_SYMOP (IC_RESULT (ic)));
+	    
+	    _G.accInUse++;
+	    aopOp (IC_RESULT (ic), ic, FALSE, useDp2);
+	    _G.accInUse--; 
+	    
+	    /* Sanity checking... */
+	    if (AOP_USESDPTR(IC_RESULT(ic)))
+	    {
+		werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+			"genReceive got unexpected DPTR.");
+	    }
+	    assignResultValue (IC_RESULT (ic));
+	}
+    } 
+    else 
+    { 
+	/* second receive onwards */
+	/* this gets a little tricky since unused recevies will be
 	 eliminated, we have saved the reg in the type field . and
 	 we use that to figure out which register to use */
-      aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
-      rb1off = ic->argreg;
-      while (size--) {
-	  aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++);
-      }
-      
-  }
-  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+	aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
+	rb1off = ic->argreg;
+	while (size--) 
+	{
+	    aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++);
+	}
+    }
+    freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12145,9 +12355,14 @@ static void genMMDeref (iCode *ic,int nparms, operand **parms)
 		if (rsym->liveFrom != rsym->liveTo) {			
 			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
 			if (AOP_TYPE(IC_RESULT(ic)) != AOP_STR) {
+			    _startLazyDPSEvaluation ();
+			    
 				aopPut(AOP(IC_RESULT(ic)),"dpl",0);
 				aopPut(AOP(IC_RESULT(ic)),"dph",1);
 				aopPut(AOP(IC_RESULT(ic)),"dpx",2);
+
+			    _endLazyDPSEvaluation ();
+			    
 			}
 		}
 	}
@@ -12493,6 +12708,127 @@ static void genSystemGetCurrentID(iCode *ic,int nparms, operand **parms,char *na
 	}
 }
 
+/*-----------------------------------------------------------------*/
+/* 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, FALSE);
+
+      /* 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, FALSE));
+	    offset++;
+	  }
+	}
+
+      freeAsmop (op, NULL, ic, TRUE);
+    }
+
+  op = IC_LEFT (ic);
+  if (op && IS_SYMOP (op))
+    {
+      aopOp (op, ic, FALSE, FALSE);
+
+      /* 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, FALSE));
+	    offset++;
+	  }
+	}
+
+      freeAsmop (op, NULL, ic, TRUE);
+    }
+    
+}
+
+/*-----------------------------------------------------------------*/
+/* genCritical - generate code for start of a critical sequence    */
+/*-----------------------------------------------------------------*/
+static void
+genCritical (iCode *ic)
+{
+  symbol *tlbl = newiTempLabel (NULL);
+
+  D(emitcode(";     genCritical",""));
+  
+  if (IC_RESULT (ic))
+    aopOp (IC_RESULT (ic), ic, TRUE, FALSE);
+
+  emitcode ("setb", "c");
+  emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
+  emitcode ("clr", "c");
+  emitcode ("", "%05d$:", (tlbl->key + 100));
+
+  if (IC_RESULT (ic))
+    outBitC (IC_RESULT (ic)); /* save old ea in an operand */
+  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, 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, 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");
+    }
+}
+
+
+
 /*-----------------------------------------------------------------*/
 /* genBuiltIn - calls the appropriate function to  generating code */
 /* for a built in function 					   */
@@ -12627,13 +12963,13 @@ gen390Code (iCode * lic)
   }
 #if 1
   /* print the allocation information */
-  if (allocInfo)
+  if (allocInfo && currFunc)
     printAllocInfo (currFunc, codeOutFile);
 #endif
   /* if debug information required */
   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);
@@ -12862,9 +13198,27 @@ gen390Code (iCode * lic)
 	  else addSet (&_G.sendSet, ic);
 	  break;
 
+	case DUMMY_READ_VOLATILE:
+	  genDummyRead (ic);
+	  break;
+
+	case CRITICAL:
+	  genCritical (ic);
+	  break;
+
+	case ENDCRITICAL:
+	  genEndCritical (ic);
+	  break;
+	
+        case SWAP:
+	  genSwap (ic);
+	  break;
+          
+#if 0 // obsolete, and buggy for != xdata
 	case ARRAYINIT:
 	    genArrayInit(ic);
 	    break;
+#endif
 	    
 	default:
 	  ic = ic;