X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fds390%2Fgen.c;h=1bb15f682fbc725c74e3f71a4d6b56e22284823c;hb=a6d2c6dfdfa34794cd062d6b4cbd23a7869d5b35;hp=e2609d6b21f3e8a5a62dd735657a2172215d8758;hpb=7902425be4d2e2f30ea56958a8f812c1fca24625;p=fw%2Fsdcc

diff --git a/src/ds390/gen.c b/src/ds390/gen.c
index e2609d6b..1bb15f68 100644
--- a/src/ds390/gen.c
+++ b/src/ds390/gen.c
@@ -4,6 +4,7 @@
   Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
          and -  Jean-Louis VERN.jlvern@writeme.com (1999)
   Bug Fixes  -  Wojciech Stryjewski  wstryj1@tiger.lsu.edu (1999 v2.1.9a)
+  DS390 adaptation by Kevin Vigor <kevin@vigor.nu>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
@@ -38,15 +39,19 @@
 #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)
+#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
 
@@ -63,9 +68,15 @@ static char *spname;
 
 #define D(x) x
 
+#define TR_DPTR(s) if (options.model != MODEL_FLAT24) { emitcode(";", " Use_DPTR1 %s ", s); }
+#define TR_AP(s) if (options.model != MODEL_FLAT24) { emitcode(";", " Use_AP %s ", s); }
+
 unsigned fReturnSizeDS390 = 5;	/* shared with ralloc.c */
-static char *fReturn[] =
+static char *fReturn24[] =
 {"dpl", "dph", "dpx", "b", "a"};
+static char *fReturn16[] =
+{"dpl", "dph", "b", "a"};
+static char **fReturn = fReturn24;
 static char *accUse[] =
 {"a", "b"};
 
@@ -83,7 +94,7 @@ static struct
   }
 _G;
 
-static void saverbank (int, iCode *, bool);
+static void saveRBank (int, iCode *, bool);
 
 #define RESULTONSTACK(x) \
                          (IC_RESULT(x) && IC_RESULT(x)->aop && \
@@ -126,7 +137,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);
@@ -168,9 +179,9 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result)
 
   /* first check if r0 & r1 are used by this
      instruction, in which case we are in trouble */
-  if ((r0iu = bitVectBitValue (ic->rUsed, R0_IDX)) &&
-      (r1iu = bitVectBitValue (ic->rUsed, R1_IDX)))
-    {
+  r0iu = bitVectBitValue (ic->rUsed, R0_IDX);
+  r1iu = bitVectBitValue (ic->rUsed, R1_IDX);
+  if (r0iu && r1iu) {
       goto endOfWorld;
     }
 
@@ -286,6 +297,7 @@ genSetDPTR (int n)
     }
   else
     {
+      TR_DPTR("#1");
       emitcode ("mov", "dps, #0x01");
     }
 }
@@ -456,13 +468,16 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 
       if (useDP2)
 	{
-	  emitcode ("mov", "dpx1,#0x40");
+	  if (options.model == MODEL_FLAT24)
+	    emitcode ("mov", "dpx1,#0x40");
+	  TR_DPTR("#2");
 	  emitcode ("mov", "dph1,#0x00");
 	  emitcode ("mov", "dpl1, a");
 	}
       else
 	{
-	  emitcode ("mov", "dpx,#0x40");
+	  if (options.model == MODEL_FLAT24)
+ 	    emitcode ("mov", "dpx,#0x40");
 	  emitcode ("mov", "dph,#0x00");
 	  emitcode ("mov", "dpl, a");
 	}
@@ -496,8 +511,8 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
   if (IS_FUNC (sym->type))
     {
       sym->aop = aop = newAsmop (AOP_IMMD);
-      aop->aopu.aop_immd = Safe_calloc (1, strlen (sym->rname) + 1);
-      strcpy (aop->aopu.aop_immd, sym->rname);
+      aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (sym->rname) + 1);
+      strcpy (aop->aopu.aop_immd.aop_immd1, sym->rname);
       aop->size = FPTRSIZE;
       return aop;
     }
@@ -533,7 +548,7 @@ aopForRemat (symbol * sym)
 {
   iCode *ic = sym->rematiCode;
   asmop *aop = newAsmop (AOP_IMMD);
-
+  int ptr_type ;
   int val = 0;
 
   for (;;)
@@ -542,9 +557,14 @@ aopForRemat (symbol * sym)
 	val += (int) operandLitValue (IC_RIGHT (ic));
       else if (ic->op == '-')
 	val -= (int) operandLitValue (IC_RIGHT (ic));
-      else
-	break;
-
+      else if (IS_CAST_ICODE(ic)) {
+	      sym_link *from_type = operandType(IC_RIGHT(ic));
+	      aop->aopu.aop_immd.from_cast_remat = 1;
+	      ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
+	      ptr_type = DCL_TYPE(from_type);
+	      continue ;
+      } else break;
+      
       ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
     }
 
@@ -556,8 +576,15 @@ aopForRemat (symbol * sym)
   else
     strcpy (buffer, OP_SYMBOL (IC_LEFT (ic))->rname);
 
-  aop->aopu.aop_immd = Safe_calloc (1, strlen (buffer) + 1);
-  strcpy (aop->aopu.aop_immd, buffer);
+  aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1);
+  strcpy (aop->aopu.aop_immd.aop_immd1, buffer);
+  /* set immd2 field if required */
+  if (aop->aopu.aop_immd.from_cast_remat) {
+	  sprintf(buffer,"#0x%02x",ptr_type);
+	  aop->aopu.aop_immd.aop_immd2 = Safe_calloc (1, strlen (buffer) + 1);
+	  strcpy (aop->aopu.aop_immd.aop_immd2, buffer);
+  }
+
   return aop;
 }
 
@@ -973,7 +1000,8 @@ aopGet (asmop * aop,
 	  genSetDPTR (1);
 	  if (!canClobberACC)
 	    {
-	      emitcode ("xch", "a, %s", DP2_RESULT_REG);
+		    TR_AP("#1");
+		    emitcode ("xch", "a, %s", DP2_RESULT_REG);
 	    }
 	}
 
@@ -1007,6 +1035,7 @@ aopGet (asmop * aop,
 	  genSetDPTR (0);
 	  if (!canClobberACC)
 	    {
+       TR_AP("#2");
 	      emitcode ("xch", "a, %s", DP2_RESULT_REG);
 	      return DP2_RESULT_REG;
 	    }
@@ -1014,15 +1043,17 @@ aopGet (asmop * aop,
       return (dname ? "acc" : "a");
 
     case AOP_IMMD:
-      if (bit16)
-	sprintf (s, "#%s", aop->aopu.aop_immd);
+      if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) {
+	      sprintf(s,"%s",aop->aopu.aop_immd.aop_immd2);
+      } else if (bit16)
+	sprintf (s, "#%s", aop->aopu.aop_immd.aop_immd1);
       else if (offset)
 	sprintf (s, "#(%s >> %d)",
-		 aop->aopu.aop_immd,
+		 aop->aopu.aop_immd.aop_immd1,
 		 offset * 8);
       else
 	sprintf (s, "#%s",
-		 aop->aopu.aop_immd);
+		 aop->aopu.aop_immd.aop_immd1);
       rs = Safe_calloc (1, strlen (s) + 1);
       strcpy (rs, s);
       return rs;
@@ -1758,7 +1789,8 @@ saveRegisters (iCode * lic)
 
   /* if the registers have been saved already then
      do nothing */
-  if (ic->regsSaved || (OP_SYMBOL (IC_LEFT (ic))->calleeSave))
+  if (ic->regsSaved || IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type) ||
+      IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic))))
     return;
 
   /* find the registers in use at this time
@@ -1796,14 +1828,8 @@ saveRegisters (iCode * lic)
       }
 
   detype = getSpec (operandType (IC_LEFT (ic)));
-  if (/* why would we do this?: jwk20010511 */ 0 &&
-      detype &&
-      (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)) &&
-      IS_ISR (currFunc->etype) &&
-      !ic->bankSaved)
-    saverbank (SPEC_BANK (detype), ic, TRUE);
-
 }
+
 /*-----------------------------------------------------------------*/
 /* unsaveRegisters - pop the pushed registers                      */
 /*-----------------------------------------------------------------*/
@@ -2038,31 +2064,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 = ds390_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 = (ds390_nRegs - 1); i >= 0; i--)
@@ -2082,30 +2119,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);
-      emitcode ("mov", "%s,_spx", r->name);
-
+        if (!ic)
+        {
+       	  /* Assume r0 is available for use. */
+        	  r = ds390_regWithIdx (R0_IDX);;
+        }
+        else
+        {
+       	  aop = newAsmop (0);
+       	  r = getFreePtr (ic, &aop, FALSE);
+        }
+        emitcode ("mov", "%s,_spx", r->name);    
     }
 
   for (i = 0; i < ds390_nRegs; i++)
@@ -2130,16 +2175,24 @@ 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;
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -2148,32 +2201,41 @@ saverbank (int bank, iCode * ic, bool pushPsw)
 static void
 genCall (iCode * ic)
 {
-  sym_link *detype;
-  int bankSwitched=0;
+  sym_link *dtype;
+  bool restoreBank = FALSE;
+  bool swapBanks = FALSE;
 
   D (emitcode (";", "genCall "););
 
-  /* if we are calling a function that is not using
+  /* if we are calling a not _naked function that is not using
      the same register bank then we need to save the
      destination registers on the stack */
-  detype = getSpec (operandType (IC_LEFT (ic)));
-  if (detype &&
-      (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)) &&
-      IS_ISR (currFunc->etype) &&
-      !ic->bankSaved) {
-    bankSwitched=1;
+  dtype = operandType (IC_LEFT (ic));
+  if (dtype && !IFFUNC_ISNAKED(dtype) &&
+      (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
+      IFFUNC_ISISR (currFunc->type))
+  {
+      if (!ic->bankSaved) 
+      {
+           /* This is unexpected; the bank should have been saved in
+            * genFunction.
+            */
+    	   saveRBank (FUNC_REGBANK (dtype), ic, FALSE);
+    	   restoreBank = TRUE;
+      }
+      swapBanks = TRUE;
   }
   
-  /* if caller saves & we have not saved then */
-  if (!ic->regsSaved) {
-    if (bankSwitched) {
-      // no need to save if we switch banks
-    } else {
+    /* if caller saves & we have not saved then */
+    if (!ic->regsSaved)
       saveRegisters (ic);
-    }
-  }
   
   /* if send set is not empty the assign */
+  /* We've saved all the registers we care about;
+  * therefore, we may clobber any register not used
+  * in the calling convention (i.e. anything not in
+  * fReturn.
+  */
   if (_G.sendSet)
     {
       iCode *sic;
@@ -2183,31 +2245,50 @@ genCall (iCode * ic)
 	{
 	  int size, offset = 0;
 
-	  aopOp (IC_LEFT (sic), sic, FALSE, TRUE);
+	  aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
 	  size = AOP_SIZE (IC_LEFT (sic));
 
 	  _startLazyDPSEvaluation ();
 	  while (size--)
 	    {
-	      char *l = aopGet (AOP (IC_LEFT (sic)), offset,
+	      char *l = aopGet (AOP(IC_LEFT(sic)), offset,
 				FALSE, FALSE, TRUE);
-	      if (strcmp (l, fReturn[offset])) {
-		genSetDPTR(0);
-		_flushLazyDPS();
-		emitcode ("mov", "%s,%s",
-			  fReturn[offset],
-			  l);
-	      }
+	        if ((AOP_TYPE(IC_LEFT(sic)) == AOP_DPTR) && size)
+	        {
+	            emitcode("mov", "%s,%s", regs390[offset].name, l);
+	        }
+	        else if (strcmp (l, fReturn[offset]))
+	        {
+		    emitcode ("mov", "%s,%s",
+			      fReturn[offset],
+			      l);
+	        }
 	      offset++;
 	    }
 	  _endLazyDPSEvaluation ();
+	  if (AOP_TYPE(IC_LEFT(sic)) == AOP_DPTR)
+	  {
+	      size = AOP_SIZE (IC_LEFT (sic));
+	      if (size)
+	      {
+	         size--;
+	      }
+	      while (size)
+	      {
+	      	   size--;
+		   emitcode("mov", "%s,%s",
+		   		    fReturn[size], regs390[size].name);
+	      }
+	  }
 	  freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
 	}
       _G.sendSet = NULL;
-    }
-
-  if (bankSwitched) {
-    saverbank(SPEC_BANK(detype), ic, TRUE);
+    }  
+    
+  if (swapBanks)
+  {
+        emitcode ("mov", "psw,#0x%02x", 
+           ((FUNC_REGBANK(dtype)) << 3) & 0xff);
   }
 
   /* make the call */
@@ -2215,6 +2296,12 @@ genCall (iCode * ic)
 			    OP_SYMBOL (IC_LEFT (ic))->rname :
 			    OP_SYMBOL (IC_LEFT (ic))->name));
 
+  if (swapBanks)
+  {
+       emitcode ("mov", "psw,#0x%02x", 
+          ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
+  }
+
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
@@ -2270,14 +2357,13 @@ genCall (iCode * ic)
 	  emitcode ("dec", "%s", spname);
     }
 
+  /* if we hade saved some registers then unsave them */
+  if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
+    unsaveRegisters (ic);
+
   /* if register bank was saved then pop them */
-  if (bankSwitched) {
-    unsaverbank (SPEC_BANK (detype), ic, TRUE);
-  } else {
-    /* if we have saved some registers then unsave them */
-    if (ic->regsSaved && !(OP_SYMBOL (IC_LEFT (ic))->calleeSave))
-      unsaveRegisters (ic);
-  }
+  if (restoreBank)
+    unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -2286,12 +2372,14 @@ genCall (iCode * ic)
 static void
 genPcall (iCode * ic)
 {
-  sym_link *detype;
+  sym_link *dtype;
   symbol *rlbl = newiTempLabel (NULL);
+  bool restoreBank=FALSE;
 
   D (emitcode (";", "genPcall ");
     );
 
+
   /* if caller saves & we have not saved then */
   if (!ic->regsSaved)
     saveRegisters (ic);
@@ -2299,11 +2387,13 @@ genPcall (iCode * 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 &&
-      IS_ISR (currFunc->etype) &&
-      (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)))
-    saverbank (SPEC_BANK (detype), ic, TRUE);
+  dtype = operandType (IC_LEFT (ic));
+  if (dtype && !IFFUNC_ISNAKED(dtype) &&
+      IFFUNC_ISISR (currFunc->type) &&
+      (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype))) {
+    saveRBank (FUNC_REGBANK (dtype), ic, TRUE);
+    restoreBank=TRUE;
+  }
 
   /* push the return address on to the stack */
   emitcode ("mov", "a,#%05d$", (rlbl->key + 100));
@@ -2393,14 +2483,12 @@ genPcall (iCode * ic)
     }
 
   /* if register bank was saved then unsave them */
-  if (detype &&
-      (SPEC_BANK (currFunc->etype) !=
-       SPEC_BANK (detype)))
-    unsaverbank (SPEC_BANK (detype), ic, TRUE);
-
+  if (restoreBank)
+    unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
+  
   /* if we hade saved some registers then
      unsave them */
-  if (ic->regsSaved)
+  if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
     unsaveRegisters (ic);
 
 }
@@ -2458,10 +2546,10 @@ static void
 genFunction (iCode * ic)
 {
   symbol *sym;
-  sym_link *fetype;
+  sym_link *ftype;
+  bool   switchedPSW = FALSE;
 
-  D (emitcode (";", "genFunction ");
-    );
+  D (emitcode (";", "genFunction "););
 
   _G.nRegsSaved = 0;
   /* create the function header */
@@ -2470,19 +2558,25 @@ genFunction (iCode * ic)
   emitcode (";", "-----------------------------------------");
 
   emitcode ("", "%s:", sym->rname);
-  fetype = getSpec (operandType (IC_LEFT (ic)));
+  ftype = operandType (IC_LEFT (ic));
+
+  if (IFFUNC_ISNAKED(ftype))
+  {
+      emitcode(";", "naked function: no prologue.");
+      return;
+  }
 
   /* if critical function then turn interrupts off */
-  if (SPEC_CRTCL (fetype))
+  if (IFFUNC_ISCRITICAL (ftype))
     emitcode ("clr", "ea");
 
   /* here we need to generate the equates for the
      register bank if required */
-  if (SPEC_BANK (fetype) != rbank)
+  if (FUNC_REGBANK (ftype) != rbank)
     {
       int i;
 
-      rbank = SPEC_BANK (fetype);
+      rbank = FUNC_REGBANK (ftype);
       for (i = 0; i < ds390_nRegs; i++)
 	{
 	  if (strcmp (regs390[i].base, "0") == 0)
@@ -2499,7 +2593,7 @@ genFunction (iCode * ic)
 
   /* if this is an interrupt service routine then
      save acc, b, dpl, dph  */
-  if (IS_ISR (sym->etype))
+  if (IFFUNC_ISISR (sym->type))
     {
 
       if (!inExcludeList ("acc"))
@@ -2528,13 +2622,13 @@ genFunction (iCode * ic)
       /* if this isr has no bank i.e. is going to
          run with bank 0 , then we need to save more
          registers :-) */
-      if (!SPEC_BANK (sym->etype))
+      if (!FUNC_REGBANK (sym->type))
 	{
 
 	  /* if this function does not call any other
 	     function then we can be economical and
 	     save only those registers that are used */
-	  if (!sym->hasFcall)
+	  if (!IFFUNC_HASFCALL(sym->type))
 	    {
 	      int i;
 
@@ -2554,17 +2648,107 @@ 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 (IFFUNC_HASFCALL(sym->type))
+	    {
+
+#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 *dtype;
+	                
+	                dtype = operandType (IC_LEFT(i));
+	                if (dtype 
+	                 && FUNC_REGBANK(dtype) != FUNC_REGBANK(sym->type))
+	                {
+	                     /* Mark this bank for saving. */
+	                     if (FUNC_REGBANK(dtype) >= MAX_REGISTER_BANKS)
+	                     {
+	                         werror(E_NO_SUCH_BANK, FUNC_REGBANK(dtype));
+	                     }
+	                     else
+	                     {
+	                         banksToSave |= (1 << FUNC_REGBANK(dtype));
+	                     }
+	                     
+	                     /* 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", 
+		    	      (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
+		    switchedPSW = TRUE;
+		}
+		
+	        for (ix = 0; ix < MAX_REGISTER_BANKS; ix++)
+	        {
+	             if (banksToSave & (1 << ix))
+	             {
+	                 saveRBank(ix, NULL, FALSE);
+	             }
+	        }
+	    }
+	    // jwk: this needs a closer look
+	    SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
+	}
     }
   else
     {
       /* if callee-save to be used for this function
          then save the registers being used in this function */
-      if (sym->calleeSave)
+      if (IFFUNC_CALLEESAVES(sym->type))
 	{
 	  int i;
 
@@ -2586,13 +2770,14 @@ genFunction (iCode * ic)
     }
 
   /* set the register bank to the desired value */
-  if (SPEC_BANK (sym->etype) || IS_ISR (sym->etype))
+  if ((FUNC_REGBANK (sym->type) || FUNC_ISISR (sym->type))
+   && !switchedPSW)
     {
       emitcode ("push", "psw");
-      emitcode ("mov", "psw,#0x%02x", (SPEC_BANK (sym->etype) << 3) & 0x00ff);
+      emitcode ("mov", "psw,#0x%02x", (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
     }
 
-  if (IS_RENT (sym->etype) || options.stackAuto)
+  if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
     {
 
       if (options.useXstack)
@@ -2649,10 +2834,15 @@ genEndFunction (iCode * ic)
 {
   symbol *sym = OP_SYMBOL (IC_LEFT (ic));
 
-  D (emitcode (";", "genEndFunction ");
-    );
+  D (emitcode (";", "genEndFunction "););
 
-  if (IS_RENT (sym->etype) || options.stackAuto)
+  if (IFFUNC_ISNAKED(sym->type))
+  {
+      emitcode(";", "naked function: no epilogue.");
+      return;
+  }
+
+  if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
     {
       emitcode ("mov", "%s,_bp", spname);
     }
@@ -2668,7 +2858,7 @@ genEndFunction (iCode * ic)
     }
 
 
-  if ((IS_RENT (sym->etype) || options.stackAuto))
+  if ((IFFUNC_ISREENT (sym->type) || options.stackAuto))
     {
       if (options.useXstack)
 	{
@@ -2684,23 +2874,31 @@ genEndFunction (iCode * ic)
     }
 
   /* restore the register bank  */
-  if (SPEC_BANK (sym->etype) || IS_ISR (sym->etype))
-    emitcode ("pop", "psw");
+  if (FUNC_REGBANK (sym->type) || IFFUNC_ISISR (sym->type))
+  {
+    if (!FUNC_REGBANK (sym->type) || !IFFUNC_ISISR (sym->type)
+     || !options.useXstack)
+    {
+        /* Special case of ISR using non-zero bank with useXstack
+         * is handled below.
+         */
+        emitcode ("pop", "psw");
+    }
+  }
 
-  if (IS_ISR (sym->etype))
+  if (IFFUNC_ISISR (sym->type))
     {
 
       /* now we need to restore the registers */
       /* if this isr has no bank i.e. is going to
          run with bank 0 , then we need to save more
          registers :-) */
-      if (!SPEC_BANK (sym->etype))
+      if (!FUNC_REGBANK (sym->type))
 	{
-
 	  /* if this function does not call any other
 	     function then we can be economical and
 	     save only those registers that are used */
-	  if (!sym->hasFcall)
+	  if (!IFFUNC_HASFCALL(sym->type))
 	    {
 	      int i;
 
@@ -2720,9 +2918,36 @@ 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);
+	    }
+	}
+	else
+	{
+	    /* This ISR uses a non-zero bank.
+	     *
+	     * Restore any register banks saved by genFunction
+	     * in reverse order.
+	     */
+	  // jwk: this needs a closer look
+	    unsigned savedBanks = SPEC_ISR_SAVED_BANKS(currFunc->etype);
+	    int ix;
+	  
+	    for (ix = MAX_REGISTER_BANKS - 1; ix >= 0; ix--)
+	    {
+	        if (savedBanks & (1 << ix))
+	        {
+	            unsaveRBank(ix, NULL, FALSE);
+	        }
+	    }
+	    
+	    if (options.useXstack)
+	    {
+	    	/* Restore bank AFTER calling unsaveRBank,
+	     	 * since it can trash r0.
+	     	 */
+	    	emitcode ("pop", "psw");
 	    }
 	}
 
@@ -2747,13 +2972,11 @@ genEndFunction (iCode * ic)
       if (!inExcludeList ("acc"))
 	emitcode ("pop", "acc");
 
-      if (SPEC_CRTCL (sym->etype))
+      if (IFFUNC_ISCRITICAL (sym->type))
 	emitcode ("setb", "ea");
 
       /* if debug then send end of function */
-/*  if (options.debug && currFunc) { */
-      if (currFunc)
-	{
+      if (options.debug && currFunc) {
 	  _G.debugLine = 1;
 	  emitcode ("", "C$%s$%d$%d$%d ==.",
 		    FileBaseName (ic->filename), currFunc->lastLine,
@@ -2769,10 +2992,10 @@ genEndFunction (iCode * ic)
     }
   else
     {
-      if (SPEC_CRTCL (sym->etype))
+      if (IFFUNC_ISCRITICAL (sym->type))
 	emitcode ("setb", "ea");
 
-      if (sym->calleeSave)
+      if (IFFUNC_CALLEESAVES(sym->type))
 	{
 	  int i;
 
@@ -2791,7 +3014,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 ==.",
@@ -2843,8 +3066,11 @@ genRet (iCode * ic)
 	}
       else
 	{
+	  /* Since A is the last element of fReturn,
+	   * is is OK to clobber it in the aopGet.
+	   */
 	  l = aopGet (AOP (IC_LEFT (ic)), offset,
-		      FALSE, FALSE, FALSE);
+		      FALSE, FALSE, TRUE);
 	  if (strcmp (fReturn[offset], l))
 	    emitcode ("mov", "%s,%s", fReturn[offset++], l);
 	}
@@ -3147,6 +3373,8 @@ adjustArithmeticResult (iCode * ic)
     }
 }
 
+#if 0 // AOP_OP_3 is deprecated; nobody likes Ack errors.
+      // Please don't bring it back without a really good reason.
 // Macro to aopOp all three operands of an ic. Will fatal if this cannot be done
 // (because all three operands are in far space).
 #define AOP_OP_3(ic) \
@@ -3161,6 +3389,7 @@ adjustArithmeticResult (iCode * ic)
         fprintf(stderr,                                  \
                "Ack: three operands in far space! (%s:%d %s:%d)\n", __FILE__, __LINE__, ic->filename, ic->lineno);   \
     }
+#endif
 
 // Macro to aopOp all three operands of an ic. If this cannot be done, 
 // the IC_LEFT and IC_RIGHT operands will be aopOp'd, and the rc parameter
@@ -3316,7 +3545,7 @@ genPlus (iCode * ic)
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC)
+      if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC && !AOP_NEEDSACC(IC_RIGHT(ic)))
 	{
 	  MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE));
 	  if (offset == 0)
@@ -3328,13 +3557,35 @@ genPlus (iCode * ic)
 	}
       else
 	{
+	  if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC && (offset == 0))
+	  {
+	      /* right is going to use ACC or we would have taken the
+	       * above branch.
+	       */
+	      assert(AOP_NEEDSACC(IC_RIGHT(ic)));
+       TR_AP("#3");
+	      D(emitcode(";", "+ AOP_ACC special case."););
+	      emitcode("xch", "a, %s", DP2_RESULT_REG);
+	  }
 	  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, TRUE));
 	  if (offset == 0)
-	    emitcode ("add", "a,%s",
-		  aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, FALSE));
+	  {
+	    if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC)
+	    {
+         TR_AP("#4");
+	        emitcode("add", "a, %s", DP2_RESULT_REG); 
+	    }
+	    else
+	    {
+	    	emitcode ("add", "a,%s",
+		  	aopGet (AOP(IC_LEFT(ic)), offset, FALSE, FALSE, FALSE));
+	    }
+          }
 	  else
+	  {
 	    emitcode ("addc", "a,%s",
 		  aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, FALSE));
+	  }
 	}
       if (!pushResult)
 	{
@@ -3628,12 +3879,17 @@ genMinus (iCode * ic)
       else
 	{
 	  /* first add without previous c */
-	  if (!offset)
-	    emitcode ("add", "a,#0x%02x",
-		      (unsigned int) (lit & 0x0FFL));
-	  else
+	  if (!offset) {
+	    if (!size && lit==-1) {
+	      emitcode ("dec", "a");
+	    } else {
+	      emitcode ("add", "a,#0x%02x",
+			(unsigned int) (lit & 0x0FFL));
+	    }
+	  } else {
 	    emitcode ("addc", "a,#0x%02x",
 		      (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+	  }
 	}
 
       if (pushResult)
@@ -3681,10 +3937,12 @@ release:
 static void
 genMultbits (operand * left,
 	     operand * right,
-	     operand * result)
+	     operand * result,
+	     iCode   * ic)
 {
   emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
   emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
+  aopOp(result, ic, TRUE, FALSE);
   outBitC (result);
 }
 
@@ -3695,19 +3953,12 @@ genMultbits (operand * left,
 static void
 genMultOneByte (operand * left,
 		operand * right,
-		operand * result)
+		operand * result,
+		iCode   * ic)
 {
   sym_link *opetype = operandType (result);
   symbol *lbl;
-  int size=AOP_SIZE(result);
 
-  emitcode (";",__FUNCTION__);
-  if (size<1 || size>2) {
-    // this should never happen
-      fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n", 
-	       AOP_SIZE(result), __FUNCTION__, lineno);
-      exit (1);
-  }
 
   /* (if two literals: the value is computed before) */
   /* if one literal, literal on the right */
@@ -3728,8 +3979,22 @@ genMultOneByte (operand * left,
     emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, TRUE));
     MOVA (aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
     emitcode ("mul", "ab");
+   
+    _G.accInUse++;
+    aopOp(result, ic, TRUE, FALSE);
+      
+      if (AOP_SIZE(result)<1 || AOP_SIZE(result)>2) 
+      {
+	  // this should never happen
+	  fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n", 
+		   AOP_SIZE(result), __FILE__, lineno);
+	  exit (1);
+      }      
+      
     aopPut (AOP (result), "a", 0);
-    if (size==2) {
+    _G.accInUse--;
+    if (AOP_SIZE(result)==2) 
+    {
       aopPut (AOP (result), "b", 1);
     }
     return;
@@ -3739,7 +4004,6 @@ genMultOneByte (operand * left,
 
   emitcode (";", "signed");
   emitcode ("clr", "F0"); // reset sign flag
-  emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, TRUE));
   MOVA (aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
 
   lbl=newiTempLabel(NULL);
@@ -3750,33 +4014,46 @@ genMultOneByte (operand * left,
   emitcode ("inc", "a");
 
   emitcode ("", "%05d$:", lbl->key+100);
-  emitcode ("xch", "a,b");
 
   /* if literal */
   if (AOP_TYPE(right)==AOP_LIT) {
+    signed char val=floatFromVal (AOP (right)->aopu.aop_lit);
     /* AND literal negative */
-    if ((int) floatFromVal (AOP (right)->aopu.aop_lit) < 0) {
-      // two's complement for literal<0
-      emitcode ("xrl", "PSW,#0x20"); // xrl sign flag
-      emitcode ("cpl", "a");
-      emitcode ("inc", "a");
+    if ((int) 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, TRUE));
     emitcode ("jnb", "acc.7,%05d$", lbl->key+100);
     // right side is negative, 8-bit two's complement
-    emitcode ("xrl", "PSW,#0x20"); // xrl sign flag
+    emitcode ("cpl", "F0"); // complement sign flag
     emitcode ("cpl", "a");
     emitcode ("inc", "a");
     emitcode ("", "%05d$:", lbl->key+100);
   }
   emitcode ("mul", "ab");
     
+  _G.accInUse++;
+  aopOp(result, ic, TRUE, FALSE);
+    
+  if (AOP_SIZE(result)<1 || AOP_SIZE(result)>2) 
+  {
+    // this should never happen
+      fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n", 
+	       AOP_SIZE(result), __FILE__, lineno);
+      exit (1);
+  }    
+    
   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) {
+  if (AOP_SIZE(result)==1) {
     emitcode ("inc", "a");
   } else {
     emitcode ("add", "a,#1");
@@ -3788,11 +4065,159 @@ genMultOneByte (operand * left,
 
   emitcode ("", "%05d$:", lbl->key+100);
   aopPut (AOP (result), "a", 0);
-  if (size==2) {
+  _G.accInUse--;
+  if (AOP_SIZE(result)==2) {
     aopPut (AOP (result), "b", 1);
   }
 }
 
+/*-----------------------------------------------------------------*/
+/* genMultTwoByte - use the DS390 MAC unit to do 16*16 multiply    */
+/*-----------------------------------------------------------------*/
+static void genMultTwoByte (operand *left, operand *right, 
+			    operand *result, iCode *ic)
+{
+	sym_link *retype = getSpec(operandType(right));
+	sym_link *letype = getSpec(operandType(left));
+	int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
+	symbol *lbl;
+
+	if (AOP_TYPE (left) == AOP_LIT) {
+		operand *t = right;
+		right = left;
+		left = t;
+	}
+	/* load up MB with right */
+	if (!umult) {
+		emitcode("clr","F0");
+		if (AOP_TYPE(right) == AOP_LIT) {
+			int val=floatFromVal (AOP (right)->aopu.aop_lit);
+			if (val < 0) {
+				emitcode("setb","F0");
+				val = -val;
+			}
+			emitcode ("mov","mb,#0x%02x",val & 0xff);
+			emitcode ("mov","mb,#0x%02x",(val >> 8) & 0xff);		    
+		} else {
+			lbl = newiTempLabel(NULL);
+			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
+			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+			emitcode ("jnb","acc.7,%05d$",lbl->key+100);		
+			emitcode ("xch", "a,b");
+			emitcode ("cpl","a");
+			emitcode ("add", "a,#1");
+			emitcode ("xch", "a,b");
+			emitcode ("cpl", "a"); // msb
+			emitcode ("addc", "a,#0");
+			emitcode ("setb","F0");
+			emitcode ("","%05d$:",lbl->key+100);
+			emitcode ("mov","mb,b");
+			emitcode ("mov","mb,a");
+		}
+	} else {
+		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+	}
+	/* load up MA with left */
+	if (!umult) {
+		lbl = newiTempLabel(NULL);
+		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+		emitcode ("xch", "a,b");
+		emitcode ("cpl","a");
+		emitcode ("add", "a,#1");
+		emitcode ("xch", "a,b");
+		emitcode ("cpl", "a"); // msb
+		emitcode ("addc","a,#0");
+		emitcode ("jbc","F0,%05d$",lbl->key+100);
+		emitcode ("setb","F0");
+		emitcode ("","%05d$:",lbl->key+100);
+		emitcode ("mov","ma,b");
+		emitcode ("mov","ma,a");
+	} else {
+		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+	}
+	/* wait for multiplication to finish */
+	lbl = newiTempLabel(NULL);
+	emitcode("","%05d$:", lbl->key+100);
+	emitcode("mov","a,mcnt1");
+	emitcode("anl","a,#0x80");
+	emitcode("jnz","%05d$",lbl->key+100);
+	
+	freeAsmop (left, NULL, ic, TRUE);
+	freeAsmop (right, NULL, ic,TRUE);
+	aopOp(result, ic, TRUE, FALSE);
+
+	/* if unsigned then simple */	
+	if (umult) {
+		emitcode ("mov","a,ma");
+		if (AOP_SIZE(result) >= 4) aopPut(AOP(result),"a",3);
+		emitcode ("mov","a,ma");
+		if (AOP_SIZE(result) >= 3) aopPut(AOP(result),"a",2);
+		aopPut(AOP(result),"ma",1);
+		aopPut(AOP(result),"ma",0);
+	} else {
+		emitcode("push","ma");
+		emitcode("push","ma");
+		emitcode("push","ma");
+		MOVA("ma");
+		/* negate result if needed */
+		lbl = newiTempLabel(NULL); 	
+		emitcode("jnb","F0,%05d$",lbl->key+100);
+		emitcode("cpl","a");
+		emitcode("add","a,#1");
+		emitcode("","%05d$:", lbl->key+100);
+	        if (AOP_TYPE(result) == AOP_ACC)
+	        {
+		    D(emitcode(";", "ACC special case."););
+		    /* We know result is the only live aop, and 
+		     * it's obviously not a DPTR2, so AP is available.
+		     */
+		    emitcode("mov", "%s,acc", DP2_RESULT_REG);
+	        }
+	        else
+	        {
+		    aopPut(AOP(result),"a",0);
+		}
+	    
+		emitcode("pop","acc");
+		lbl = newiTempLabel(NULL); 	
+		emitcode("jnb","F0,%05d$",lbl->key+100);
+		emitcode("cpl","a");
+		emitcode("addc","a,#0");
+		emitcode("","%05d$:", lbl->key+100);
+		aopPut(AOP(result),"a",1);
+		emitcode("pop","acc");
+		if (AOP_SIZE(result) >= 3) {
+			lbl = newiTempLabel(NULL); 	
+			emitcode("jnb","F0,%05d$",lbl->key+100);
+			emitcode("cpl","a");
+			emitcode("addc","a,#0");			
+			emitcode("","%05d$:", lbl->key+100);
+			aopPut(AOP(result),"a",2);
+		}
+		emitcode("pop","acc");
+		if (AOP_SIZE(result) >= 4) {
+			lbl = newiTempLabel(NULL); 	
+			emitcode("jnb","F0,%05d$",lbl->key+100);
+			emitcode("cpl","a");
+			emitcode("addc","a,#0");			
+			emitcode("","%05d$:", lbl->key+100);
+			aopPut(AOP(result),"a",3);
+		}
+	        if (AOP_TYPE(result) == AOP_ACC)
+	        {
+		    /* We stashed the result away above. */
+		    emitcode("mov", "acc,%s", DP2_RESULT_REG);
+	        }	    
+		
+	}
+	freeAsmop (result, NULL, ic, TRUE);
+	return ;
+}
+
 /*-----------------------------------------------------------------*/
 /* genMult - generates code for multiplication                     */
 /*-----------------------------------------------------------------*/
@@ -3806,14 +4231,14 @@ genMult (iCode * ic)
   D (emitcode (";", "genMult "););
 
   /* assign the amsops */
-  AOP_OP_3 (ic);
+  AOP_OP_2 (ic);
 
   /* special cases first */
   /* both are bits */
   if (AOP_TYPE (left) == AOP_CRY &&
       AOP_TYPE (right) == AOP_CRY)
     {
-      genMultbits (left, right, result);
+      genMultbits (left, right, result, ic);
       goto release;
     }
 
@@ -3821,12 +4246,17 @@ genMult (iCode * ic)
   if (AOP_SIZE (left) == 1 &&
       AOP_SIZE (right) == 1)
     {
-      genMultOneByte (left, right, result);
+      genMultOneByte (left, right, result, ic);
       goto release;
     }
 
+  if (AOP_SIZE (left) == 2 && AOP_SIZE(right) == 2) {
+	  /* use the ds390 ARITHMETIC accel UNIT */
+	  genMultTwoByte (left, right, result, ic);
+	  return ;
+  }
   /* should have been converted to function call */
-  assert (1);
+  assert (0);
 
 release:
   freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
@@ -3840,7 +4270,8 @@ release:
 static void
 genDivbits (operand * left,
 	    operand * right,
-	    operand * result)
+	    operand * result,
+	    iCode   * ic)
 {
 
   char *l;
@@ -3849,6 +4280,8 @@ genDivbits (operand * left,
   LOAD_AB_FOR_DIV (left, right, l);
   emitcode ("div", "ab");
   emitcode ("rrc", "a");
+  aopOp(result, ic, TRUE, FALSE);
+    
   aopPut (AOP (result), "c", 0);
 }
 
@@ -3858,24 +4291,33 @@ genDivbits (operand * left,
 static void
 genDivOneByte (operand * left,
 	       operand * right,
-	       operand * result)
+	       operand * result,
+	       iCode   * ic)
 {
   sym_link *opetype = operandType (result);
   char *l;
   symbol *lbl;
   int size, offset;
 
-  size = AOP_SIZE (result) - 1;
   offset = 1;
   /* signed or unsigned */
   if (SPEC_USIGN (opetype))
     {
-      /* unsigned is easy */
-      LOAD_AB_FOR_DIV (left, right, l);
-      emitcode ("div", "ab");
-      aopPut (AOP (result), "a", 0);
-      while (size--)
-	aopPut (AOP (result), zero, offset++);
+	/* unsigned is easy */
+	LOAD_AB_FOR_DIV (left, right, l);
+	emitcode ("div", "ab");
+
+	_G.accInUse++;
+	aopOp(result, ic, TRUE, FALSE);
+	aopPut (AOP (result), "a", 0);
+	_G.accInUse--;
+
+	size = AOP_SIZE (result) - 1;
+	
+	while (size--)
+	{
+	    aopPut (AOP (result), zero, offset++);
+	}
       return;
     }
 
@@ -3926,15 +4368,129 @@ genDivOneByte (operand * left,
   emitcode ("", "%05d$:", (lbl->key + 100));
 
   /* now we are done */
-  aopPut (AOP (result), "b", 0);
-  if (size > 0)
+    _G.accInUse++;
+    aopOp(result, ic, TRUE, FALSE);
+    
+    aopPut (AOP (result), "b", 0);
+    
+    size = AOP_SIZE (result) - 1;
+    
+    if (size > 0)
     {
       emitcode ("mov", "c,b.7");
       emitcode ("subb", "a,acc");
     }
-  while (size--)
-    aopPut (AOP (result), "a", offset++);
-
+    while (size--)
+    {
+	aopPut (AOP (result), "a", offset++);
+    }
+    _G.accInUse--;
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genDivTwoByte - use the DS390 MAC unit to do 16/16 divide       */
+/*-----------------------------------------------------------------*/
+static void genDivTwoByte (operand *left, operand *right, 
+			    operand *result, iCode *ic)
+{
+	sym_link *retype = getSpec(operandType(right));
+	sym_link *letype = getSpec(operandType(left));
+	int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
+	symbol *lbl;
+
+	/* load up MA with left */
+	if (!umult) {
+		emitcode("clr","F0");
+		lbl = newiTempLabel(NULL);
+		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+		emitcode ("xch", "a,b");
+		emitcode ("cpl","a");
+		emitcode ("add", "a,#1");
+		emitcode ("xch", "a,b");
+		emitcode ("cpl", "a"); // msb
+		emitcode ("addc","a,#0");
+		emitcode ("setb","F0");
+		emitcode ("","%05d$:",lbl->key+100);
+		emitcode ("mov","ma,b");
+		emitcode ("mov","ma,a");
+	} else {
+		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+	}
+
+	/* load up MB with right */
+	if (!umult) {
+		if (AOP_TYPE(right) == AOP_LIT) {
+			int val=floatFromVal (AOP (right)->aopu.aop_lit);
+			if (val < 0) {
+				lbl = newiTempLabel(NULL);
+				emitcode ("jbc","F0,%05d$",lbl->key+100);
+				emitcode("setb","F0");
+				emitcode ("","%05d$:",lbl->key+100);
+				val = -val;
+			} 
+			emitcode ("mov","mb,#0x%02x",val & 0xff);		    
+			emitcode ("mov","mb,#0x%02x",(val >> 8) & 0xff);
+		} else {
+			lbl = newiTempLabel(NULL);
+			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
+			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+			emitcode ("jnb","acc.7,%05d$",lbl->key+100);		
+			emitcode ("xch", "a,b");
+			emitcode ("cpl","a");
+			emitcode ("add", "a,#1");
+			emitcode ("xch", "a,b");
+			emitcode ("cpl", "a"); // msb
+			emitcode ("addc", "a,#0");
+			emitcode ("jbc","F0,%05d$",lbl->key+100);
+			emitcode ("setb","F0");
+			emitcode ("","%05d$:",lbl->key+100);
+			emitcode ("mov","mb,b");
+			emitcode ("mov","mb,a");
+		}
+	} else {
+		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+	}
+
+	/* wait for multiplication to finish */
+	lbl = newiTempLabel(NULL);
+	emitcode("","%05d$:", lbl->key+100);
+	emitcode("mov","a,mcnt1");
+	emitcode("anl","a,#0x80");
+	emitcode("jnz","%05d$",lbl->key+100);
+	
+	freeAsmop (left, NULL, ic, TRUE);
+	freeAsmop (right, NULL, ic,TRUE);
+	aopOp(result, ic, TRUE, FALSE);
+
+	/* if unsigned then simple */	
+	if (umult) {
+		aopPut(AOP(result),"ma",1);
+		aopPut(AOP(result),"ma",0);
+	} else {
+		emitcode("push","ma");
+		MOVA("ma");
+		/* negate result if needed */
+		lbl = newiTempLabel(NULL); 	
+		emitcode("jnb","F0,%05d$",lbl->key+100);
+		emitcode("cpl","a");
+		emitcode("add","a,#1");
+		emitcode("","%05d$:", lbl->key+100);
+		aopPut(AOP(result),"a",0);
+		emitcode("pop","acc");
+		lbl = newiTempLabel(NULL); 	
+		emitcode("jnb","F0,%05d$",lbl->key+100);
+		emitcode("cpl","a");
+		emitcode("addc","a,#0");
+		emitcode("","%05d$:", lbl->key+100);
+		aopPut(AOP(result),"a",1);
+	}
+	freeAsmop (result, NULL, ic, TRUE);
+	return ;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3947,18 +4503,17 @@ genDiv (iCode * ic)
   operand *right = IC_RIGHT (ic);
   operand *result = IC_RESULT (ic);
 
-  D (emitcode (";", "genDiv ");
-    );
+  D (emitcode (";", "genDiv "););
 
   /* assign the amsops */
-  AOP_OP_3 (ic);
+  AOP_OP_2 (ic);
 
   /* special cases first */
   /* both are bits */
   if (AOP_TYPE (left) == AOP_CRY &&
       AOP_TYPE (right) == AOP_CRY)
     {
-      genDivbits (left, right, result);
+      genDivbits (left, right, result, ic);
       goto release;
     }
 
@@ -3966,12 +4521,17 @@ genDiv (iCode * ic)
   if (AOP_SIZE (left) == 1 &&
       AOP_SIZE (right) == 1)
     {
-      genDivOneByte (left, right, result);
+      genDivOneByte (left, right, result, ic);
       goto release;
     }
 
+  if (AOP_SIZE (left) == 2 && AOP_SIZE(right) == 2) {
+	  /* use the ds390 ARITHMETIC accel UNIT */
+	  genDivTwoByte (left, right, result, ic);
+	  return ;
+  }
   /* should have been converted to function call */
-  assert (1);
+  assert (0);
 release:
   freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
@@ -3984,7 +4544,8 @@ release:
 static void
 genModbits (operand * left,
 	    operand * right,
-	    operand * result)
+	    operand * result,
+	    iCode   * ic)
 {
 
   char *l;
@@ -3994,6 +4555,7 @@ genModbits (operand * left,
   emitcode ("div", "ab");
   emitcode ("mov", "a,b");
   emitcode ("rrc", "a");
+  aopOp(result, ic, TRUE, FALSE);
   aopPut (AOP (result), "c", 0);
 }
 
@@ -4003,7 +4565,8 @@ genModbits (operand * left,
 static void
 genModOneByte (operand * left,
 	       operand * right,
-	       operand * result)
+	       operand * result,
+	       iCode   * ic)
 {
   sym_link *opetype = operandType (result);
   char *l;
@@ -4015,6 +4578,7 @@ genModOneByte (operand * left,
       /* unsigned is easy */
       LOAD_AB_FOR_DIV (left, right, l);
       emitcode ("div", "ab");
+      aopOp(result, ic, TRUE, FALSE);	
       aopPut (AOP (result), "b", 0);
       return;
     }
@@ -4067,10 +4631,88 @@ genModOneByte (operand * left,
   emitcode ("", "%05d$:", (lbl->key + 100));
 
   /* now we are done */
+  aopOp(result, ic, TRUE, FALSE);    
   aopPut (AOP (result), "b", 0);
 
 }
 
+/*-----------------------------------------------------------------*/
+/* genModTwoByte - use the DS390 MAC unit to do 16%16 modulus      */
+/*-----------------------------------------------------------------*/
+static void genModTwoByte (operand *left, operand *right, 
+			    operand *result, iCode *ic)
+{
+	sym_link *retype = getSpec(operandType(right));
+	sym_link *letype = getSpec(operandType(left));
+	int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
+	symbol *lbl;
+
+	/* load up MA with left */
+	if (!umult) {
+		lbl = newiTempLabel(NULL);
+		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("jnb","acc.7,%05d$",lbl->key+100);
+		emitcode ("xch", "a,b");
+		emitcode ("cpl","a");
+		emitcode ("add", "a,#1");
+		emitcode ("xch", "a,b");
+		emitcode ("cpl", "a"); // msb
+		emitcode ("addc","a,#0");
+		emitcode ("","%05d$:",lbl->key+100);
+		emitcode ("mov","ma,b");
+		emitcode ("mov","ma,a");
+	} else {
+		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+	}
+
+	/* load up MB with right */
+	if (!umult) {
+		if (AOP_TYPE(right) == AOP_LIT) {
+			int val=floatFromVal (AOP (right)->aopu.aop_lit);
+			if (val < 0) {
+				val = -val;
+			} 
+			emitcode ("mov","mb,#0x%02x",val & 0xff);
+			emitcode ("mov","mb,#0x%02x",(val >> 8) & 0xff);		    
+		} else {
+			lbl = newiTempLabel(NULL);
+			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
+			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+			emitcode ("jnb","acc.7,%05d$",lbl->key+100);		
+			emitcode ("xch", "a,b");
+			emitcode ("cpl","a");
+			emitcode ("add", "a,#1");
+			emitcode ("xch", "a,b");
+			emitcode ("cpl", "a"); // msb
+			emitcode ("addc", "a,#0");
+			emitcode ("","%05d$:",lbl->key+100);
+			emitcode ("mov","mb,b");
+			emitcode ("mov","mb,a");
+		}
+	} else {
+		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+	}
+
+	/* wait for multiplication to finish */
+	lbl = newiTempLabel(NULL);
+	emitcode("","%05d$:", lbl->key+100);
+	emitcode("mov","a,mcnt1");
+	emitcode("anl","a,#0x80");
+	emitcode("jnz","%05d$",lbl->key+100);
+	
+	freeAsmop (left, NULL, ic, TRUE);
+	freeAsmop (right, NULL, ic,TRUE);
+	aopOp(result, ic, TRUE, FALSE);
+
+	aopPut(AOP(result),"mb",1);
+	aopPut(AOP(result),"mb",0);
+	freeAsmop (result, NULL, ic, TRUE);
+	return ;
+}
+
 /*-----------------------------------------------------------------*/
 /* genMod - generates code for division                            */
 /*-----------------------------------------------------------------*/
@@ -4081,18 +4723,17 @@ genMod (iCode * ic)
   operand *right = IC_RIGHT (ic);
   operand *result = IC_RESULT (ic);
 
-  D (emitcode (";", "genMod ");
-    );
+  D (emitcode (";", "genMod "); );
 
   /* assign the amsops */
-  AOP_OP_3 (ic);
+  AOP_OP_2 (ic);
 
   /* special cases first */
   /* both are bits */
   if (AOP_TYPE (left) == AOP_CRY &&
       AOP_TYPE (right) == AOP_CRY)
     {
-      genModbits (left, right, result);
+      genModbits (left, right, result, ic);
       goto release;
     }
 
@@ -4100,12 +4741,18 @@ genMod (iCode * ic)
   if (AOP_SIZE (left) == 1 &&
       AOP_SIZE (right) == 1)
     {
-      genModOneByte (left, right, result);
+      genModOneByte (left, right, result, ic);
       goto release;
     }
 
+  if (AOP_SIZE (left) == 2 && AOP_SIZE(right) == 2) {
+	  /* use the ds390 ARITHMETIC accel UNIT */
+	  genModTwoByte (left, right, result, ic);
+	  return ;
+  }
+
   /* should have been converted to function call */
-  assert (1);
+  assert (0);
 
 release:
   freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
@@ -4855,6 +5502,7 @@ genFarFarLogicOp(iCode *ic, char *logicOp)
       int size, resultSize, compSize;
       int offset = 0;
       
+      TR_AP("#5");
       D(emitcode(";", "%s special case for 3 far operands.", logicOp););
       compSize = AOP_SIZE(IC_LEFT(ic)) < AOP_SIZE(IC_RIGHT(ic)) ? 
       		  AOP_SIZE(IC_LEFT(ic)) : AOP_SIZE(IC_RIGHT(ic));
@@ -4924,8 +5572,11 @@ genAnd (iCode * ic, iCode * ifx)
 #endif
 
   /* if left is a literal & right is not then exchange them */
-  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) ||
-      AOP_NEEDSACC (left))
+  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT)
+#ifdef LOGIC_OPS_BROKEN      
+    ||  AOP_NEEDSACC (left)
+#endif
+    )
     {
       operand *tmp = right;
       right = left;
@@ -5134,9 +5785,20 @@ genAnd (iCode * ic, iCode * ifx)
 	    emitcode ("setb", "c");
 	  while (sizer--)
 	    {
-	      MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-	      emitcode ("anl", "a,%s",
-			aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+	      if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+		emitcode ("anl", "a,%s",
+			  aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+	      } else {
+		if (AOP_TYPE(left)==AOP_ACC) {
+		  emitcode("mov", "b,a");
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		  emitcode("anl", "a,b");
+		}else {
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		  emitcode ("anl", "a,%s",
+			    aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+		}
+	      }
 	      emitcode ("jnz", "%05d$", tlbl->key + 100);
 	      offset++;
 	    }
@@ -5169,8 +5831,7 @@ genAnd (iCode * ic, iCode * ifx)
 		      aopPut (AOP (result), zero, offset);
 		      continue;
 		    }
-		  D (emitcode (";", "better literal AND.");
-		    );
+		  D (emitcode (";", "better literal AND."););
 		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
 		  emitcode ("anl", "a, %s", aopGet (AOP (right), offset,
 						    FALSE, FALSE, FALSE));
@@ -5187,10 +5848,16 @@ genAnd (iCode * ic, iCode * ifx)
 		    }
 		  else
 		    {
-		      MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-		      emitcode ("anl", "a,%s",
-			  aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
-		    }
+		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, TRUE);
+		      if (!strcmp(rOp, "a") || !strcmp(rOp, "acc"))
+		      {
+			  emitcode("mov", "b,a");
+			  rOp = "b";
+		      }
+			
+		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		      emitcode ("anl", "a,%s", rOp);
+		    }			
 		}
 	      aopPut (AOP (result), "a", offset);
 	    }
@@ -5237,8 +5904,11 @@ genOr (iCode * ic, iCode * ifx)
 #endif
 
   /* if left is a literal & right is not then exchange them */
-  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) ||
-      AOP_NEEDSACC (left))
+  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT)
+#ifdef LOGIC_OPS_BROKEN
+   || AOP_NEEDSACC (left) // I think this is a net loss now.
+#endif      
+      )
     {
       operand *tmp = right;
       right = left;
@@ -5436,9 +6106,14 @@ genOr (iCode * ic, iCode * ifx)
 	    emitcode ("setb", "c");
 	  while (sizer--)
 	    {
-	      MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-	      emitcode ("orl", "a,%s",
-			aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+	      if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+		emitcode ("orl", "a,%s",
+			  aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+	      } else {
+		MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		emitcode ("orl", "a,%s",
+			  aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+	      }
 	      emitcode ("jnz", "%05d$", tlbl->key + 100);
 	      offset++;
 	    }
@@ -5453,6 +6128,7 @@ genOr (iCode * ic, iCode * ifx)
 	}
       else
 	{
+	    _startLazyDPSEvaluation();
 	  for (; (size--); offset++)
 	    {
 	      // normal case
@@ -5466,8 +6142,7 @@ genOr (iCode * ic, iCode * ifx)
 			      offset);
 		      continue;
 		    }
-		  D (emitcode (";", "better literal OR.");
-		    );
+		  D (emitcode (";", "better literal OR."););
 		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
 		  emitcode ("orl", "a, %s", aopGet (AOP (right), offset,
 						    FALSE, FALSE, FALSE));
@@ -5484,13 +6159,21 @@ genOr (iCode * ic, iCode * ifx)
 		    }
 		  else
 		    {
-		      MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-		      emitcode ("orl", "a,%s",
-			  aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, TRUE);
+			
+		      if (!strcmp(rOp, "a") || !strcmp(rOp, "acc"))
+		      {
+			  emitcode("mov", "b,a");
+			  rOp = "b";
+		      }
+			
+		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		      emitcode ("orl", "a,%s", rOp);
 		    }
 		}
 	      aopPut (AOP (result), "a", offset);
 	    }
+	    _endLazyDPSEvaluation();
 	}
     }
 
@@ -5533,8 +6216,11 @@ genXor (iCode * ic, iCode * ifx)
 
   /* if left is a literal & right is not ||
      if left needs acc & right does not */
-  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) ||
-      (AOP_NEEDSACC (left) && !AOP_NEEDSACC (right)))
+  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) 
+#ifdef LOGIC_OPS_BROKEN      
+      || (AOP_NEEDSACC (left) && !AOP_NEEDSACC (right))
+#endif
+     )
     {
       operand *tmp = right;
       right = left;
@@ -5710,9 +6396,14 @@ genXor (iCode * ic, iCode * ifx)
 		}
 	      else
 		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-		  emitcode ("xrl", "a,%s",
-			  aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+		  if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+		    emitcode ("xrl", "a,%s",
+			      aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+		  } else {
+		    MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		    emitcode ("xrl", "a,%s",
+			      aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+		  }
 		}
 	      emitcode ("jnz", "%05d$", tlbl->key + 100);
 	      offset++;
@@ -5757,9 +6448,15 @@ genXor (iCode * ic, iCode * ifx)
 		  }
 		else
 		  {
-		    MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-		    emitcode ("xrl", "a,%s",
-			   aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, TRUE);
+		      if (!strcmp(rOp, "a") || !strcmp(rOp, "acc"))
+		      {
+			  emitcode("mov", "b,a");
+			  rOp = "b";
+		      }
+			
+		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		      emitcode ("xrl", "a,%s", rOp);
 		  }
 	      }
 	    aopPut (AOP (result), "a", offset);
@@ -5778,14 +6475,14 @@ release:
 static void
 genInline (iCode * ic)
 {
-  char buffer[MAX_INLINEASM];
-  char *bp = buffer;
-  char *bp1 = buffer;
+  char *buffer, *bp, *bp1;
 
   D (emitcode (";", "genInline ");
     );
 
   _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 */
@@ -6364,7 +7061,6 @@ AccAXRsh (char *x, int shCount)
 #endif
 
 #ifdef BETTER_LITERAL_SHIFT
-//REMOVE ME!!!
 /*-----------------------------------------------------------------*/
 /* AccAXRshS - right shift signed a:x known count (0..7)           */
 /*-----------------------------------------------------------------*/
@@ -6488,7 +7184,7 @@ _loadLeftIntoAx(char 	**lsb,
        char *leftByte;
        
        _startLazyDPSEvaluation();
-       if (AOP_TYPE(left) == AOP_DPTR2)
+      if (AOP_TYPE(left) == AOP_DPTR2)
        {
            // Get MSB in A.
        	   MOVA(aopGet(AOP(left), offl + MSB16, FALSE, FALSE, TRUE));
@@ -6502,6 +7198,7 @@ _loadLeftIntoAx(char 	**lsb,
        	   leftByte = aopGet (AOP(left), offl, FALSE, FALSE, TRUE);
            if (strcmp(leftByte, DP2_RESULT_REG))
            {
+               TR_AP("#7");
                emitcode("mov","%s,%s", DP2_RESULT_REG, leftByte);
        	   }
        	   // And MSB in A.
@@ -6586,11 +7283,11 @@ shiftR2Left2Result (operand * left, int offl,
   /* a:x >> shCount (x = lsb(result)) */
   if (sign)
   {
-    AccAXRshS(aopGet(AOP(result), offr, FALSE, FALSE, FALSE), shCount);
+     AccAXRshS(lsb, shCount);
   }
   else
   {
-    AccAXRsh(aopGet(AOP(result), offr, FALSE, FALSE, FALSE), shCount);
+    AccAXRsh(lsb, shCount);
   }
   
   _storeAxResults(lsb, result, offr);
@@ -7164,28 +7861,54 @@ static void
 shiftRLong (operand * left, int offl,
 	    operand * result, int sign)
 {
-  if (!sign)
+  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 (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");
-  MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE, TRUE));
-  if (sign)
+  } 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, TRUE));
   emitcode ("rrc", "a");
-  aopPut (AOP (result), "a", MSB24 - offl);
 
-  MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE, TRUE));
+  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);
 
   if (offl == LSB)
     {
-      MOVA (aopGet (AOP (left), LSB, FALSE, FALSE, TRUE));
+      MOVA (aopGet (AOP (left), LSB, FALSE, FALSE));
       emitcode ("rrc", "a");
       aopPut (AOP (result), "a", LSB);
     }
@@ -7654,7 +8377,7 @@ genUnpackBits (operand * result, char *rname, int ptype)
 
     case CPOINTER:
       emitcode ("clr", "a");
-      emitcode ("movc", "a", "@a+dptr");
+      emitcode ("movc", "a,@a+dptr");
       break;
 
     case GPOINTER:
@@ -7706,7 +8429,7 @@ genUnpackBits (operand * result, char *rname, int ptype)
 	case CPOINTER:
 	  emitcode ("clr", "a");
 	  emitcode ("inc", "dptr");
-	  emitcode ("movc", "a", "@a+dptr");
+	  emitcode ("movc", "a,@a+dptr");
 	  break;
 
 	case GPOINTER:
@@ -7994,7 +8717,8 @@ genFarPointerGet (operand * left,
 	    {
 	      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
 	      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, TRUE));
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+	      if (options.model == MODEL_FLAT24)
+		emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
 	    }
 	  else
 	    {
@@ -8003,7 +8727,8 @@ genFarPointerGet (operand * left,
 		);
 	      emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, TRUE));
 	      emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, TRUE));
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+	      if (options.model == MODEL_FLAT24)
+		emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
 	    }
@@ -8069,7 +8794,8 @@ emitcodePointerGet (operand * left,
 	    {
 	      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
 	      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, TRUE));
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+	      if (options.model == MODEL_FLAT24)
+	        emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
 	    }
 	  else
 	    {
@@ -8078,7 +8804,8 @@ emitcodePointerGet (operand * left,
 		);
 	      emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, TRUE));
 	      emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, TRUE));
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+	      if (options.model == MODEL_FLAT24)
+	        emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
 	    }
@@ -8153,16 +8880,24 @@ genGenPointerGet (operand * left,
 	    genSetDPTR(0);
 	    _flushLazyDPS();
 	    emitcode ("mov", "dph,%s", l);
-	    l=aopGet(AOP(left),2,FALSE,FALSE,TRUE);
-	    genSetDPTR(0);
-	    _flushLazyDPS();
-	    emitcode ("mov", "dpx,%s", l);
-	    emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
+	    if (options.model == MODEL_FLAT24) {
+	      l=aopGet(AOP(left),2,FALSE,FALSE,TRUE);
+	      genSetDPTR(0);
+	      _flushLazyDPS();
+	      emitcode ("mov", "dpx,%s", l);
+	      emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
+	    } else {
+	      emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
+	    }
 	  } else {
 	    emitcode ("mov", "dpl,%s", aopGet (AOP(left),0,FALSE,FALSE,TRUE));
 	    emitcode ("mov", "dph,%s", aopGet (AOP(left),1,FALSE,FALSE,TRUE));
-	    emitcode ("mov", "dpx,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
-	    emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
+	    if (options.model == MODEL_FLAT24) {
+	      emitcode ("mov", "dpx,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
+	      emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
+	    } else {
+	      emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
+	    }
 	  }
 	  _endLazyDPSEvaluation ();
 	}
@@ -8666,7 +9401,8 @@ genFarPointerSet (operand * right,
 	    {
 	      emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE, TRUE));
 	      emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE, TRUE));
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
+	      if (options.model == MODEL_FLAT24)
+	        emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
 	    }
 	  else
 	    {
@@ -8675,7 +9411,8 @@ genFarPointerSet (operand * right,
 		);
 	      emitcode ("push", "%s", aopGet (AOP (result), 0, FALSE, TRUE, TRUE));
 	      emitcode ("push", "%s", aopGet (AOP (result), 1, FALSE, TRUE, TRUE));
-	      emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
+	      if (options.model == MODEL_FLAT24)
+	        emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
 	    }
@@ -8741,8 +9478,12 @@ genGenPointerSet (operand * right,
 	{			/* we need to get it byte by byte */
 	  emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE, TRUE));
 	  emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE, TRUE));
-	  emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
-	  emitcode ("mov", "b,%s", aopGet (AOP (result), 3, FALSE, FALSE, TRUE));
+	  if (options.model == MODEL_FLAT24) {
+	    emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
+	    emitcode ("mov", "b,%s", aopGet (AOP (result), 3, FALSE, FALSE, TRUE));
+	  } else {
+	    emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
+	  }
 	}
       _endLazyDPSEvaluation ();
     }
@@ -8950,6 +9691,115 @@ release:
 
 }
 
+/*-----------------------------------------------------------------*/
+/* genArrayInit - generates code for address of                       */
+/*-----------------------------------------------------------------*/
+static void
+genArrayInit (iCode * ic)
+{
+    literalList *iLoop;
+    int         ix, count;
+    int         elementSize = 0, eIndex;
+    unsigned    val, lastVal;
+    sym_link    *type;
+    operand     *left=IC_LEFT(ic);
+    
+    D (emitcode (";", "genArrayInit "););
+
+    aopOp (IC_LEFT(ic), ic, FALSE, FALSE);
+    
+    if (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD)
+    {
+	// Load immediate value into DPTR.
+	emitcode("mov", "dptr, %s",
+	     aopGet(AOP(IC_LEFT(ic)), 0, TRUE, FALSE, TRUE));
+    }
+    else if (AOP_TYPE(IC_LEFT(ic)) != AOP_DPTR)
+    {
+#if 0
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+	      "Unexpected operand to genArrayInit.\n");
+      exit(1);
+#else
+      // a regression because of SDCCcse.c:1.52
+      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
+      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, TRUE));
+      if (options.model == MODEL_FLAT24)
+	emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+#endif
+    }
+    
+    type = operandType(IC_LEFT(ic));
+    
+    if (type && type->next)
+    {
+	elementSize = getSize(type->next);
+    }
+    else
+    {
+	werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+		                "can't determine element size in genArrayInit.\n");
+	exit(1);
+    }
+    
+    iLoop = IC_ARRAYILIST(ic);
+    lastVal = 0xffff;
+    
+    while (iLoop)
+    {
+	bool firstpass = TRUE;
+	
+	emitcode(";", "store %d x 0x%x to DPTR (element size %d)", 
+		 iLoop->count, (int)iLoop->literalValue, elementSize);
+	
+	ix = iLoop->count;
+	
+	while (ix)
+	{
+	    symbol *tlbl = NULL;
+	    
+	    count = ix > 256 ? 256 : ix;
+	    
+	    if (count > 1)
+	    {
+		tlbl = newiTempLabel (NULL);
+		if (firstpass || (count & 0xff))
+		{
+		    emitcode("mov", "b, #0x%x", count & 0xff);
+		}
+		
+		emitcode ("", "%05d$:", tlbl->key + 100);
+	    }
+	    
+	    firstpass = FALSE;
+		
+	    for (eIndex = 0; eIndex < elementSize; eIndex++)
+	    {
+		val = (((int)iLoop->literalValue) >> (eIndex * 8)) & 0xff;
+		if (val != lastVal)
+		{
+		    emitcode("mov", "a, #0x%x", val);
+		    lastVal = val;
+		}
+		
+		emitcode("movx", "@dptr, a");
+		emitcode("inc", "dptr");
+	    }
+	    
+	    if (count > 1)
+	    {
+		emitcode("djnz", "b, %05d$", tlbl->key + 100);
+	    }
+	    
+	    ix -= count;
+	}
+	
+	iLoop = iLoop->next;
+    }
+    
+    freeAsmop (IC_LEFT(ic), NULL, ic, TRUE);
+}
+
 /*-----------------------------------------------------------------*/
 /* genFarFarAssign - assignment when both are in far space         */
 /*-----------------------------------------------------------------*/
@@ -8992,7 +9842,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   {
       /* We can use the '390 auto-toggle feature to good effect here. */
       
-      D(emitcode(";","genFarFarAssign ('390 auto-toggle fun)"););
+      D(emitcode(";","genFarFarAssign (390 auto-toggle fun)"););
       emitcode("mov", "dps, #0x21"); 	/* Select DPTR2 & auto-toggle. */
       emitcode ("mov", "dptr,#%s", rSym->rname); 
       /* DP2 = result, DP1 = right, DP1 is current. */
@@ -9008,6 +9858,28 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
       }
       emitcode("mov", "dps, #0");
       freeAsmop (right, NULL, ic, FALSE);
+#if 0
+some alternative code for processors without auto-toggle
+no time to test now, so later well put in...kpb
+        D(emitcode(";","genFarFarAssign (dual-dptr fun)"););
+        emitcode("mov", "dps, #0x01"); 	/* Select DPTR2. */
+        emitcode ("mov", "dptr,#%s", rSym->rname); 
+        /* DP2 = result, DP1 = right, DP1 is current. */
+        while (size)
+        {
+          --size;
+          emitcode("movx", "a,@dptr");
+          if (size)
+            emitcode("inc", "dptr");
+          emitcode("inc", "dps");
+          emitcode("movx", "@dptr,a");
+          if (size)
+            emitcode("inc", "dptr");
+          emitcode("inc", "dps");
+        }
+        emitcode("mov", "dps, #0");
+        freeAsmop (right, NULL, ic, FALSE);
+#endif
   }
   else
   {
@@ -9071,9 +9943,8 @@ genAssign (iCode * ic)
     goto release;
 
   /* if the result is a bit */
-  if (AOP_TYPE (result) == AOP_CRY)
+  if (AOP_TYPE (result) == AOP_CRY) /* works only for true symbols */
     {
-
       /* if the right size is a literal then
          we know what the value is */
       if (AOP_TYPE (right) == AOP_LIT)
@@ -9204,7 +10075,8 @@ genCast (iCode * ic)
   aopOp (result, ic, FALSE, AOP_TYPE (right) == AOP_DPTR);
 
   /* if the result is a bit */
-  if (AOP_TYPE (result) == AOP_CRY)
+  // if (AOP_TYPE (result) == AOP_CRY) /* works only for true symbols */
+  if (IS_BITVAR(OP_SYMBOL(result)->type))
     {
       /* if the right size is a literal then
          we know what the value is */
@@ -9552,6 +10424,14 @@ gen390Code (iCode * lic)
 
   lineHead = lineCurr = NULL;
 
+  if (options.model == MODEL_FLAT24) {
+    fReturnSizeDS390 = 5;
+    fReturn = fReturn24;
+  } else {
+    fReturnSizeDS390 = 4;
+    fReturn = fReturn16;
+    options.stack10bit=0;
+  }
 #if 0
   //REMOVE ME!!!
   /* print the allocation information */
@@ -9783,6 +10663,10 @@ gen390Code (iCode * lic)
 	  addSet (&_G.sendSet, ic);
 	  break;
 
+	case ARRAYINIT:
+	    genArrayInit(ic);
+	    break;
+	    
 	default:
 	  ic = ic;
 	}