X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fmcs51%2Fgen.c;h=2c38a068d64bb89f14ae334c886a7bd4f134ad9f;hb=d46b4a50e1b8b1819d974533a9012b013090f8fd;hp=ac7e903300355ca6bb1f8a98ce07d90d47057c3e;hpb=64b4d0281b7c7a899a70c075e1e61c738ff50c8e;p=fw%2Fsdcc

diff --git a/src/mcs51/gen.c b/src/mcs51/gen.c
index ac7e9033..2c38a068 100644
--- a/src/mcs51/gen.c
+++ b/src/mcs51/gen.c
@@ -28,6 +28,9 @@
       Made everything static
 -------------------------------------------------------------------------*/
 
+#define D
+//#define D(x) x
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -41,7 +44,7 @@
 #ifdef HAVE_ENDIAN_H
 #include <endian.h>
 #else
-#if !defined(__BORLANDC__) && !defined(_MSC_VER)
+#if !defined(__BORLANDC__) && !defined(_MSC_VER) && !defined(__MINGW32__)
 #warning "Cannot determine ENDIANESS of this machine assuming LITTLE_ENDIAN"
 #warning "If you running sdcc on an INTEL 80x86 Platform you are okay"
 #endif
@@ -67,9 +70,7 @@ static char *spname;
 
 char *fReturn8051[] =
 {"dpl", "dph", "b", "a"};
-char *fReturn390[] =
-{"dpl", "dph", "dpx", "b", "a"};
-unsigned fReturnSize = 4;	/* shared with ralloc.c */
+unsigned fReturnSizeMCS51 = 4;	/* shared with ralloc.c */
 char **fReturn = fReturn8051;
 static char *accUse[] =
 {"a", "b"};
@@ -91,7 +92,7 @@ _G;
 extern int mcs51_ptrRegReq;
 extern int mcs51_nRegs;
 extern FILE *codeOutFile;
-static void saverbank (int, iCode *, bool);
+static void saveRBank (int, iCode *, bool);
 #define RESULTONSTACK(x) \
                          (IC_RESULT(x) && IC_RESULT(x)->aop && \
                          IC_RESULT(x)->aop->type == AOP_STK )
@@ -122,7 +123,7 @@ static void
 emitcode (char *inst, char *fmt,...)
 {
   va_list ap;
-  char lb[MAX_INLINEASM];
+  char lb[INITIAL_INLINEASM];
   char *lbp = lb;
 
   va_start (ap, fmt);
@@ -235,7 +236,6 @@ endOfWorld:
       return NULL;
     }
 
-  piCode (ic, stdout);
   /* other wise this is true end of the world */
   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 	  "getFreePtr should never reach here");
@@ -255,21 +255,6 @@ newAsmop (short type)
   return aop;
 }
 
-static void
-genSetDPTR (int n)
-{
-  if (!n)
-    {
-      emitcode (";", "Select standard DPTR");
-      emitcode ("mov", "dps, #0x00");
-    }
-  else
-    {
-      emitcode (";", "Select alternate DPTR");
-      emitcode ("mov", "dps, #0x01");
-    }
-}
-
 /*-----------------------------------------------------------------*/
 /* pointerCode - returns the code for a pointer type               */
 /*-----------------------------------------------------------------*/
@@ -297,7 +282,7 @@ aopForSym (iCode * ic, symbol * sym, bool result)
   /* assign depending on the storage class */
   /* if it is on the stack or indirectly addressable */
   /* space we need to assign either r0 or r1 to it   */
-  if ((sym->onStack && !options.stack10bit) || sym->iaccess)
+  if (sym->onStack || sym->iaccess)
     {
       sym->aop = aop = newAsmop (0);
       aop->aopu.aop_ptr = getFreePtr (ic, &aop, result);
@@ -335,35 +320,6 @@ aopForSym (iCode * ic, symbol * sym, bool result)
       return aop;
     }
 
-  if (sym->onStack && options.stack10bit)
-    {
-      /* It's on the 10 bit stack, which is located in
-       * far data space.
-       */
-
-      if (_G.accInUse)
-	emitcode ("push", "acc");
-
-      emitcode ("mov", "a,_bp");
-      emitcode ("add", "a,#0x%02x",
-		((sym->stack < 0) ?
-		 ((char) (sym->stack - _G.nRegsSaved)) :
-		 ((char) sym->stack)) & 0xff);
-
-      genSetDPTR (1);
-      emitcode ("mov", "dpx1,#0x40");
-      emitcode ("mov", "dph1,#0x00");
-      emitcode ("mov", "dpl1, a");
-      genSetDPTR (0);
-
-      if (_G.accInUse)
-	emitcode ("pop", "acc");
-
-      sym->aop = aop = newAsmop (AOP_DPTR2);
-      aop->size = getSize (sym->type);
-      return aop;
-    }
-
   /* if in bit space */
   if (IN_BITSPACE (space))
     {
@@ -417,9 +373,9 @@ aopForRemat (symbol * sym)
   for (;;)
     {
       if (ic->op == '+')
-	val += operandLitValue (IC_RIGHT (ic));
+	val += (int) operandLitValue (IC_RIGHT (ic));
       else if (ic->op == '-')
-	val -= operandLitValue (IC_RIGHT (ic));
+	val -= (int) operandLitValue (IC_RIGHT (ic));
       else
 	break;
 
@@ -635,10 +591,10 @@ aopOp (operand * op, iCode * ic, bool result)
 
       if (sym->ruonly)
 	{
-	  int i;
+	  unsigned i;
 	  aop = op->aop = sym->aop = newAsmop (AOP_STR);
 	  aop->size = getSize (sym->type);
-	  for (i = 0; i < fReturnSize; i++)
+	  for (i = 0; i < fReturnSizeMCS51; i++)
 	    aop->aopu.aop_str[i] = fReturn[i];
 	  return;
 	}
@@ -715,15 +671,6 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
 
 	getFreePtr (ic, &aop, FALSE);
 
-	if (options.stack10bit)
-	  {
-	    /* I'm not sure what to do here yet... */
-	    /* #STUB */
-	    fprintf (stderr,
-		     "*** Warning: probably generating bad code for "
-		     "10 bit stack mode.\n");
-	  }
-
 	if (stk)
 	  {
 	    emitcode ("mov", "a,_bp");
@@ -820,13 +767,6 @@ aopGet (asmop * aop, int offset, bool bit16, bool dname)
       return rs;
 
     case AOP_DPTR:
-    case AOP_DPTR2:
-
-      if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (1);
-	}
-
       while (offset > aop->coff)
 	{
 	  emitcode ("inc", "dptr");
@@ -849,12 +789,6 @@ aopGet (asmop * aop, int offset, bool bit16, bool dname)
 	{
 	  emitcode ("movx", "a,@dptr");
 	}
-
-      if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (0);
-	}
-
       return (dname ? "acc" : "a");
 
 
@@ -924,7 +858,6 @@ static void
 aopPut (asmop * aop, char *s, int offset)
 {
   char *d = buffer;
-  symbol *lbl;
 
   if (aop->size && offset > (aop->size - 1))
     {
@@ -971,13 +904,6 @@ aopPut (asmop * aop, char *s, int offset)
       break;
 
     case AOP_DPTR:
-    case AOP_DPTR2:
-
-      if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (1);
-	}
-
       if (aop->code)
 	{
 	  werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
@@ -1003,11 +929,6 @@ aopPut (asmop * aop, char *s, int offset)
       MOVA (s);
 
       emitcode ("movx", "@dptr,a");
-
-      if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (0);
-	}
       break;
 
     case AOP_R0:
@@ -1079,17 +1000,18 @@ aopPut (asmop * aop, char *s, int offset)
 	    emitcode ("mov", "%s,c", aop->aopu.aop_dir);
 	  else
 	    {
-	      lbl = newiTempLabel (NULL);
-
 	      if (strcmp (s, "a"))
 		{
 		  MOVA (s);
 		}
-	      emitcode ("clr", "c");
-	      emitcode ("jz", "%05d$", lbl->key + 100);
-	      emitcode ("cpl", "c");
-	      emitcode ("", "%05d$:", lbl->key + 100);
-	      emitcode ("mov", "%s,c", aop->aopu.aop_dir);
+	      {
+		symbol *lbl = newiTempLabel (NULL);
+		emitcode ("clr", "c; oops");
+		emitcode ("jz", "%05d$", lbl->key + 100);
+		emitcode ("cpl", "c");
+		emitcode ("", "%05d$:", lbl->key + 100);
+		emitcode ("mov", "%s,c", aop->aopu.aop_dir);
+	      }
 	    }
 	}
       break;
@@ -1152,38 +1074,24 @@ pointToEnd (asmop * aop)
 static void
 reAdjustPreg (asmop * aop)
 {
-  int size;
-
-  aop->coff = 0;
-  if ((size = aop->size) <= 1)
+  if ((aop->coff==0) || aop->size <= 1)
     return;
-  size--;
+
   switch (aop->type)
     {
     case AOP_R0:
     case AOP_R1:
-      while (size--)
+      while (aop->coff--)
 	emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
       break;
     case AOP_DPTR:
-    case AOP_DPTR2:
-      if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (1);
-	}
-      while (size--)
+      while (aop->coff--)
 	{
 	  emitcode ("lcall", "__decdptr");
 	}
-
-      if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (0);
-	}
       break;
-
     }
-
+  aop->coff = 0;
 }
 
 #define AOP(op) op->aop
@@ -1193,8 +1101,7 @@ reAdjustPreg (asmop * aop)
                        AOP_TYPE(x) == AOP_R0))
 
 #define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY ||  \
-                        AOP_TYPE(x) == AOP_DPTR || AOP_TYPE(x) == AOP_DPTR2 || \
-                         AOP(x)->paged))
+                        AOP_TYPE(x) == AOP_DPTR || AOP(x)->paged))
 
 #define AOP_INPREG(x) (x && (x->type == AOP_REG &&                        \
                       (x->aopu.aop_reg[0] == mcs51_regWithIdx(R0_IDX) || \
@@ -1225,7 +1132,6 @@ genNotFloat (operand * op, operand * res)
 		aopGet (op->aop,
 			offset++, FALSE, FALSE));
     }
-  tlbl = newiTempLabel (NULL);
 
   tlbl = newiTempLabel (NULL);
   aopPut (res->aop, one, 1);
@@ -1540,9 +1446,10 @@ saveRegisters (iCode * lic)
       return;
     }
 
-  /* if the registers have been saved already then
+  /* if the registers have been saved already or don't need to be then
      do nothing */
-  if (ic->regsSaved || (OP_SYMBOL (IC_LEFT (ic))->calleeSave))
+  if (ic->regsSaved || (OP_SYMBOL (IC_LEFT (ic))->calleeSave) ||
+      SPEC_NAKED(OP_SYM_ETYPE(IC_LEFT (ic))))
     return;
 
   /* find the registers in use at this time
@@ -1580,12 +1487,6 @@ saveRegisters (iCode * lic)
       }
 
   detype = getSpec (operandType (IC_LEFT (ic)));
-  if (detype &&
-      (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)) &&
-      IS_ISR (currFunc->etype) &&
-      !ic->bankSaved)
-
-    saverbank (SPEC_BANK (detype), ic, TRUE);
 
 }
 /*-----------------------------------------------------------------*/
@@ -1713,6 +1614,7 @@ genIpush (iCode * ic)
   int size, offset = 0;
   char *l;
 
+  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 */
@@ -1800,31 +1702,42 @@ genIpop (iCode * ic)
 }
 
 /*-----------------------------------------------------------------*/
-/* unsaverbank - restores the resgister bank from stack            */
+/* unsaveRBank - restores the resgister bank from stack            */
 /*-----------------------------------------------------------------*/
 static void
-unsaverbank (int bank, iCode * ic, bool popPsw)
+unsaveRBank (int bank, iCode * ic, bool popPsw)
 {
   int i;
-  asmop *aop;
+  asmop *aop = NULL;
   regs *r = NULL;
 
+  if (options.useXstack)
+  {
+      if (!ic)
+      {
+      	  /* Assume r0 is available for use. */
+      	  r = mcs51_regWithIdx (R0_IDX);;          
+      }	
+      else
+      {
+	  aop = newAsmop (0);
+	  r = getFreePtr (ic, &aop, FALSE);
+      }
+      emitcode ("mov", "%s,_spx", r->name);      
+  }
+  
   if (popPsw)
     {
       if (options.useXstack)
-	{
-	  aop = newAsmop (0);
-	  r = getFreePtr (ic, &aop, FALSE);
-
-
-	  emitcode ("mov", "%s,_spx", r->name);
+      {
 	  emitcode ("movx", "a,@%s", r->name);
 	  emitcode ("mov", "psw,a");
 	  emitcode ("dec", "%s", r->name);
-
 	}
       else
+      {
 	emitcode ("pop", "psw");
+      }
     }
 
   for (i = (mcs51_nRegs - 1); i >= 0; i--)
@@ -1844,30 +1757,38 @@ unsaverbank (int bank, iCode * ic, bool popPsw)
 
   if (options.useXstack)
     {
-
       emitcode ("mov", "_spx,%s", r->name);
-      freeAsmop (NULL, aop, ic, TRUE);
-
     }
+    
+  if (aop)
+  {
+      freeAsmop (NULL, aop, ic, TRUE);  
+  }    
 }
 
 /*-----------------------------------------------------------------*/
-/* saverbank - saves an entire register bank on the stack          */
+/* saveRBank - saves an entire register bank on the stack          */
 /*-----------------------------------------------------------------*/
 static void
-saverbank (int bank, iCode * ic, bool pushPsw)
+saveRBank (int bank, iCode * ic, bool pushPsw)
 {
   int i;
-  asmop *aop;
+  asmop *aop = NULL;
   regs *r = NULL;
 
   if (options.useXstack)
     {
-
-      aop = newAsmop (0);
-      r = getFreePtr (ic, &aop, FALSE);
+      if (!ic)
+      {
+      	  /* Assume r0 is available for use. */
+      	  r = mcs51_regWithIdx (R0_IDX);;
+      }
+      else
+      {
+      	  aop = newAsmop (0);
+      	  r = getFreePtr (ic, &aop, FALSE);
+      }
       emitcode ("mov", "%s,_spx", r->name);
-
     }
 
   for (i = 0; i < mcs51_nRegs; i++)
@@ -1892,16 +1813,25 @@ saverbank (int bank, iCode * ic, bool pushPsw)
 	  emitcode ("movx", "@%s,a", r->name);
 	  emitcode ("inc", "%s", r->name);
 	  emitcode ("mov", "_spx,%s", r->name);
-	  freeAsmop (NULL, aop, ic, TRUE);
 
 	}
       else
+      {
 	emitcode ("push", "psw");
+      }
 
       emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
     }
-  ic->bankSaved = 1;
 
+    if (aop)
+    {
+        freeAsmop (NULL, aop, ic, TRUE);
+    }
+
+  if (ic)
+  {  
+      ic->bankSaved = 1;
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -1911,22 +1841,10 @@ static void
 genCall (iCode * ic)
 {
   sym_link *detype;
+  bool restoreBank = FALSE;
+  bool swapBanks = FALSE;
 
-  /* if caller saves & we have not saved then */
-  if (!ic->regsSaved)
-    saveRegisters (ic);
-
-  /* if we are calling a function that is not using
-     the same register bank then we need to save the
-     destination registers on the stack */
-  detype = getSpec (operandType (IC_LEFT (ic)));
-  if (detype &&
-      (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)) &&
-      IS_ISR (currFunc->etype) &&
-      !ic->bankSaved)
-
-    saverbank (SPEC_BANK (detype), ic, TRUE);
-
+  D(emitcode(";", "genCall"));
   /* if send set is not empty the assign */
   if (_G.sendSet)
     {
@@ -1952,11 +1870,47 @@ genCall (iCode * ic)
 	}
       _G.sendSet = NULL;
     }
+
+  /* if we are calling a not _naked function that is not using
+     the same register bank then we need to save the
+     destination registers on the stack */
+  detype = getSpec (operandType (IC_LEFT (ic)));
+  if (detype && !SPEC_NAKED(detype) &&
+      (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)) &&
+      IS_ISR (currFunc->etype))
+  {
+      if (!ic->bankSaved) 
+      {
+           /* This is unexpected; the bank should have been saved in
+            * genFunction.
+            */
+    	   saveRBank (SPEC_BANK (detype), ic, FALSE);
+    	   restoreBank = TRUE;
+      }
+      swapBanks = TRUE;  
+  } 
+    
+  /* if caller saves & we have not saved then */
+  if (!ic->regsSaved)
+      saveRegisters (ic);
+
+  if (swapBanks)
+  {
+        emitcode ("mov", "psw,#0x%02x", 
+           ((SPEC_BANK(detype)) << 3) & 0xff);
+  }
+
   /* make the call */
   emitcode ("lcall", "%s", (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
 			    OP_SYMBOL (IC_LEFT (ic))->rname :
 			    OP_SYMBOL (IC_LEFT (ic))->name));
 
+  if (swapBanks)
+  {
+       emitcode ("mov", "psw,#0x%02x", 
+          ((SPEC_BANK(currFunc->etype)) << 3) & 0xff);
+  }
+
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
@@ -1975,30 +1929,27 @@ genCall (iCode * ic)
 
   /* adjust the stack for parameters if
      required */
-  if (IC_LEFT (ic)->parmBytes)
+  if (ic->parmBytes)
     {
       int i;
-      if (IC_LEFT (ic)->parmBytes > 3)
+      if (ic->parmBytes > 3)
 	{
 	  emitcode ("mov", "a,%s", spname);
-	  emitcode ("add", "a,#0x%02x", (-IC_LEFT (ic)->parmBytes) & 0xff);
+	  emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
 	  emitcode ("mov", "%s,a", spname);
 	}
       else
-	for (i = 0; i < IC_LEFT (ic)->parmBytes; i++)
+	for (i = 0; i < ic->parmBytes; i++)
 	  emitcode ("dec", "%s", spname);
-
     }
 
-  /* if register bank was saved then pop them */
-  if (ic->bankSaved)
-    unsaverbank (SPEC_BANK (detype), ic, TRUE);
-
   /* if we hade saved some registers then unsave them */
   if (ic->regsSaved && !(OP_SYMBOL (IC_LEFT (ic))->calleeSave))
     unsaveRegisters (ic);
 
-
+  /* if register bank was saved then pop them */
+  if (restoreBank)
+    unsaveRBank (SPEC_BANK (detype), ic, FALSE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -2022,7 +1973,7 @@ genPcall (iCode * ic)
   if (detype &&
       IS_ISR (currFunc->etype) &&
       (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)))
-    saverbank (SPEC_BANK (detype), ic, TRUE);
+    saveRBank (SPEC_BANK (detype), ic, TRUE);
 
 
   /* push the return address on to the stack */
@@ -2031,12 +1982,6 @@ genPcall (iCode * ic)
   emitcode ("mov", "a,#(%05d$ >> 8)", (rlbl->key + 100));
   emitcode ("push", "acc");
 
-  if (options.model == MODEL_FLAT24)
-    {
-      emitcode ("mov", "a,#(%05d$ >> 16)", (rlbl->key + 100));
-      emitcode ("push", "acc");
-    }
-
   /* now push the calling address */
   aopOp (IC_LEFT (ic), ic, FALSE);
 
@@ -2092,17 +2037,17 @@ genPcall (iCode * ic)
 
   /* adjust the stack for parameters if
      required */
-  if (IC_LEFT (ic)->parmBytes)
+  if (ic->parmBytes)
     {
       int i;
-      if (IC_LEFT (ic)->parmBytes > 3)
+      if (ic->parmBytes > 3)
 	{
 	  emitcode ("mov", "a,%s", spname);
-	  emitcode ("add", "a,#0x%02x", (-IC_LEFT (ic)->parmBytes) & 0xff);
+	  emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
 	  emitcode ("mov", "%s,a", spname);
 	}
       else
-	for (i = 0; i < IC_LEFT (ic)->parmBytes; i++)
+	for (i = 0; i < ic->parmBytes; i++)
 	  emitcode ("dec", "%s", spname);
 
     }
@@ -2111,7 +2056,7 @@ genPcall (iCode * ic)
   if (detype &&
       (SPEC_BANK (currFunc->etype) !=
        SPEC_BANK (detype)))
-    unsaverbank (SPEC_BANK (detype), ic, TRUE);
+    unsaveRBank (SPEC_BANK (detype), ic, TRUE);
 
   /* if we hade saved some registers then
      unsave them */
@@ -2174,6 +2119,7 @@ genFunction (iCode * ic)
 {
   symbol *sym;
   sym_link *fetype;
+  bool   switchedPSW = FALSE;
 
   _G.nRegsSaved = 0;
   /* create the function header */
@@ -2184,6 +2130,12 @@ genFunction (iCode * ic)
   emitcode ("", "%s:", sym->rname);
   fetype = getSpec (operandType (IC_LEFT (ic)));
 
+  if (SPEC_NAKED(fetype))
+  {
+      emitcode(";", "naked function: no prologue.");
+      return;
+  }
+
   /* if critical function then turn interrupts off */
   if (SPEC_CRTCL (fetype))
     emitcode ("clr", "ea");
@@ -2222,20 +2174,6 @@ genFunction (iCode * ic)
 	emitcode ("push", "dpl");
       if (!inExcludeList ("dph"))
 	emitcode ("push", "dph");
-      if (options.model == MODEL_FLAT24 && !inExcludeList ("dpx"))
-	{
-	  emitcode ("push", "dpx");
-	  /* Make sure we're using standard DPTR */
-	  emitcode ("push", "dps");
-	  emitcode ("mov", "dps, #0x00");
-	  if (options.stack10bit)
-	    {
-	      /* This ISR could conceivably use DPTR2. Better save it. */
-	      emitcode ("push", "dpl1");
-	      emitcode ("push", "dph1");
-	      emitcode ("push", "dpx1");
-	    }
-	}
       /* if this isr has no bank i.e. is going to
          run with bank 0 , then we need to save more
          registers :-) */
@@ -2265,10 +2203,99 @@ genFunction (iCode * ic)
 	  else
 	    {
 	      /* this function has  a function call cannot
-	         determines register usage so we will have the
+	         determines register usage so we will have to push the
 	         entire bank */
-	      saverbank (0, ic, FALSE);
+	      saveRBank (0, ic, FALSE);
+	    }
+	}
+	else
+	{
+	    /* This ISR uses a non-zero bank.
+	     *
+	     * We assume that the bank is available for our
+	     * exclusive use.
+	     *
+	     * However, if this ISR calls a function which uses some
+	     * other bank, we must save that bank entirely.
+	     */
+	    unsigned long banksToSave = 0;
+	    
+	    if (sym->hasFcall)
+	    {
+
+#define MAX_REGISTER_BANKS 4
+
+	        iCode *i;
+	        int ix;
+
+	        for (i = ic; i; i = i->next)
+	        {
+	            if (i->op == ENDFUNCTION)
+	            {
+	                /* we got to the end OK. */
+	                break;
+	            }
+	            
+	            if (i->op == CALL)
+	            {
+	                sym_link *detype;
+	                
+	                detype = getSpec(operandType (IC_LEFT(i)));
+	                if (detype 
+	                 && SPEC_BANK(detype) != SPEC_BANK(sym->etype))
+	                {
+	                     /* Mark this bank for saving. */
+	                     if (SPEC_BANK(detype) >= MAX_REGISTER_BANKS)
+	                     {
+	                         werror(E_NO_SUCH_BANK, SPEC_BANK(detype));
+	                     }
+	                     else
+	                     {
+	                         banksToSave |= (1 << SPEC_BANK(detype));
+	                     }
+	                     
+	                     /* And note that we don't need to do it in 
+	                      * genCall.
+	                      */
+	                     i->bankSaved = 1;
+	                }
+	            }
+	            if (i->op == PCALL)
+	            {
+	             	/* This is a mess; we have no idea what
+	             	 * register bank the called function might
+	             	 * use.
+	             	 *
+	             	 * The only thing I can think of to do is
+	             	 * throw a warning and hope.
+	             	 */
+	             	werror(W_FUNCPTR_IN_USING_ISR);   
+	            }
+	        }
+
+		if (banksToSave && options.useXstack)
+		{
+		    /* 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", 
+		    	      (SPEC_BANK (sym->etype) << 3) & 0x00ff);
+		    switchedPSW = TRUE;
+		}
+		
+	        for (ix = 0; ix < MAX_REGISTER_BANKS; ix++)
+	        {
+	             if (banksToSave & (1 << ix))
+	             {
+	                 saveRBank(ix, NULL, FALSE);
+	             }
+	        }
 	    }
+	    SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
 	}
     }
   else
@@ -2297,7 +2324,8 @@ genFunction (iCode * ic)
     }
 
   /* set the register bank to the desired value */
-  if (SPEC_BANK (sym->etype) || IS_ISR (sym->etype))
+  if ((SPEC_BANK (sym->etype) || IS_ISR (sym->etype))
+   && !switchedPSW)
     {
       emitcode ("push", "psw");
       emitcode ("mov", "psw,#0x%02x", (SPEC_BANK (sym->etype) << 3) & 0x00ff);
@@ -2360,6 +2388,12 @@ genEndFunction (iCode * ic)
 {
   symbol *sym = OP_SYMBOL (IC_LEFT (ic));
 
+  if (SPEC_NAKED(sym->etype))
+  {
+      emitcode(";", "naked function: no epilogue.");
+      return;
+  }
+
   if (IS_RENT (sym->etype) || options.stackAuto)
     {
       emitcode ("mov", "%s,_bp", spname);
@@ -2393,7 +2427,16 @@ genEndFunction (iCode * ic)
 
   /* restore the register bank  */
   if (SPEC_BANK (sym->etype) || IS_ISR (sym->etype))
-    emitcode ("pop", "psw");
+  {
+    if (!SPEC_BANK (sym->etype) || !IS_ISR (sym->etype)
+     || !options.useXstack)
+    {
+        /* Special case of ISR using non-zero bank with useXstack
+         * is handled below.
+         */
+        emitcode ("pop", "psw");
+    }
+  }
 
   if (IS_ISR (sym->etype))
     {
@@ -2404,7 +2447,6 @@ genEndFunction (iCode * ic)
          registers :-) */
       if (!SPEC_BANK (sym->etype))
 	{
-
 	  /* if this function does not call any other
 	     function then we can be economical and
 	     save only those registers that are used */
@@ -2428,23 +2470,38 @@ genEndFunction (iCode * ic)
 	  else
 	    {
 	      /* this function has  a function call cannot
-	         determines register usage so we will have the
+	         determines register usage so we will have to pop the
 	         entire bank */
-	      unsaverbank (0, ic, FALSE);
+	      unsaveRBank (0, ic, FALSE);
 	    }
 	}
-
-      if (options.model == MODEL_FLAT24 && !inExcludeList ("dpx"))
+	else
 	{
-	  if (options.stack10bit)
+	    /* This ISR uses a non-zero bank.
+	     *
+	     * Restore any register banks saved by genFunction
+	     * in reverse order.
+	     */
+	    unsigned savedBanks = SPEC_ISR_SAVED_BANKS(currFunc->etype);
+	    int ix;
+	  
+	    for (ix = MAX_REGISTER_BANKS - 1; ix >= 0; ix--)
+	    {
+	        if (savedBanks & (1 << ix))
+	        {
+	            unsaveRBank(ix, NULL, FALSE);
+	        }
+	    }
+	    
+	    if (options.useXstack)
 	    {
-	      emitcode ("pop", "dpx1");
-	      emitcode ("pop", "dph1");
-	      emitcode ("pop", "dpl1");
+	    	/* Restore bank AFTER calling unsaveRBank,
+	     	 * since it can trash r0.
+	     	 */
+	    	emitcode ("pop", "psw");
 	    }
-	  emitcode ("pop", "dps");
-	  emitcode ("pop", "dpx");
 	}
+
       if (!inExcludeList ("dph"))
 	emitcode ("pop", "dph");
       if (!inExcludeList ("dpl"))
@@ -2458,8 +2515,8 @@ genEndFunction (iCode * ic)
 	emitcode ("setb", "ea");
 
       /* if debug then send end of function */
-/*  if (options.debug && currFunc) { */
-      if (currFunc)
+      /*  if (options.debug && currFunc)  */
+      if (options.debug && currFunc)
 	{
 	  _G.debugLine = 1;
 	  emitcode ("", "C$%s$%d$%d$%d ==.",
@@ -2498,7 +2555,7 @@ genEndFunction (iCode * ic)
 	}
 
       /* if debug then send end of function */
-      if (currFunc)
+      if (options.debug && currFunc)
 	{
 	  _G.debugLine = 1;
 	  emitcode ("", "C$%s$%d$%d$%d ==.",
@@ -2642,7 +2699,7 @@ genPlusIncr (iCode * ic)
 
   /* if the literal value of the right hand side
      is greater than 4 then it is not worth it */
-  if ((icount = floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
+  if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
     return FALSE;
 
   /* if increment 16 bits in register */
@@ -3223,7 +3280,7 @@ genMultbits (operand * left,
 
 
 /*-----------------------------------------------------------------*/
-/* genMultOneByte : 8 bit multiplication & division                */
+/* genMultOneByte : 8*8=8/16 bit multiplication                    */
 /*-----------------------------------------------------------------*/
 static void
 genMultOneByte (operand * left,
@@ -3231,89 +3288,99 @@ genMultOneByte (operand * left,
 		operand * result)
 {
   sym_link *opetype = operandType (result);
-  char *l;
   symbol *lbl;
-  int size, offset;
+  int size=AOP_SIZE(result);
+
+  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 two literals: the value is computed before) */
   /* if one literal, literal on the right */
   if (AOP_TYPE (left) == AOP_LIT)
     {
       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);
     }
+    return;
+  }
 
-  size = AOP_SIZE (result);
-  /* signed or unsigned */
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-  l = aopGet (AOP (left), 0, FALSE, FALSE);
-  MOVA (l);
-  emitcode ("mul", "ab");
-  /* if result size = 1, mul signed = mul unsigned */
-  aopPut (AOP (result), "a", 0);
-  if (size > 1)
-    {
-      if (SPEC_USIGN (opetype))
-	{
-	  aopPut (AOP (result), "b", 1);
-	  if (size > 2)
-	    /* for filling the MSBs */
-	    emitcode ("clr", "a");
-	}
-      else
-	{
-	  emitcode ("mov", "a,b");
+  // we have to do a signed multiply
 
-	  /* adjust the MSB if left or right neg */
+  //emitcode (";", "signed");
+  emitcode ("clr", "F0"); // reset sign flag
+  MOVA (aopGet (AOP (left), 0, FALSE, FALSE));
 
-	  /* if one literal */
-	  if (AOP_TYPE (right) == AOP_LIT)
-	    {
-	      /* AND literal negative */
-	      if ((int) floatFromVal (AOP (right)->aopu.aop_lit) < 0)
-		{
-		  /* adjust MSB (c==0 after mul) */
-		  emitcode ("subb", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE));
-		}
-	    }
-	  else
-	    {
-	      lbl = newiTempLabel (NULL);
-	      emitcode ("xch", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-	      emitcode ("cjne", "a,#0x80,%05d$", (lbl->key + 100));
-	      emitcode ("", "%05d$:", (lbl->key + 100));
-	      emitcode ("xch", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-	      lbl = newiTempLabel (NULL);
-	      emitcode ("jc", "%05d$", (lbl->key + 100));
-	      emitcode ("subb", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE));
-	      emitcode ("", "%05d$:", (lbl->key + 100));
-	    }
+  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");
 
-	  lbl = newiTempLabel (NULL);
-	  emitcode ("xch", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE));
-	  emitcode ("cjne", "a,#0x80,%05d$", (lbl->key + 100));
-	  emitcode ("", "%05d$:", (lbl->key + 100));
-	  emitcode ("xch", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE));
-	  lbl = newiTempLabel (NULL);
-	  emitcode ("jc", "%05d$", (lbl->key + 100));
-	  emitcode ("subb", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE));
-	  emitcode ("", "%05d$:", (lbl->key + 100));
+  emitcode ("", "%05d$:", lbl->key+100);
+
+  /* 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);
+    }
+  } 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");
+  }
 
-	  aopPut (AOP (result), "a", 1);
-	  if (size > 2)
-	    {
-	      /* get the sign */
-	      emitcode ("rlc", "a");
-	      emitcode ("subb", "a,acc");
-	    }
-	}
-      size -= 2;
-      offset = 2;
-      if (size > 0)
-	while (size--)
-	  aopPut (AOP (result), "a", offset++);
-    }
+  emitcode ("", "%05d$:", lbl->key+100);
+  aopPut (AOP (result), "a", 0);
+  if (size==2) {
+    aopPut (AOP (result), "b", 1);
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3685,7 +3752,7 @@ genIfxJump (iCode * ic, char *jval)
 /*-----------------------------------------------------------------*/
 static void
 genCmp (operand * left, operand * right,
-	operand * result, iCode * ifx, int sign)
+	operand * result, iCode * ifx, int sign, iCode *ic)
 {
   int size, offset = 0;
   unsigned long lit = 0L;
@@ -3769,6 +3836,8 @@ genCmp (operand * left, operand * right,
     }
 
 release:
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
     {
       outBitC (result);
@@ -3808,10 +3877,8 @@ genCmpGt (iCode * ic, iCode * ifx)
   aopOp (right, ic, FALSE);
   aopOp (result, ic, TRUE);
 
-  genCmp (right, left, result, ifx, sign);
+  genCmp (right, left, result, ifx, sign,ic);
 
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
-  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -3838,10 +3905,8 @@ genCmpLt (iCode * ic, iCode * ifx)
   aopOp (right, ic, FALSE);
   aopOp (result, ic, TRUE);
 
-  genCmp (left, right, result, ifx, sign);
+  genCmp (left, right, result, ifx, sign,ic);
 
-  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
-  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -4120,6 +4185,37 @@ ifxForOp (operand * op, iCode * ic)
 
   return NULL;
 }
+
+/*-----------------------------------------------------------------*/
+/* hasInc - operand is incremented before any other use            */
+/*-----------------------------------------------------------------*/
+static iCode *
+hasInc (operand *op, iCode *ic)
+{
+  sym_link *type = operandType(op);
+  sym_link *retype = getSpec (type);
+  iCode *lic = ic->next;
+  int isize ;
+  
+  if (IS_BITVAR(retype)||!IS_PTR(type)) return NULL;
+  isize = getSize(type->next);
+  while (lic) {
+    /* if operand of the form op = op + <sizeof *op> */
+    if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) &&
+	isOperandEqual(IC_RESULT(lic),op) && 
+	isOperandLiteral(IC_RIGHT(lic)) &&
+	operandLitValue(IC_RIGHT(lic)) == isize) {
+      return lic;
+    }
+    /* if the operand used or deffed */
+    if (bitVectBitValue(ic->uses,op->key) || (unsigned) ic->defKey == op->key) {
+      return NULL;
+    }
+    lic = lic->next;
+  }
+  return NULL;
+}
+
 /*-----------------------------------------------------------------*/
 /* genAndOp - for && operation                                     */
 /*-----------------------------------------------------------------*/
@@ -4502,9 +4598,20 @@ genAnd (iCode * ic, iCode * ifx)
 	    emitcode ("setb", "c");
 	  while (sizer--)
 	    {
-	      MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-	      emitcode ("anl", "a,%s",
-			aopGet (AOP (left), offset, FALSE, FALSE));
+	      if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+		emitcode ("anl", "a,%s",
+			  aopGet (AOP (right), offset, FALSE, FALSE));
+	      } else {
+		if (AOP_TYPE(left)==AOP_ACC) {
+		  emitcode("mov", "b,a");
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+		  emitcode("anl", "a,b");
+		}else {
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+		  emitcode ("anl", "a,%s",
+			    aopGet (AOP (left), offset, FALSE, FALSE));
+		}
+	      }
 	      emitcode ("jnz", "%05d$", tlbl->key + 100);
 	      offset++;
 	    }
@@ -4771,9 +4878,14 @@ genOr (iCode * ic, iCode * ifx)
 	    emitcode ("setb", "c");
 	  while (sizer--)
 	    {
-	      MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-	      emitcode ("orl", "a,%s",
-			aopGet (AOP (left), offset, FALSE, FALSE));
+	      if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+		emitcode ("orl", "a,%s",
+			  aopGet (AOP (right), offset, FALSE, FALSE));
+	      } else {
+		MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+		emitcode ("orl", "a,%s",
+			  aopGet (AOP (left), offset, FALSE, FALSE));
+	      }
 	      emitcode ("jnz", "%05d$", tlbl->key + 100);
 	      offset++;
 	    }
@@ -5023,9 +5135,14 @@ genXor (iCode * ic, iCode * ifx)
 		}
 	      else
 		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
-		  emitcode ("xrl", "a,%s",
-			    aopGet (AOP (left), offset, FALSE, FALSE));
+		  if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+		    emitcode ("xrl", "a,%s",
+			      aopGet (AOP (right), offset, FALSE, FALSE));
+		  } else {
+		    MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+		    emitcode ("xrl", "a,%s",
+			      aopGet (AOP (left), offset, FALSE, FALSE));
+		  }
 		}
 	      emitcode ("jnz", "%05d$", tlbl->key + 100);
 	      offset++;
@@ -5080,11 +5197,11 @@ release:
 static void
 genInline (iCode * ic)
 {
-  char buffer[MAX_INLINEASM];
-  char *bp = buffer;
-  char *bp1 = buffer;
+  char *buffer, *bp, *bp1;
 
   _G.inLine += (!options.asmpeep);
+
+  buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
   strcpy (buffer, IC_INLINE (ic));
 
   /* emit each line as a code */
@@ -5507,18 +5624,25 @@ AccAXLsh (char *x, int shCount)
 
       break;
     case 6:			// AAAAAABB:CCCCCCDD
-
       emitcode ("anl", "a,#0x%02x",
 		SRMask[shCount]);	// 000000BB:CCCCCCDD
-
       emitcode ("mov", "c,acc.0");	// c = B
-
       emitcode ("xch", "a,%s", x);	// CCCCCCDD:000000BB
-
+#if 0 // REMOVE ME
       AccAXRrl1 (x);		// BCCCCCCD:D000000B
-
       AccAXRrl1 (x);		// BBCCCCCC:DD000000
-
+#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); 
+#endif
       break;
     case 7:			// a:x <<= 7
 
@@ -5938,7 +6062,7 @@ genlshFour (operand * result, operand * left, int shCount)
 	movLeft2Result (left, LSB, result, MSB32, 0);
       aopPut (AOP (result), zero, LSB);
       aopPut (AOP (result), zero, MSB16);
-      aopPut (AOP (result), zero, MSB32);
+      aopPut (AOP (result), zero, MSB24);
       return;
     }
 
@@ -6054,13 +6178,15 @@ genLeftShiftLiteral (operand * left,
 	  break;
 
 	case 2:
-	case 3:
 	  genlshTwo (result, left, shCount);
 	  break;
 
 	case 4:
 	  genlshFour (result, left, shCount);
 	  break;
+	default:
+	  fprintf(stderr, "*** ack! mystery literal shift!\n");
+	  break;
 	}
     }
   freeAsmop (left, NULL, ic, TRUE);
@@ -6214,22 +6340,48 @@ static void
 shiftRLong (operand * left, int offl,
 	    operand * result, int sign)
 {
-  if (!sign)
-    emitcode ("clr", "c");
+  int isSameRegs=sameRegs(AOP(left),AOP(result));
+
+  if (isSameRegs && offl>1) {
+    // we are in big trouble, but this shouldn't happen
+    werror(E_INTERNAL_ERROR, __FILE__, __LINE__);
+  }
+
   MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
-  if (sign)
+  
+  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));
+    } else {
+      aopPut (AOP(result), zero, MSB32);
+    }
+  }
+
+  if (!sign) {
+    emitcode ("clr", "c");
+  } else {
     emitcode ("mov", "c,acc.7");
-  emitcode ("rrc", "a");
-  aopPut (AOP (result), "a", MSB32 - offl);
-  if (offl == MSB16)
-    /* add sign of "a" */
-    addSign (result, MSB32, sign);
+  }
 
-  MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
   emitcode ("rrc", "a");
-  aopPut (AOP (result), "a", MSB24 - offl);
 
-  MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
+  if (isSameRegs && offl==MSB16) {
+    emitcode ("xch", "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE));
+  } else {
+    aopPut (AOP (result), "a", MSB32);
+    MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
+  }
+
+  emitcode ("rrc", "a");
+  if (isSameRegs && offl==1) {
+    emitcode ("xch", "a,%s",aopGet (AOP (left), MSB16, FALSE, FALSE));
+  } else {
+    aopPut (AOP (result), "a", MSB24);
+    MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
+  }
   emitcode ("rrc", "a");
   aopPut (AOP (result), "a", MSB16 - offl);
 
@@ -6754,7 +6906,8 @@ genDataPointerGet (operand * left,
 static void
 genNearPointerGet (operand * left,
 		   operand * result,
-		   iCode * ic)
+		   iCode * ic,
+		   iCode * pi)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -6795,7 +6948,6 @@ genNearPointerGet (operand * left,
   else
     rname = aopGet (AOP (left), 0, FALSE, FALSE);
 
-  freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE);
 
   /* if bitfield then unpack the bits */
@@ -6821,15 +6973,17 @@ genNearPointerGet (operand * left,
 	      aopPut (AOP (result), buffer, offset);
 	    }
 	  offset++;
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "%s", rname);
 	}
     }
 
   /* now some housekeeping stuff */
-  if (aop)
+  if (aop)       /* we had to allocate for this iCode */
     {
-      /* we had to allocate for this iCode */
+      if (pi) { /* post increment present */
+	aopPut(AOP ( left ),rname,0);
+      }
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -6839,10 +6993,11 @@ genNearPointerGet (operand * left,
          if size > 0 && this could be used again
          we have to point it back to where it
          belongs */
-      if (AOP_SIZE (result) > 1 &&
-	  !OP_SYMBOL (left)->remat &&
-	  (OP_SYMBOL (left)->liveTo > ic->seq ||
-	   ic->depth))
+      if ((AOP_SIZE (result) > 1 &&
+	   !OP_SYMBOL (left)->remat &&
+	   (OP_SYMBOL (left)->liveTo > ic->seq ||
+	    ic->depth)) &&
+	  !pi)
 	{
 	  int size = AOP_SIZE (result) - 1;
 	  while (size--)
@@ -6851,8 +7006,9 @@ genNearPointerGet (operand * left,
     }
 
   /* done */
+  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
-
+  if (pi) pi->generated = 1;
 }
 
 /*-----------------------------------------------------------------*/
@@ -6861,7 +7017,8 @@ genNearPointerGet (operand * left,
 static void
 genPagedPointerGet (operand * left,
 		    operand * result,
-		    iCode * ic)
+		    iCode * ic,
+		    iCode *pi)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -6888,7 +7045,6 @@ genPagedPointerGet (operand * left,
   else
     rname = aopGet (AOP (left), 0, FALSE, FALSE);
 
-  freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE);
 
   /* if bitfield then unpack the bits */
@@ -6908,15 +7064,15 @@ genPagedPointerGet (operand * left,
 
 	  offset++;
 
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "%s", rname);
 	}
     }
 
   /* now some housekeeping stuff */
-  if (aop)
+  if (aop) /* we had to allocate for this iCode */
     {
-      /* we had to allocate for this iCode */
+      if (pi) aopPut ( AOP (left), rname, 0);
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -6926,10 +7082,11 @@ genPagedPointerGet (operand * left,
          if size > 0 && this could be used again
          we have to point it back to where it
          belongs */
-      if (AOP_SIZE (result) > 1 &&
-	  !OP_SYMBOL (left)->remat &&
-	  (OP_SYMBOL (left)->liveTo > ic->seq ||
-	   ic->depth))
+      if ((AOP_SIZE (result) > 1 &&
+	   !OP_SYMBOL (left)->remat &&
+	   (OP_SYMBOL (left)->liveTo > ic->seq ||
+	    ic->depth)) &&
+	  !pi)
 	{
 	  int size = AOP_SIZE (result) - 1;
 	  while (size--)
@@ -6938,8 +7095,9 @@ genPagedPointerGet (operand * left,
     }
 
   /* done */
+  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
-
+  if (pi) pi->generated = 1;
 
 }
 
@@ -6948,7 +7106,7 @@ genPagedPointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genFarPointerGet (operand * left,
-		  operand * result, iCode * ic)
+		  operand * result, iCode * ic, iCode * pi)
 {
   int size, offset;
   sym_link *retype = getSpec (operandType (result));
@@ -6966,14 +7124,9 @@ genFarPointerGet (operand * left,
 	{			/* 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));
-	  if (options.model == MODEL_FLAT24)
-	    {
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE));
-	    }
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE);
 
   /* if bit then unpack */
@@ -6988,20 +7141,26 @@ genFarPointerGet (operand * left,
 	{
 	  emitcode ("movx", "a,@dptr");
 	  aopPut (AOP (result), "a", offset++);
-	  if (size)
+	  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);
+    pi->generated = 1;
+  }
+  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
-/* emitcodePointerGet - gget value from code space                  */
+/* genCodePointerGet - gget value from code space                  */
 /*-----------------------------------------------------------------*/
 static void
-emitcodePointerGet (operand * left,
-		    operand * result, iCode * ic)
+genCodePointerGet (operand * left,
+		    operand * result, iCode * ic, iCode *pi)
 {
   int size, offset;
   sym_link *retype = getSpec (operandType (result));
@@ -7019,14 +7178,9 @@ emitcodePointerGet (operand * left,
 	{			/* 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));
-	  if (options.model == MODEL_FLAT24)
-	    {
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE));
-	    }
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE);
 
   /* if bit then unpack */
@@ -7042,11 +7196,17 @@ emitcodePointerGet (operand * left,
 	  emitcode ("clr", "a");
 	  emitcode ("movc", "a,@a+dptr");
 	  aopPut (AOP (result), "a", offset++);
-	  if (size)
+	  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);
+    pi->generated = 1;
+  }
+  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -7055,7 +7215,7 @@ emitcodePointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genGenPointerGet (operand * left,
-		  operand * result, iCode * ic)
+		  operand * result, iCode * ic, iCode *pi)
 {
   int size, offset;
   sym_link *retype = getSpec (operandType (result));
@@ -7076,19 +7236,10 @@ genGenPointerGet (operand * left,
 	{			/* 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));
-	  if (options.model == MODEL_FLAT24)
-	    {
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE));
-	      emitcode ("mov", "b,%s", aopGet (AOP (left), 3, FALSE, FALSE));
-	    }
-	  else
-	    {
-	      emitcode ("mov", "b,%s", aopGet (AOP (left), 2, FALSE, FALSE));
-	    }
+	  emitcode ("mov", "b,%s", aopGet (AOP (left), 2, FALSE, FALSE));
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE);
 
   /* if bit then unpack */
@@ -7103,11 +7254,17 @@ genGenPointerGet (operand * left,
 	{
 	  emitcode ("lcall", "__gptrget");
 	  aopPut (AOP (result), "a", offset++);
-	  if (size)
+	  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);
+    pi->generated = 1;
+  }
+  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -7115,7 +7272,7 @@ genGenPointerGet (operand * left,
 /* genPointerGet - generate code for pointer get                   */
 /*-----------------------------------------------------------------*/
 static void
-genPointerGet (iCode * ic)
+genPointerGet (iCode * ic, iCode *pi)
 {
   operand *left, *result;
   sym_link *type, *etype;
@@ -7135,21 +7292,6 @@ genPointerGet (iCode * ic)
     {
       /* we have to go by the storage class */
       p_type = PTR_TYPE (SPEC_OCLS (etype));
-
-/*  if (SPEC_OCLS(etype)->codesp ) { */
-/*      p_type = CPOINTER ;  */
-/*  } */
-/*  else */
-/*      if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
-/*    p_type = FPOINTER ; */
-/*      else */
-/*    if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
-/*        p_type = PPOINTER; */
-/*    else */
-/*        if (SPEC_OCLS(etype) == idata ) */
-/*      p_type = IPOINTER; */
-/*        else */
-/*      p_type = POINTER ; */
     }
 
   /* now that we have the pointer type we assign
@@ -7159,23 +7301,23 @@ genPointerGet (iCode * ic)
 
     case POINTER:
     case IPOINTER:
-      genNearPointerGet (left, result, ic);
+      genNearPointerGet (left, result, ic, pi);
       break;
 
     case PPOINTER:
-      genPagedPointerGet (left, result, ic);
+      genPagedPointerGet (left, result, ic, pi);
       break;
 
     case FPOINTER:
-      genFarPointerGet (left, result, ic);
+      genFarPointerGet (left, result, ic, pi);
       break;
 
     case CPOINTER:
-      emitcodePointerGet (left, result, ic);
+      genCodePointerGet (left, result, ic, pi);
       break;
 
     case GPOINTER:
-      genGenPointerGet (left, result, ic);
+      genGenPointerGet (left, result, ic, pi);
       break;
     }
 
@@ -7384,7 +7526,8 @@ genDataPointerSet (operand * right,
 static void
 genNearPointerSet (operand * right,
 		   operand * result,
-		   iCode * ic)
+		   iCode * ic,
+		   iCode * pi)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -7422,7 +7565,6 @@ genNearPointerSet (operand * right,
   else
     rname = aopGet (AOP (result), 0, FALSE, FALSE);
 
-  freeAsmop (result, NULL, ic, TRUE);
   aopOp (right, ic, FALSE);
 
   /* if bitfield then unpack the bits */
@@ -7444,16 +7586,16 @@ genNearPointerSet (operand * right,
 	    }
 	  else
 	    emitcode ("mov", "@%s,%s", rname, l);
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "%s", rname);
 	  offset++;
 	}
     }
 
   /* now some housekeeping stuff */
-  if (aop)
+  if (aop) /* we had to allocate for this iCode */
     {
-      /* we had to allocate for this iCode */
+      if (pi) aopPut (AOP (result),rname,0);
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -7463,10 +7605,11 @@ genNearPointerSet (operand * right,
          if size > 0 && this could be used again
          we have to point it back to where it
          belongs */
-      if (AOP_SIZE (right) > 1 &&
-	  !OP_SYMBOL (result)->remat &&
-	  (OP_SYMBOL (result)->liveTo > ic->seq ||
-	   ic->depth))
+      if ((AOP_SIZE (right) > 1 &&
+	   !OP_SYMBOL (result)->remat &&
+	   (OP_SYMBOL (result)->liveTo > ic->seq ||
+	    ic->depth)) &&
+	  !pi)
 	{
 	  int size = AOP_SIZE (right) - 1;
 	  while (size--)
@@ -7475,9 +7618,9 @@ genNearPointerSet (operand * right,
     }
 
   /* done */
+  if (pi) pi->generated = 1;
+  freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
-
-
 }
 
 /*-----------------------------------------------------------------*/
@@ -7486,7 +7629,8 @@ genNearPointerSet (operand * right,
 static void
 genPagedPointerSet (operand * right,
 		    operand * result,
-		    iCode * ic)
+		    iCode * ic,
+		    iCode * pi)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -7513,7 +7657,6 @@ genPagedPointerSet (operand * right,
   else
     rname = aopGet (AOP (result), 0, FALSE, FALSE);
 
-  freeAsmop (result, NULL, ic, TRUE);
   aopOp (right, ic, FALSE);
 
   /* if bitfield then unpack the bits */
@@ -7532,7 +7675,7 @@ genPagedPointerSet (operand * right,
 	  MOVA (l);
 	  emitcode ("movx", "@%s,a", rname);
 
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "%s", rname);
 
 	  offset++;
@@ -7540,9 +7683,9 @@ genPagedPointerSet (operand * right,
     }
 
   /* now some housekeeping stuff */
-  if (aop)
+  if (aop) /* we had to allocate for this iCode */
     {
-      /* we had to allocate for this iCode */
+      if (pi) aopPut (AOP (result),rname,0);
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -7564,6 +7707,8 @@ genPagedPointerSet (operand * right,
     }
 
   /* done */
+  if (pi) pi->generated = 1;
+  freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 
 
@@ -7574,7 +7719,7 @@ genPagedPointerSet (operand * right,
 /*-----------------------------------------------------------------*/
 static void
 genFarPointerSet (operand * right,
-		  operand * result, iCode * ic)
+		  operand * result, iCode * ic, iCode * pi)
 {
   int size, offset;
   sym_link *retype = getSpec (operandType (right));
@@ -7592,14 +7737,9 @@ genFarPointerSet (operand * right,
 	{			/* 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));
-	  if (options.model == MODEL_FLAT24)
-	    {
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE));
-	    }
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (result, NULL, ic, TRUE);
   aopOp (right, ic, FALSE);
 
   /* if bit then unpack */
@@ -7615,11 +7755,16 @@ genFarPointerSet (operand * right,
 	  char *l = aopGet (AOP (right), offset++, FALSE, FALSE);
 	  MOVA (l);
 	  emitcode ("movx", "@dptr,a");
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "dptr");
 	}
     }
-
+  if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
+    aopPut (AOP(result),"dpl",0);
+    aopPut (AOP(result),"dph",1);
+    pi->generated=1;
+  }
+  freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 }
 
@@ -7628,7 +7773,7 @@ genFarPointerSet (operand * right,
 /*-----------------------------------------------------------------*/
 static void
 genGenPointerSet (operand * right,
-		  operand * result, iCode * ic)
+		  operand * result, iCode * ic, iCode * pi)
 {
   int size, offset;
   sym_link *retype = getSpec (operandType (right));
@@ -7650,19 +7795,10 @@ genGenPointerSet (operand * right,
 	{			/* 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));
-	  if (options.model == MODEL_FLAT24)
-	    {
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE));
-	      emitcode ("mov", "b,%s", aopGet (AOP (result), 3, FALSE, FALSE));
-	    }
-	  else
-	    {
-	      emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE));
-	    }
+	  emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE));
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (result, NULL, ic, TRUE);
   aopOp (right, ic, FALSE);
 
   /* if bit then unpack */
@@ -7678,11 +7814,17 @@ genGenPointerSet (operand * right,
 	  char *l = aopGet (AOP (right), offset++, FALSE, FALSE);
 	  MOVA (l);
 	  emitcode ("lcall", "__gptrput");
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "dptr");
 	}
     }
 
+  if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
+    aopPut (AOP(result),"dpl",0);
+    aopPut (AOP(result),"dph",1);
+    pi->generated=1;
+  }
+  freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 }
 
@@ -7690,7 +7832,7 @@ genGenPointerSet (operand * right,
 /* genPointerSet - stores the value into a pointer location        */
 /*-----------------------------------------------------------------*/
 static void
-genPointerSet (iCode * ic)
+genPointerSet (iCode * ic, iCode *pi)
 {
   operand *right, *result;
   sym_link *type, *etype;
@@ -7721,19 +7863,19 @@ genPointerSet (iCode * ic)
 
     case POINTER:
     case IPOINTER:
-      genNearPointerSet (right, result, ic);
+      genNearPointerSet (right, result, ic, pi);
       break;
 
     case PPOINTER:
-      genPagedPointerSet (right, result, ic);
+      genPagedPointerSet (right, result, ic, pi);
       break;
 
     case FPOINTER:
-      genFarPointerSet (right, result, ic);
+      genFarPointerSet (right, result, ic, pi);
       break;
 
     case GPOINTER:
-      genGenPointerSet (right, result, ic);
+      genGenPointerSet (right, result, ic, pi);
       break;
     }
 
@@ -7806,25 +7948,10 @@ genAddrOf (iCode * ic)
       /* fill the result with zero */
       size = AOP_SIZE (IC_RESULT (ic)) - 1;
 
-
-      if (options.stack10bit && size < (FPTRSIZE - 1))
-	{
-	  fprintf (stderr,
-		   "*** warning: pointer to stack var truncated.\n");
-	}
-
       offset = 1;
       while (size--)
 	{
-	  /* Yuck! */
-	  if (options.stack10bit && offset == 2)
-	    {
-	      aopPut (AOP (IC_RESULT (ic)), "#0x40", offset++);
-	    }
-	  else
-	    {
-	      aopPut (AOP (IC_RESULT (ic)), zero, offset++);
-	    }
+	  aopPut (AOP (IC_RESULT (ic)), zero, offset++);
 	}
 
       goto release;
@@ -7901,8 +8028,7 @@ genAssign (iCode * ic)
   aopOp (right, ic, FALSE);
 
   /* special case both in far space */
-  if ((AOP_TYPE (right) == AOP_DPTR ||
-       AOP_TYPE (right) == AOP_DPTR2) &&
+  if (AOP_TYPE (right) == AOP_DPTR &&
       IS_TRUE_SYMOP (result) &&
       isOperandInFarSpace (result))
     {
@@ -8026,6 +8152,8 @@ genCast (iCode * ic)
   operand *right = IC_RIGHT (ic);
   int size, offset;
 
+  D(emitcode(";", "genCast"));
+
   /* if they are equivalent then do nothing */
   if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
     return;
@@ -8101,8 +8229,13 @@ genCast (iCode * ic)
 	    p_type = DCL_TYPE (type);
 	  else
 	    {
-	      /* we have to go by the storage class */
-	      p_type = PTR_TYPE (SPEC_OCLS (etype));
+	      if (SPEC_SCLS(etype)==S_REGISTER) {
+		// let's assume it is a generic pointer
+		p_type=GPOINTER;
+	      } else {
+		/* we have to go by the storage class */
+		p_type = PTR_TYPE (SPEC_OCLS (etype));
+	      }
 	    }
 
 	  /* the first two bytes are known */
@@ -8128,7 +8261,10 @@ genCast (iCode * ic)
 	    case CPOINTER:
 	      l = "#0x02";
 	      break;
-	    case PPOINTER:
+	    case GPOINTER:
+	      l = "0x03";
+	      break;
+	    case PPOINTER: // what the fck is this?
 	      l = "#0x03";
 	      break;
 
@@ -8171,7 +8307,7 @@ genCast (iCode * ic)
   /* 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))
+  if (SPEC_USIGN (rtype) || !IS_SPEC (rtype) || AOP_TYPE(right)==AOP_CRY)
     {
       while (size--)
 	aopPut (AOP (result), zero, offset++);
@@ -8231,7 +8367,30 @@ genDjnz (iCode * ic, iCode * ifx)
 
   aopOp (IC_RESULT (ic), ic, FALSE);
 
-  if (IS_AOP_PREG (IC_RESULT (ic)))
+  if (AOP_NEEDSACC(IC_RESULT(ic)))
+  {
+      /* If the result is accessed indirectly via
+       * the accumulator, we must explicitly write
+       * it back after the decrement.
+       */
+      char *rByte = aopGet(AOP(IC_RESULT(ic)), 0, FALSE, FALSE);
+      
+      if (strcmp(rByte, "a"))
+      {
+           /* Something is hopelessly wrong */
+           fprintf(stderr, "*** warning: internal error at %s:%d\n",
+           	   __FILE__, __LINE__);
+           /* We can just give up; the generated code will be inefficient,
+            * but what the hey.
+            */
+           freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+           return 0;
+      }
+      emitcode ("dec", "%s", rByte);
+      aopPut(AOP(IC_RESULT(ic)), rByte, 0);
+      emitcode ("jnz", "%05d$", lbl->key + 100);
+  }
+  else if (IS_AOP_PREG (IC_RESULT (ic)))
     {
       emitcode ("dec", "%s",
 		aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE));
@@ -8265,11 +8424,11 @@ genReceive (iCode * ic)
     {
 
       int size = getSize (operandType (IC_RESULT (ic)));
-      int offset = fReturnSize - size;
+      int offset = fReturnSizeMCS51 - size;
       while (size--)
 	{
-	  emitcode ("push", "%s", (strcmp (fReturn[fReturnSize - offset - 1], "a") ?
-				fReturn[fReturnSize - offset - 1] : "acc"));
+	  emitcode ("push", "%s", (strcmp (fReturn[fReturnSizeMCS51 - offset - 1], "a") ?
+				fReturn[fReturnSizeMCS51 - offset - 1] : "acc"));
 	  offset++;
 	}
       aopOp (IC_RESULT (ic), ic, FALSE);
@@ -8308,8 +8467,8 @@ gen51Code (iCode * lic)
   if (allocInfo)
     printAllocInfo (currFunc, codeOutFile);
   /* if debug information required */
-/*     if (options.debug && currFunc) { */
-  if (currFunc)
+  /*     if (options.debug && currFunc) { */
+  if (options.debug && currFunc)
     {
       cdbSymbol (currFunc, cdbFile, FALSE, TRUE);
       _G.debugLine = 1;
@@ -8499,12 +8658,12 @@ gen51Code (iCode * lic)
 	  break;
 
 	case GET_VALUE_AT_ADDRESS:
-	  genPointerGet (ic);
+	  genPointerGet (ic, hasInc(IC_LEFT(ic),ic));
 	  break;
 
 	case '=':
 	  if (POINTER_SET (ic))
-	    genPointerSet (ic);
+	    genPointerSet (ic, hasInc (IC_RESULT(ic),ic));
 	  else
 	    genAssign (ic);
 	  break;
@@ -8535,8 +8694,6 @@ gen51Code (iCode * lic)
 
 	default:
 	  ic = ic;
-	  /*      piCode(ic,stdout); */
-
 	}
     }