X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fds390%2Fgen.c;h=92e7ac9b3588b5a188baad9a45caa0b04a4652bf;hb=3c14fa0febe494de4e6b32d931cd2d58db841b12;hp=44699fdd214adb6aabc3d7df2dee12734be6efe8;hpb=d7d830fa295b940b75fd64ba8297d00f2a24b2fc;p=fw%2Fsdcc

diff --git a/src/ds390/gen.c b/src/ds390/gen.c
index 44699fdd..92e7ac9b 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,6 +39,9 @@
 #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
@@ -47,18 +51,20 @@
 #endif
 #endif
 #endif
+#endif
 
 #define BETTER_LITERAL_SHIFT
 
 char *aopLiteral (value * val, int offset);
+extern int allocInfo;
 
 /* this is the down and dirty file with all kinds of
    kludgy & hacky stuff. This is what it is all about
    CODE GENERATION for a specific MCU . some of the
    routines may be reusable, will have to see */
 
-static char *zero = "#0x00";
-static char *one = "#0x01";
+static char *zero = "#0";
+static char *one = "#1";
 static char *spname;
 
 #define D(x) x
@@ -74,7 +80,7 @@ static char *fReturn16[] =
 static char **fReturn = fReturn24;
 static char *accUse[] =
 {"a", "b"};
-
+static char *javaRet[] = { "r0","r1","r2","r3"};
 static short rbank = -1;
 
 static struct
@@ -82,6 +88,7 @@ static struct
     short r0Pushed;
     short r1Pushed;
     short accInUse;
+    short bInUse;
     short inLine;
     short debugLine;
     short nRegsSaved;
@@ -108,7 +115,7 @@ static void saveRBank (int, iCode *, bool);
 
 // A scratch register which will be used to hold
 // result bytes from operands in far space via DPTR2.
-#define DP2_RESULT_REG	"ap"
+#define DP2_RESULT_REG	"_ap"
 
 static lineNode *lineHead = NULL;
 static lineNode *lineCurr = NULL;
@@ -143,10 +150,10 @@ emitcode (char *inst, char *fmt,...)
 	sprintf (lb, "%s\t", inst);
       else
 	sprintf (lb, "%s", inst);
-      vsprintf (lb + (strlen (lb)), fmt, ap);
+      tvsprintf (lb + (strlen (lb)), fmt, ap);
     }
   else
-    vsprintf (lb, fmt, ap);
+    tvsprintf (lb, fmt, ap);
 
   while (isspace (*lbp))
     lbp++;
@@ -288,12 +295,12 @@ genSetDPTR (int n)
 
   if (!n)
     {
-      emitcode ("mov", "dps, #0x00");
+      emitcode ("mov", "dps,#0");
     }
   else
     {
       TR_DPTR("#1");
-      emitcode ("mov", "dps, #0x01");
+      emitcode ("mov", "dps,#1");
     }
 }
 
@@ -424,14 +431,20 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 	      if (_G.accInUse)
 		emitcode ("push", "acc");
 
+	      if (_G.bInUse)
+		emitcode ("push", "b");
+
 	      emitcode ("mov", "a,_bp");
-	      emitcode ("add", "a,#0x%02x",
+	      emitcode ("add", "a,#!constbyte",
 			((sym->stack < 0) ?
 			 ((char) (sym->stack - _G.nRegsSaved)) :
 			 ((char) sym->stack)) & 0xff);
 	      emitcode ("mov", "%s,a",
 			aop->aopu.aop_ptr->name);
 
+	      if (_G.bInUse)
+		emitcode ("pop", "b");
+
 	      if (_G.accInUse)
 		emitcode ("pop", "acc");
 	    }
@@ -448,41 +461,68 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 
   if (sym->onStack && options.stack10bit)
     {
+	short stack_val = -((sym->stack < 0) ?
+			    ((short) (sym->stack - _G.nRegsSaved)) :
+			    ((short) sym->stack)) ;
       /* 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);
-
-      if (useDP2)
-	{
-	  if (options.model == MODEL_FLAT24)
-	    emitcode ("mov", "dpx1,#0x40");
-   TR_DPTR("#2");
-	  emitcode ("mov", "dph1,#0x00");
-	  emitcode ("mov", "dpl1, a");
-	}
-      else
-	{
-	  if (options.model == MODEL_FLAT24)
- 	    emitcode ("mov", "dpx,#0x40");
-	  emitcode ("mov", "dph,#0x00");
-	  emitcode ("mov", "dpl, a");
+	if (stack_val < 0 && stack_val > -3) { /* between -3 & -1 */
+	    if (useDP2) {
+		if (options.model == MODEL_FLAT24)
+		    emitcode ("mov", "dpx1,#!constbyte", (options.stack_loc >> 16) & 0xff);
+		TR_DPTR("#2");
+		emitcode ("mov", "dph1,_bpx+1");
+		emitcode ("mov", "dpl1,_bpx");
+		emitcode ("mov","dps,#1");
+	    } else {
+		if (options.model == MODEL_FLAT24)
+		    emitcode ("mov", "dpx,#!constbyte", (options.stack_loc >> 16) & 0xff);
+		emitcode ("mov", "dph,_bpx+1");
+		emitcode ("mov", "dpl,_bpx");
+	    }
+	    stack_val = -stack_val;
+	    while (stack_val--) {
+		emitcode ("inc","dptr");
+	    }
+	    if (useDP2) {
+		emitcode("mov","dps,#0");
+	    }
+	}  else {
+	    if (_G.accInUse)
+		emitcode ("push", "acc");
+	    
+	    if (_G.bInUse)
+		emitcode ("push", "b");
+	
+	    emitcode ("mov", "a,_bpx");
+	    emitcode ("clr","c");
+	    emitcode ("subb", "a,#!constbyte", stack_val & 0xff);
+	    emitcode ("mov","b,a");
+	    emitcode ("mov","a,_bpx+1");
+	    emitcode ("subb","a,#!constbyte",(stack_val >> 8) & 0xff);
+	    if (useDP2) {
+		if (options.model == MODEL_FLAT24)
+		    emitcode ("mov", "dpx1,#!constbyte", (options.stack_loc >> 16) & 0xff);
+		TR_DPTR("#2");
+		emitcode ("mov", "dph1,a");
+		emitcode ("mov", "dpl1,b");
+	    } else {
+		if (options.model == MODEL_FLAT24)
+		    emitcode ("mov", "dpx,#!constbyte", (options.stack_loc >> 16) & 0xff);
+		emitcode ("mov", "dph,a");
+		emitcode ("mov", "dpl,b");
+	    }
+	    
+	    if (_G.bInUse)
+		emitcode ("pop", "b");
+	    
+	    if (_G.accInUse)
+		emitcode ("pop", "acc");
 	}
-
-      if (_G.accInUse)
-	emitcode ("pop", "acc");
-
-      sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
-      aop->size = getSize (sym->type);
-      return aop;
+	sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
+	aop->size = getSize (sym->type);
+	return aop;
     }
 
   /* if in bit space */
@@ -506,8 +546,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;
     }
@@ -543,7 +583,7 @@ aopForRemat (symbol * sym)
 {
   iCode *ic = sym->rematiCode;
   asmop *aop = newAsmop (AOP_IMMD);
-
+  int ptr_type =0;
   int val = 0;
 
   for (;;)
@@ -552,9 +592,18 @@ 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);
+	      if (ptr_type == IPOINTER) {
+		// bug #481053
+		ptr_type = POINTER;
+	      }
+	      continue ;
+      } else break;
+      
       ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
     }
 
@@ -566,11 +615,35 @@ 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) {
+	  tsprintf(buffer,"#!constbyte",ptr_type);
+	  aop->aopu.aop_immd.aop_immd2 = Safe_calloc (1, strlen (buffer) + 1);
+	  strcpy (aop->aopu.aop_immd.aop_immd2, buffer);
+  }
+
   return aop;
 }
 
+/*-----------------------------------------------------------------*/
+/* aopHasRegs - returns true if aop has regs between from-to       */
+/*-----------------------------------------------------------------*/
+static int aopHasRegs(asmop *aop, int from, int to)
+{
+    int size =0;
+
+    if (aop->type != AOP_REG) return 0; /* if not assigned to regs */
+
+    for (; size < aop->size ; size++) {
+	int reg;
+	for (reg = from ; reg <= to ; reg++)
+	    if (aop->aopu.aop_reg[size] == ds390_regWithIdx(reg)) return 1;
+    }
+    return 0;
+}
+
 /*-----------------------------------------------------------------*/
 /* regsInCommon - two operands have some registers in common       */
 /*-----------------------------------------------------------------*/
@@ -780,7 +853,7 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2)
 	      /* a AOP_STR uses DPTR, but DPTR is already in use;
 	       * we're just hosed.
 	       */
-	      fprintf (stderr, "*** Internal error: AOP_STR with DPTR in use!\n");
+	      fprintf (stderr, "*** Internal error: AOP_STR with DPTR in use! for operand %s\n",sym->name);
 	    }
 
 	  aop = op->aop = sym->aop = newAsmop (AOP_STR);
@@ -791,6 +864,10 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2)
 	}
 
       /* else spill location  */
+      if (sym->usl.spillLoc && getSize(sym->type) != getSize(sym->usl.spillLoc->type)) {
+	  /* force a new aop if sizes differ */
+	  sym->usl.spillLoc->aop = NULL;
+      }
       sym->aop = op->aop = aop =
 	aopForSym (ic, sym->usl.spillLoc, result, useDP2);
       aop->size = getSize (sym->type);
@@ -874,7 +951,7 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
 	if (stk)
 	  {
 	    emitcode ("mov", "a,_bp");
-	    emitcode ("add", "a,#0x%02x", ((char) stk) & 0xff);
+	    emitcode ("add", "a,#!constbyte", ((char) stk) & 0xff);
 	    emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name);
 	  }
 	else
@@ -983,8 +1060,8 @@ aopGet (asmop * aop,
 	  genSetDPTR (1);
 	  if (!canClobberACC)
 	    {
-       TR_AP("#1");
-	      emitcode ("xch", "a, %s", DP2_RESULT_REG);
+		    TR_AP("#1");
+		    emitcode ("xch", "a, %s", DP2_RESULT_REG);
 	    }
 	}
 
@@ -1026,15 +1103,30 @@ aopGet (asmop * aop,
       return (dname ? "acc" : "a");
 
     case AOP_IMMD:
-      if (bit16)
-	sprintf (s, "#%s", aop->aopu.aop_immd);
-      else if (offset)
-	sprintf (s, "#(%s >> %d)",
-		 aop->aopu.aop_immd,
-		 offset * 8);
+      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) {
+	  switch (offset) {
+	  case 1:
+	      tsprintf(s,"#!his",aop->aopu.aop_immd.aop_immd1);
+	      break;
+	  case 2:
+	      tsprintf(s,"#!hihis",aop->aopu.aop_immd.aop_immd1);
+	      break;
+	  case 3:
+	      tsprintf(s,"#!hihihis",aop->aopu.aop_immd.aop_immd1);
+	      break;
+	  default: /* should not need this (just in case) */
+	      sprintf (s, "#(%s >> %d)",
+		       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;
@@ -1225,7 +1317,12 @@ aopPut (asmop * aop, char *s, int offset)
       if (strcmp (s, "a") == 0)
 	emitcode ("push", "acc");
       else
-	emitcode ("push", "%s", s);
+	if (*s=='@') {
+	  MOVA(s);
+	  emitcode ("push", "acc");
+	} else {
+	  emitcode ("push", s);
+	}
 
       break;
 
@@ -1253,9 +1350,9 @@ aopPut (asmop * aop, char *s, int offset)
 	      {
 		symbol *lbl = newiTempLabel (NULL);
 		emitcode ("clr", "c");
-		emitcode ("jz", "%05d$", lbl->key + 100);
+		emitcode ("jz", "!tlabel", lbl->key + 100);
 		emitcode ("cpl", "c");
-		emitcode ("", "%05d$:", lbl->key + 100);
+		emitcode ("", "!tlabeldef", lbl->key + 100);
 		emitcode ("mov", "%s,c", aop->aopu.aop_dir);
 	      }
 	    }
@@ -1399,9 +1496,9 @@ genNotFloat (operand * op, operand * res)
 
   tlbl = newiTempLabel (NULL);
   aopPut (res->aop, one, 1);
-  emitcode ("jz", "%05d$", (tlbl->key + 100));
+  emitcode ("jz", "!tlabel", (tlbl->key + 100));
   aopPut (res->aop, zero, 1);
-  emitcode ("", "%05d$:", (tlbl->key + 100));
+  emitcode ("", "!tlabeldef", (tlbl->key + 100));
 
   size = res->aop->size - 2;
   offset = 2;
@@ -1577,8 +1674,8 @@ genNot (iCode * ic)
   toBoolean (IC_LEFT (ic));
 
   tlbl = newiTempLabel (NULL);
-  emitcode ("cjne", "a,#0x01,%05d$", tlbl->key + 100);
-  emitcode ("", "%05d$:", tlbl->key + 100);
+  emitcode ("cjne", "a,#1,!tlabel", tlbl->key + 100);
+  emitcode ("", "!tlabeldef", tlbl->key + 100);
   outBitC (IC_RESULT (ic));
 
 release:
@@ -1596,6 +1693,7 @@ genCpl (iCode * ic)
 {
   int offset = 0;
   int size;
+  symbol *tlbl;
 
   D (emitcode (";", "genCpl ");
     );
@@ -1605,17 +1703,21 @@ genCpl (iCode * ic)
   aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
   aopOp (IC_RESULT (ic), ic, TRUE, AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR);
 
-  /* if both are in bit space then
-     a special case */
-  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY &&
-      AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
-    {
-
+  /* special case if in bit space */
+  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY) {
+    if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY) {
       emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
       emitcode ("cpl", "c");
       emitcode ("mov", "%s,c", IC_RESULT (ic)->aop->aopu.aop_dir);
       goto release;
     }
+    tlbl=newiTempLabel(NULL);
+    emitcode ("cjne", "%s,#0x01,%05d$", 
+	      aopGet(AOP(IC_LEFT(ic)), 0, FALSE,FALSE,TRUE), tlbl->key+100);
+    emitcode ("", "%05d$:", tlbl->key+100);
+    outBitC (IC_RESULT(ic));
+    goto release;
+  }
 
   size = AOP_SIZE (IC_RESULT (ic));
   _startLazyDPSEvaluation ();
@@ -1746,16 +1848,45 @@ release:
   freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
 }
 
+/*-----------------------------------------------------------------*/
+/* savermask - saves registers in the mask                         */
+/*-----------------------------------------------------------------*/
+static void savermask(bitVect *rs_mask)
+{
+    int i;
+    if (options.useXstack) {
+	if (bitVectBitValue (rs_mask, R0_IDX))
+	    emitcode ("mov", "b,r0");
+	emitcode ("mov", "r0,%s", spname);
+	for (i = 0; i < ds390_nRegs; i++) {
+	    if (bitVectBitValue (rs_mask, i)) {
+		if (i == R0_IDX)
+		    emitcode ("mov", "a,b");
+		else
+		    emitcode ("mov", "a,%s", ds390_regWithIdx (i)->name);
+		emitcode ("movx", "@r0,a");
+		emitcode ("inc", "r0");
+	    }
+	}
+	emitcode ("mov", "%s,r0", spname);
+	if (bitVectBitValue (rs_mask, R0_IDX))
+	    emitcode ("mov", "r0,b");
+    } else {
+	for (i = 0; i < ds390_nRegs; i++) {
+	    if (bitVectBitValue (rs_mask, i))
+		emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
+	}
+    }
+}
+
 /*-----------------------------------------------------------------*/
 /* saveRegisters - will look for a call and save the registers     */
 /*-----------------------------------------------------------------*/
 static void
 saveRegisters (iCode * lic)
 {
-  int i;
   iCode *ic;
   bitVect *rsave;
-  sym_link *detype;
 
   /* look for call */
   for (ic = lic; ic; ic = ic->next)
@@ -1770,45 +1901,55 @@ saveRegisters (iCode * lic)
 
   /* if the registers have been saved already then
      do nothing */
-  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
-     and push them away to safety */
-  rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
-			 ic->rUsed);
-
+  if (ic->regsSaved || IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic)))) return ;
+
+  /* special case if DPTR alive across a function call then must save it 
+     even though callee saves */
+  if (IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
+      int i =0;
+      rsave = newBitVect(ic->rMask->size);
+      for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	  if (bitVectBitValue(ic->rMask,i))
+	      rsave = bitVectSetBit(rsave,i);
+      }
+      rsave = bitVectCplAnd(rsave,ds390_rUmaskForOp (IC_RESULT(ic)));
+  } else {
+    /* safe the registers in use at this time but skip the
+       ones for the result */
+    rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+			   ds390_rUmaskForOp (IC_RESULT(ic)));
+  }
   ic->regsSaved = 1;
-  if (options.useXstack)
-    {
-      if (bitVectBitValue (rsave, R0_IDX))
-	emitcode ("mov", "b,r0");
-      emitcode ("mov", "r0,%s", spname);
-      for (i = 0; i < ds390_nRegs; i++)
-	{
-	  if (bitVectBitValue (rsave, i))
-	    {
-	      if (i == R0_IDX)
-		emitcode ("mov", "a,b");
-	      else
-		emitcode ("mov", "a,%s", ds390_regWithIdx (i)->name);
-	      emitcode ("movx", "@r0,a");
-	      emitcode ("inc", "r0");
-	    }
+  savermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* usavermask - restore registers with mask                        */
+/*-----------------------------------------------------------------*/
+static void unsavermask(bitVect *rs_mask)
+{
+    int i;
+    if (options.useXstack) {
+	emitcode ("mov", "r0,%s", spname);
+	for (i = ds390_nRegs; i >= 0; i--) {
+	    if (bitVectBitValue (rs_mask, i)) {
+		emitcode ("dec", "r0");
+		emitcode ("movx", "a,@r0");
+		if (i == R0_IDX)
+		    emitcode ("mov", "b,a");
+		else
+		    emitcode ("mov", "%s,a", ds390_regWithIdx (i)->name);
+	    }	    
+	}
+	emitcode ("mov", "%s,r0", spname);
+	if (bitVectBitValue (rs_mask, R0_IDX))
+	    emitcode ("mov", "r0,b");
+    } else {
+	for (i = ds390_nRegs; i >= 0; i--) {
+	    if (bitVectBitValue (rs_mask, i))
+		emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
 	}
-      emitcode ("mov", "%s,r0", spname);
-      if (bitVectBitValue (rsave, R0_IDX))
-	emitcode ("mov", "r0,b");
     }
-  else
-    for (i = 0; i < ds390_nRegs; i++)
-      {
-	if (bitVectBitValue (rsave, i))
-	  emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
-      }
-
-  detype = getSpec (operandType (IC_LEFT (ic)));
 }
 
 /*-----------------------------------------------------------------*/
@@ -1817,40 +1958,23 @@ saveRegisters (iCode * lic)
 static void
 unsaveRegisters (iCode * ic)
 {
-  int i;
   bitVect *rsave;
-  /* find the registers in use at this time
-     and push them away to safety */
-  rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
-			 ic->rUsed);
-
-  if (options.useXstack)
-    {
-      emitcode ("mov", "r0,%s", spname);
-      for (i = ds390_nRegs; i >= 0; i--)
-	{
-	  if (bitVectBitValue (rsave, i))
-	    {
-	      emitcode ("dec", "r0");
-	      emitcode ("movx", "a,@r0");
-	      if (i == R0_IDX)
-		emitcode ("mov", "b,a");
-	      else
-		emitcode ("mov", "%s,a", ds390_regWithIdx (i)->name);
-	    }
 
-	}
-      emitcode ("mov", "%s,r0", spname);
-      if (bitVectBitValue (rsave, R0_IDX))
-	emitcode ("mov", "r0,b");
-    }
-  else
-    for (i = ds390_nRegs; i >= 0; i--)
-      {
-	if (bitVectBitValue (rsave, i))
-	  emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
+  if (IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
+      int i =0;
+      rsave = newBitVect(ic->rMask->size);
+      for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	  if (bitVectBitValue(ic->rMask,i))
+	      rsave = bitVectSetBit(rsave,i);
       }
-
+      rsave = bitVectCplAnd(rsave,ds390_rUmaskForOp (IC_RESULT(ic)));
+  } else {
+    /* restore the registers in use at this time but skip the
+       ones for the result */
+    rsave = bitVectCplAnd (bitVectCopy (ic->rMask), 
+			   ds390_rUmaskForOp (IC_RESULT(ic)));
+  }
+  unsavermask(rsave);
 }
 
 
@@ -2083,7 +2207,7 @@ unsaveRBank (int bank, iCode * ic, bool popPsw)
       }
     }
 
-  for (i = (ds390_nRegs - 1); i >= 0; i--)
+  for (i = 7; i >= 0; i--) /* only R7-R0 needs to be popped */
     {
       if (options.useXstack)
 	{
@@ -2134,7 +2258,7 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
         emitcode ("mov", "%s,_spx", r->name);    
     }
 
-  for (i = 0; i < ds390_nRegs; i++)
+  for (i = 0; i < 8 ; i++) /* only R0-R7 needs saving */
     {
       if (options.useXstack)
 	{
@@ -2162,7 +2286,7 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
 	emitcode ("push", "psw");
       }
 
-      emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
+      emitcode ("mov", "psw,#!constbyte", (bank << 3) & 0x00ff);
     }
   
   if (aop)
@@ -2182,7 +2306,7 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
 static void
 genCall (iCode * ic)
 {
-  sym_link *detype;
+  sym_link *dtype;
   bool restoreBank = FALSE;
   bool swapBanks = FALSE;
 
@@ -2191,17 +2315,17 @@ genCall (iCode * ic)
   /* if we are calling a not _naked function that is not using
      the same register bank then we need to save the
      destination registers on the stack */
-  detype = getSpec (operandType (IC_LEFT (ic)));
-  if (detype && !SPEC_NAKED(detype) &&
-      (SPEC_BANK (currFunc->etype) != SPEC_BANK (detype)) &&
-      IS_ISR (currFunc->etype))
+  dtype = operandType (IC_LEFT (ic));
+  if (currFunc && 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 (SPEC_BANK (detype), ic, FALSE);
+    	   saveRBank (FUNC_REGBANK (dtype), ic, FALSE);
     	   restoreBank = TRUE;
       }
       swapBanks = TRUE;
@@ -2226,41 +2350,28 @@ genCall (iCode * ic)
 	{
 	  int size, offset = 0;
 
-	  aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
-	  size = AOP_SIZE (IC_LEFT (sic));
-
+	  // we know that dpl(hxb) is the result, so
 	  _startLazyDPSEvaluation ();
+	  size=getSize(operandType(IC_LEFT(sic)));
+	  if (size>1) {
+	    aopOp (IC_LEFT (sic), sic, FALSE, 
+		   (IS_SYMOP(IC_LEFT(sic)) && OP_SYMBOL(IC_LEFT(sic))->ruonly ? FALSE : TRUE));
+	  } else {
+	    aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
+	  }
 	  while (size--)
 	    {
-	      char *l = aopGet (AOP(IC_LEFT(sic)), offset,
+	      char *l = aopGet (AOP (IC_LEFT (sic)), offset,
 				FALSE, FALSE, TRUE);
-	        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);
-	        }
+	      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;
@@ -2268,8 +2379,8 @@ genCall (iCode * ic)
     
   if (swapBanks)
   {
-        emitcode ("mov", "psw,#0x%02x", 
-           ((SPEC_BANK(detype)) << 3) & 0xff);
+        emitcode ("mov", "psw,#!constbyte", 
+           ((FUNC_REGBANK(dtype)) << 3) & 0xff);
   }
 
   /* make the call */
@@ -2279,13 +2390,14 @@ genCall (iCode * ic)
 
   if (swapBanks)
   {
-       emitcode ("mov", "psw,#0x%02x", 
-          ((SPEC_BANK(currFunc->etype)) << 3) & 0xff);
+       emitcode ("mov", "psw,#!constbyte", 
+          ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
   }
 
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
+	OP_SYMBOL (IC_RESULT (ic))->accuse ||
 	OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
       IS_TRUE_SYMOP (IC_RESULT (ic)))
     {
@@ -2324,27 +2436,41 @@ genCall (iCode * ic)
 
   /* adjust the stack for parameters if
      required */
-  if (ic->parmBytes)
-    {
+  if (ic->parmBytes) {
       int i;
-      if (ic->parmBytes > 3)
-	{
-	  emitcode ("mov", "a,%s", spname);
-	  emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
-	  emitcode ("mov", "%s,a", spname);
-	}
-      else
-	for (i = 0; i < ic->parmBytes; i++)
-	  emitcode ("dec", "%s", spname);
-    }
+      if (options.stack10bit) {
+	  if (ic->parmBytes <= 4) {
+	      emitcode(";","stack adjustment for parms");
+	      for (i=0; i < ic->parmBytes ; i++) {
+		  emitcode("pop","acc");
+	      }
+	  } else {
+	      emitcode ("clr","c");
+	      emitcode ("mov","a,sp");
+	      emitcode ("subb","a,#!constbyte",ic->parmBytes & 0xff);
+	      emitcode ("mov","sp,a");
+	      emitcode ("mov","a,esp");
+	      emitcode ("subb","a,#!constbyte",(ic->parmBytes >> 8) & 0xff);
+	      emitcode ("mov","esp,a");	  
+	  }
+      } else {
+	  if (ic->parmBytes > 3) {
+	      emitcode ("mov", "a,%s", spname);
+	      emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff);
+	      emitcode ("mov", "%s,a", spname);
+	  } else
+	      for (i = 0; i < ic->parmBytes; i++)
+		  emitcode ("dec", "%s", spname);
+      }
+  }
 
   /* if we hade saved some registers then unsave them */
-  if (ic->regsSaved && !(OP_SYMBOL (IC_LEFT (ic))->calleeSave))
+  if (ic->regsSaved)
     unsaveRegisters (ic);
 
   /* if register bank was saved then pop them */
   if (restoreBank)
-    unsaveRBank (SPEC_BANK (detype), ic, FALSE);
+    unsaveRBank (FUNC_REGBANK (dtype), ic, FALSE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -2353,8 +2479,9 @@ genCall (iCode * ic)
 static void
 genPcall (iCode * ic)
 {
-  sym_link *detype;
+  sym_link *dtype;
   symbol *rlbl = newiTempLabel (NULL);
+  bool restoreBank=FALSE;
 
   D (emitcode (";", "genPcall ");
     );
@@ -2367,22 +2494,23 @@ 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 (currFunc && 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));
+  emitcode ("mov", "a,#!tlabel", (rlbl->key + 100));
   emitcode ("push", "acc");
-  emitcode ("mov", "a,#(%05d$ >> 8)", (rlbl->key + 100));
+  emitcode ("mov", "a,#!hil", (rlbl->key + 100));
   emitcode ("push", "acc");
 
   if (options.model == MODEL_FLAT24)
     {
-      emitcode ("mov", "a,#(%05d$ >> 16)", (rlbl->key + 100));
+      emitcode ("mov", "a,#!hihil", (rlbl->key + 100));
       emitcode ("push", "acc");
     }
 
@@ -2403,9 +2531,14 @@ genPcall (iCode * ic)
 	{
 	  int size, offset = 0;
 
-	  aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
-	  size = AOP_SIZE (IC_LEFT (sic));
+	  // we know that dpl(hxb) is the result, so
 	  _startLazyDPSEvaluation ();
+	  size=getSize(operandType(IC_LEFT(sic)));
+	  if (size>1) {
+	    aopOp (IC_LEFT (sic), sic, FALSE, TRUE);
+	  } else {
+	    aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
+	  }
 	  while (size--)
 	    {
 	      char *l = aopGet (AOP (IC_LEFT (sic)), offset,
@@ -2425,7 +2558,7 @@ genPcall (iCode * ic)
     }
 
   emitcode ("ret", "");
-  emitcode ("", "%05d$:", (rlbl->key + 100));
+  emitcode ("", "!tlabeldef", (rlbl->key + 100));
 
 
   /* if we need assign a result value */
@@ -2452,7 +2585,7 @@ genPcall (iCode * ic)
       if (ic->parmBytes > 3)
 	{
 	  emitcode ("mov", "a,%s", spname);
-	  emitcode ("add", "a,#0x%02x", (-ic->parmBytes) & 0xff);
+	  emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff);
 	  emitcode ("mov", "%s,a", spname);
 	}
       else
@@ -2462,11 +2595,9 @@ 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)
@@ -2527,7 +2658,7 @@ static void
 genFunction (iCode * ic)
 {
   symbol *sym;
-  sym_link *fetype;
+  sym_link *ftype;
   bool   switchedPSW = FALSE;
 
   D (emitcode (";", "genFunction "););
@@ -2539,42 +2670,46 @@ genFunction (iCode * ic)
   emitcode (";", "-----------------------------------------");
 
   emitcode ("", "%s:", sym->rname);
-  fetype = getSpec (operandType (IC_LEFT (ic)));
+  ftype = operandType (IC_LEFT (ic));
 
-  if (SPEC_NAKED(fetype))
+  if (IFFUNC_ISNAKED(ftype))
   {
       emitcode(";", "naked function: no prologue.");
       return;
   }
-
+  
+  if (options.stack_probe) 
+      emitcode ("lcall","__stack_probe");
   /* 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)
-	    emitcode ("", "%s = 0x%02x",
-		      regs390[i].dname,
-		      8 * rbank + regs390[i].offset);
-	  else
-	    emitcode ("", "%s = %s + 0x%02x",
-		      regs390[i].dname,
-		      regs390[i].base,
-		      8 * rbank + regs390[i].offset);
+	  if (regs390[i].print) {
+	      if (strcmp (regs390[i].base, "0") == 0)
+		  emitcode ("", "%s !equ !constbyte",
+			    regs390[i].dname,
+			    8 * rbank + regs390[i].offset);
+	      else
+		  emitcode ("", "%s !equ %s + !constbyte",
+			    regs390[i].dname,
+			    regs390[i].base,
+			    8 * rbank + regs390[i].offset);
+	  }
 	}
     }
 
   /* 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"))
@@ -2590,7 +2725,7 @@ genFunction (iCode * ic)
 	  emitcode ("push", "dpx");
 	  /* Make sure we're using standard DPTR */
 	  emitcode ("push", "dps");
-	  emitcode ("mov", "dps, #0x00");
+	  emitcode ("mov", "dps,#0");
 	  if (options.stack10bit)
 	    {
 	      /* This ISR could conceivably use DPTR2. Better save it. */
@@ -2603,13 +2738,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;
 
@@ -2646,7 +2781,7 @@ genFunction (iCode * ic)
 	     */
 	    unsigned long banksToSave = 0;
 	    
-	    if (sym->hasFcall)
+	    if (IFFUNC_HASFCALL(sym->type))
 	    {
 
 #define MAX_REGISTER_BANKS 4
@@ -2664,20 +2799,20 @@ genFunction (iCode * ic)
 	            
 	            if (i->op == CALL)
 	            {
-	                sym_link *detype;
+	                sym_link *dtype;
 	                
-	                detype = getSpec(operandType (IC_LEFT(i)));
-	                if (detype 
-	                 && SPEC_BANK(detype) != SPEC_BANK(sym->etype))
+	                dtype = operandType (IC_LEFT(i));
+	                if (dtype 
+	                 && FUNC_REGBANK(dtype) != FUNC_REGBANK(sym->type))
 	                {
 	                     /* Mark this bank for saving. */
-	                     if (SPEC_BANK(detype) >= MAX_REGISTER_BANKS)
+	                     if (FUNC_REGBANK(dtype) >= MAX_REGISTER_BANKS)
 	                     {
-	                         werror(E_NO_SUCH_BANK, SPEC_BANK(detype));
+	                         werror(E_NO_SUCH_BANK, FUNC_REGBANK(dtype));
 	                     }
 	                     else
 	                     {
-	                         banksToSave |= (1 << SPEC_BANK(detype));
+	                         banksToSave |= (1 << FUNC_REGBANK(dtype));
 	                     }
 	                     
 	                     /* And note that we don't need to do it in 
@@ -2708,8 +2843,8 @@ genFunction (iCode * ic)
 		     * the caller's R0 isn't trashed.
 		     */
 		    emitcode ("push", "psw");
-		    emitcode ("mov", "psw,#0x%02x", 
-		    	      (SPEC_BANK (sym->etype) << 3) & 0x00ff);
+		    emitcode ("mov", "psw,#!constbyte", 
+		    	      (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
 		    switchedPSW = TRUE;
 		}
 		
@@ -2721,6 +2856,7 @@ genFunction (iCode * ic)
 	             }
 	        }
 	    }
+	    // jwk: this needs a closer look
 	    SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
 	}
     }
@@ -2728,7 +2864,7 @@ genFunction (iCode * ic)
     {
       /* 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;
 
@@ -2750,57 +2886,68 @@ 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);
-    }
-
-  if (IS_RENT (sym->etype) || options.stackAuto)
-    {
-
-      if (options.useXstack)
-	{
-	  emitcode ("mov", "r0,%s", spname);
-	  emitcode ("mov", "a,_bp");
-	  emitcode ("movx", "@r0,a");
-	  emitcode ("inc", "%s", spname);
-	}
-      else
-	{
-	  /* set up the stack */
-	  emitcode ("push", "_bp");	/* save the callers stack  */
-	}
-      emitcode ("mov", "_bp,%s", spname);
-    }
+      emitcode ("mov", "psw,#!constbyte", (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
+    }
+
+  if ( (IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+       (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
+      if (options.stack10bit) {
+	  emitcode ("push","_bpx");
+	  emitcode ("push","_bpx+1");
+	  emitcode ("mov","_bpx,%s",spname);
+	  emitcode ("mov","_bpx+1,esp");
+	  emitcode ("anl","_bpx+1,#3");
+      } else {
+	  if (options.useXstack) {
+	      emitcode ("mov", "r0,%s", spname);
+	      emitcode ("mov", "a,_bp");
+	      emitcode ("movx", "@r0,a");
+	      emitcode ("inc", "%s", spname);
+	  } else {
+	      /* set up the stack */
+	      emitcode ("push", "_bp");	/* save the callers stack  */
+	  }
+	  emitcode ("mov", "_bp,%s", spname);
+      }
+  }
 
   /* adjust the stack for the function */
-  if (sym->stack)
-    {
-
+  if (sym->stack) {
       int i = sym->stack;
-      if (i > 256)
-	werror (W_STACK_OVERFLOW, sym->name);
-
-      if (i > 3 && sym->recvSize < 4)
-	{
-
-	  emitcode ("mov", "a,sp");
-	  emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
-	  emitcode ("mov", "sp,a");
-
-	}
-      else
-	while (i--)
-	  emitcode ("inc", "sp");
-    }
+      if (options.stack10bit) {
+	  if ( i > 1024) werror (W_STACK_OVERFLOW, sym->name);
+	  assert (sym->recvSize <= 4);
+	  emitcode ("mov","a,sp");
+	  emitcode ("add","a,#!constbyte", ((short) sym->stack & 0xff));
+	  emitcode ("mov","sp,a");
+	  emitcode ("mov","a,esp");
+	  emitcode ("addc","a,#!constbyte", (((short) sym->stack) >> 8) & 0xff);
+	  emitcode ("mov","esp,a");
+      } else {
+	  if (i > 256)
+	      werror (W_STACK_OVERFLOW, sym->name);
+	  
+	  if (i > 3 && sym->recvSize < 4) {
+	      
+	      emitcode ("mov", "a,sp");
+	      emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff));
+	      emitcode ("mov", "sp,a");
+	      
+	  } else
+	      while (i--)
+		  emitcode ("inc", "sp");
+      }
+  }
 
   if (sym->xstack)
     {
 
       emitcode ("mov", "a,_spx");
-      emitcode ("add", "a,#0x%02x", ((char) sym->xstack & 0xff));
+      emitcode ("add", "a,#!constbyte", ((char) sym->xstack & 0xff));
       emitcode ("mov", "_spx,a");
     }
 
@@ -2816,47 +2963,55 @@ genEndFunction (iCode * ic)
 
   D (emitcode (";", "genEndFunction "););
 
-  if (SPEC_NAKED(sym->etype))
+  if (IFFUNC_ISNAKED(sym->type))
   {
       emitcode(";", "naked function: no epilogue.");
       return;
   }
 
-  if (IS_RENT (sym->etype) || options.stackAuto)
-    {
-      emitcode ("mov", "%s,_bp", spname);
-    }
+  if ((IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+       (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
+
+      if (options.stack10bit) {
+	  emitcode ("mov", "sp,_bpx", spname);
+	  emitcode ("mov", "esp,_bpx+1", spname);
+      } else {
+	  emitcode ("mov", "%s,_bp", spname);
+      }
+  }
 
   /* if use external stack but some variables were
      added to the local stack then decrement the
      local stack */
-  if (options.useXstack && sym->stack)
-    {
+  if (options.useXstack && sym->stack) {
       emitcode ("mov", "a,sp");
-      emitcode ("add", "a,#0x%02x", ((char) -sym->stack) & 0xff);
+      emitcode ("add", "a,#!constbyte", ((char) -sym->stack) & 0xff);
       emitcode ("mov", "sp,a");
-    }
+  }
 
 
-  if ((IS_RENT (sym->etype) || options.stackAuto))
-    {
-      if (options.useXstack)
-	{
+  if ((IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+       (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
+
+      if (options.useXstack) {
 	  emitcode ("mov", "r0,%s", spname);
 	  emitcode ("movx", "a,@r0");
 	  emitcode ("mov", "_bp,a");
 	  emitcode ("dec", "%s", spname);
-	}
-      else
-	{
-	  emitcode ("pop", "_bp");
-	}
-    }
+      } else {
+	  if (options.stack10bit) {
+	      emitcode ("pop", "_bpx+1");
+	      emitcode ("pop", "_bpx");
+	  } else {
+	      emitcode ("pop", "_bp");
+	  }
+      }
+  }
 
   /* restore the register bank  */
-  if (SPEC_BANK (sym->etype) || IS_ISR (sym->etype))
+  if (FUNC_REGBANK (sym->type) || IFFUNC_ISISR (sym->type))
   {
-    if (!SPEC_BANK (sym->etype) || !IS_ISR (sym->etype)
+    if (!FUNC_REGBANK (sym->type) || !IFFUNC_ISISR (sym->type)
      || !options.useXstack)
     {
         /* Special case of ISR using non-zero bank with useXstack
@@ -2866,19 +3021,19 @@ genEndFunction (iCode * ic)
     }
   }
 
-  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;
 
@@ -2910,6 +3065,7 @@ genEndFunction (iCode * ic)
 	     * Restore any register banks saved by genFunction
 	     * in reverse order.
 	     */
+	  // jwk: this needs a closer look
 	    unsigned savedBanks = SPEC_ISR_SAVED_BANKS(currFunc->etype);
 	    int ix;
 	  
@@ -2951,7 +3107,7 @@ 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 */
@@ -2971,10 +3127,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;
 
@@ -3011,6 +3167,37 @@ genEndFunction (iCode * ic)
 
 }
 
+/*-----------------------------------------------------------------*/
+/* genJavaNativeRet - generate code for return JavaNative          */
+/*-----------------------------------------------------------------*/
+static void genJavaNativeRet(iCode *ic)
+{
+    int i, size;
+
+    aopOp (IC_LEFT (ic), ic, FALSE, 
+	   (IS_SYMOP(IC_LEFT(ic)) && OP_SYMBOL(IC_LEFT(ic))->ruonly ? FALSE :TRUE));
+    size = AOP_SIZE (IC_LEFT (ic));
+
+    assert (size <= 4);
+
+    /* it is assigned to GPR0-R3 then push them */
+    if (aopHasRegs(AOP(IC_LEFT(ic)),R0_IDX,R1_IDX) ||
+	aopHasRegs(AOP(IC_LEFT(ic)),R2_IDX,R3_IDX)) {
+	for (i = 0 ; i < size ; i++ ) {
+	    emitcode ("push","%s",aopGet(AOP(IC_LEFT(ic)),i,FALSE,TRUE,FALSE));	    
+	}
+	for (i = (size-1) ; i >= 0 ; i--) {
+	    emitcode ("pop","a%s",javaRet[i]);
+	}
+    } else {
+	for (i = 0 ; i < size ; i++) 
+	    emitcode ("mov","%s,%s",javaRet[i],aopGet(AOP(IC_LEFT(ic)),i,FALSE,TRUE,FALSE));
+    }
+    for (i = size ; i < 4 ; i++ )
+	    emitcode ("mov","%s,#0",javaRet[i]);
+    return;
+}
+
 /*-----------------------------------------------------------------*/
 /* genRet - generate code for return statement                     */
 /*-----------------------------------------------------------------*/
@@ -3027,9 +3214,16 @@ genRet (iCode * ic)
   if (!IC_LEFT (ic))
     goto jumpret;
 
+  /* if this is a JavaNative function then return 
+     value in different register */
+  if (IFFUNC_ISJAVANATIVE(currFunc->type)) {
+      genJavaNativeRet(ic);
+      goto jumpret;
+  }
   /* we have something to return then
      move the return value into place */
-  aopOp (IC_LEFT (ic), ic, FALSE, TRUE);
+  aopOp (IC_LEFT (ic), ic, FALSE, 
+	 (IS_SYMOP(IC_LEFT(ic)) && OP_SYMBOL(IC_LEFT(ic))->ruonly ? FALSE :TRUE));
   size = AOP_SIZE (IC_LEFT (ic));
 
   _startLazyDPSEvaluation ();
@@ -3075,7 +3269,7 @@ jumpret:
   if (!(ic->next && ic->next->op == LABEL &&
 	IC_LABEL (ic->next) == returnLabel))
 
-    emitcode ("ljmp", "%05d$", (returnLabel->key + 100));
+    emitcode ("ljmp", "!tlabel", (returnLabel->key + 100));
 
 }
 
@@ -3092,7 +3286,7 @@ genLabel (iCode * ic)
   D (emitcode (";", "genLabel ");
     );
 
-  emitcode ("", "%05d$:", (IC_LABEL (ic)->key + 100));
+  emitcode ("", "!tlabeldef", (IC_LABEL (ic)->key + 100));
 }
 
 /*-----------------------------------------------------------------*/
@@ -3103,7 +3297,7 @@ genGoto (iCode * ic)
 {
   D (emitcode (";", "genGoto ");
     );
-  emitcode ("ljmp", "%05d$", (IC_LABEL (ic)->key + 100));
+  emitcode ("ljmp", "!tlabel", (IC_LABEL (ic)->key + 100));
 }
 
 /*-----------------------------------------------------------------*/
@@ -3122,6 +3316,13 @@ findLabelBackwards (iCode * ic, int key)
       ic = ic->prev;
       count++;
 
+      /* If we have any pushes or pops, we cannot predict the distance.
+	 I don't like this at all, this should be dealt with in the 
+	 back-end */
+      if (ic->op == IPUSH || ic->op == IPOP) {
+	return 0;
+      }
+
       if (ic->op == LABEL && IC_LABEL (ic)->key == key)
 	{
 	  /* printf("findLabelBackwards = %d\n", count); */
@@ -3152,6 +3353,13 @@ genPlusIncr (iCode * ic)
   if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
     return FALSE;
 
+  if (size == 1 && AOP(IC_LEFT(ic)) == AOP(IC_RESULT(ic)) &&
+      AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) {
+      while (icount--) {
+	  emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE));
+      }
+      return TRUE;
+  }
   /* if increment 16 bits in register */
   if (
        AOP_TYPE (IC_LEFT (ic)) == AOP_REG &&
@@ -3184,13 +3392,13 @@ genPlusIncr (iCode * ic)
       emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE));
       if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	  IS_AOP_PREG (IC_RESULT (ic)))
-	emitcode ("cjne", "%s,#0x00,%05d$"
+	emitcode ("cjne", "%s,#0,!tlabel"
 		  ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
 		  ,tlbl->key + 100);
       else
 	{
 	  emitcode ("clr", "a");
-	  emitcode ("cjne", "a,%s,%05d$"
+	  emitcode ("cjne", "a,%s,!tlabel"
 		    ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
 		    ,tlbl->key + 100);
 	}
@@ -3200,11 +3408,11 @@ genPlusIncr (iCode * ic)
 	{
 	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0x00,%05d$"
+	    emitcode ("cjne", "%s,#0,!tlabel"
 		  ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
 		      ,tlbl->key + 100);
 	  else
-	    emitcode ("cjne", "a,%s,%05d$"
+	    emitcode ("cjne", "a,%s,!tlabel"
 		  ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
 		      ,tlbl->key + 100);
 
@@ -3214,12 +3422,12 @@ genPlusIncr (iCode * ic)
 	{
 	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0x00,%05d$"
+	    emitcode ("cjne", "%s,#0,!tlabel"
 		  ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
 		      ,tlbl->key + 100);
 	  else
 	    {
-	      emitcode ("cjne", "a,%s,%05d$"
+	      emitcode ("cjne", "a,%s,!tlabel"
 		  ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
 			,tlbl->key + 100);
 	    }
@@ -3228,7 +3436,7 @@ genPlusIncr (iCode * ic)
 
       if (emitTlbl)
 	{
-	  emitcode ("", "%05d$:", tlbl->key + 100);
+	  emitcode ("", "!tlabeldef", tlbl->key + 100);
 	}
       return TRUE;
     }
@@ -3250,7 +3458,7 @@ genPlusIncr (iCode * ic)
       if (icount > 3)
 	{
 	  MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, TRUE));
-	  emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff);
+	  emitcode ("add", "a,#!constbyte", ((char) icount) & 0xff);
 	  aopPut (AOP (IC_RESULT (ic)), "a", 0);
 	}
       else
@@ -3284,9 +3492,9 @@ outBitAcc (operand * result)
     }
   else
     {
-      emitcode ("jz", "%05d$", tlbl->key + 100);
+      emitcode ("jz", "!tlabel", tlbl->key + 100);
       emitcode ("mov", "a,%s", one);
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       outAcc (result);
     }
 }
@@ -3303,9 +3511,9 @@ genPlusBits (iCode * ic)
     {
       symbol *lbl = newiTempLabel (NULL);
       emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
-      emitcode ("jnb", "%s,%05d$", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
+      emitcode ("jnb", "%s,!tlabel", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
       emitcode ("cpl", "c");
-      emitcode ("", "%05d$:", (lbl->key + 100));
+      emitcode ("", "!tlabeldef", (lbl->key + 100));
       outBitC (IC_RESULT (ic));
     }
   else
@@ -3314,7 +3522,7 @@ genPlusBits (iCode * ic)
       emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
       emitcode ("rlc", "a");
       emitcode ("mov", "c,%s", AOP (IC_RIGHT (ic))->aopu.aop_dir);
-      emitcode ("addc", "a,#0x00");
+      emitcode ("addc", "a,#0");
       outAcc (IC_RESULT (ic));
     }
 }
@@ -3352,6 +3560,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) \
@@ -3366,6 +3576,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
@@ -3373,9 +3584,10 @@ adjustArithmeticResult (iCode * ic)
 // that the IC_RESULT operand is not aopOp'd.
 #define AOP_OP_3_NOFATAL(ic, rc) \
     aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
-    aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
+    aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR) || \
+                                  ((OP_SYMBOL(IC_RESULT(ic))->ruonly) && !isOperandEqual(IC_LEFT(ic),IC_RESULT(ic)))); \
     if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
-        isOperandInFarSpace(IC_RESULT(ic))) \
+        (isOperandInFarSpace(IC_RESULT(ic)) || (OP_SYMBOL(IC_RESULT(ic))->ruonly && !isOperandEqual(IC_LEFT(ic),IC_RESULT(ic))))) \
     { \
        /* No can do; DPTR & DPTR2 in use, and we need another. */ \
        rc = TRUE; \
@@ -3449,7 +3661,34 @@ genPlus (iCode * ic)
   D (emitcode (";", "genPlus "););
 
   /* special cases :- */
-
+  if ( IS_SYMOP(IC_LEFT(ic)) && OP_SYMBOL(IC_LEFT(ic))->ruonly &&
+      isOperandLiteral(IC_RIGHT(ic)) && OP_SYMBOL(IC_RESULT(ic))->ruonly) {
+      aopOp (IC_RIGHT (ic), ic, TRUE, FALSE);
+      size = floatFromVal (AOP (IC_RIGHT(ic))->aopu.aop_lit);
+      if (size <= 9) {
+	  while (size--) emitcode ("inc","dptr");
+      } else {
+	  emitcode ("mov","a,dpl");
+	  emitcode ("add","a,#!constbyte",size & 0xff);
+	  emitcode ("mov","dpl,a");
+	  emitcode ("mov","a,dph");
+	  emitcode ("addc","a,#!constbyte",(size >> 8) & 0xff);
+	  emitcode ("mov","dph,a");
+	  emitcode ("mov","a,dpx");
+	  emitcode ("addc","a,#!constbyte",(size >> 16) & 0xff);
+	  emitcode ("mov","dpx,a");
+      }
+      freeAsmop (IC_RIGHT (ic), NULL, ic, FALSE);
+      return ;
+  }
+  if ( IS_SYMOP(IC_LEFT(ic)) && 
+       OP_SYMBOL(IC_LEFT(ic))->remat &&
+       isOperandInFarSpace(IC_RIGHT(ic))) {
+      operand *op = IC_RIGHT(ic);
+      IC_RIGHT(ic) = IC_LEFT(ic);
+      IC_LEFT(ic) = op;
+  }
+		
   AOP_OP_3_NOFATAL (ic, pushResult);
   if (pushResult)
     {
@@ -3499,7 +3738,7 @@ genPlus (iCode * ic)
 	      while (size--)
 		{
 		  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, TRUE));
-		  emitcode ("addc", "a,#00");
+		  emitcode ("addc", "a,#0");
 		  aopPut (AOP (IC_RESULT (ic)), "a", offset++);
 		}
 	      _endLazyDPSEvaluation ();
@@ -3621,6 +3860,13 @@ genMinusDec (iCode * ic)
   if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
     return FALSE;
 
+  if (size == 1 && AOP(IC_LEFT(ic)) == AOP(IC_RESULT(ic)) &&
+      AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) {
+      while (icount--) {
+	  emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE));
+      }
+      return TRUE;
+  }
   /* if decrement 16 bits in register */
   if (AOP_TYPE (IC_LEFT (ic)) == AOP_REG &&
       AOP_TYPE (IC_RESULT (ic)) == AOP_REG &&
@@ -3654,13 +3900,13 @@ genMinusDec (iCode * ic)
       if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	  AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
 	  IS_AOP_PREG (IC_RESULT (ic)))
-	emitcode ("cjne", "%s,#0xff,%05d$"
-		  ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
+	emitcode ("cjne", "%s,#!constbyte,!tlabel"
+		  ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE), 0xff
 		  ,tlbl->key + 100);
       else
 	{
-	  emitcode ("mov", "a,#0xff");
-	  emitcode ("cjne", "a,%s,%05d$"
+	  emitcode ("mov", "a,#!constbyte",0xff);
+	  emitcode ("cjne", "a,%s,!tlabel"
 		    ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
 		    ,tlbl->key + 100);
 	}
@@ -3670,12 +3916,12 @@ genMinusDec (iCode * ic)
 	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	      AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
 	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0xff,%05d$"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
+	    emitcode ("cjne", "%s,#!constbyte,!tlabel"
+		      ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE),0xff
 		      ,tlbl->key + 100);
 	  else
 	    {
-	      emitcode ("cjne", "a,%s,%05d$"
+	      emitcode ("cjne", "a,%s,!tlabel"
 		  ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
 			,tlbl->key + 100);
 	    }
@@ -3686,12 +3932,12 @@ genMinusDec (iCode * ic)
 	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	      AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
 	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0xff,%05d$"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
+	    emitcode ("cjne", "%s,#!constbyte,!tlabel"
+		      ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE),0xff
 		      ,tlbl->key + 100);
 	  else
 	    {
-	      emitcode ("cjne", "a,%s,%05d$"
+	      emitcode ("cjne", "a,%s,!tlabel"
 		  ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
 			,tlbl->key + 100);
 	    }
@@ -3699,7 +3945,7 @@ genMinusDec (iCode * ic)
 	}
       if (emitTlbl)
 	{
-	  emitcode ("", "%05d$:", tlbl->key + 100);
+	  emitcode ("", "!tlabeldef", tlbl->key + 100);
 	}
       return TRUE;
     }
@@ -3774,18 +4020,18 @@ genMinusBits (iCode * ic)
   if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
     {
       emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
-      emitcode ("jnb", "%s,%05d$", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
+      emitcode ("jnb", "%s,!tlabel", AOP (IC_RIGHT (ic))->aopu.aop_dir, (lbl->key + 100));
       emitcode ("cpl", "c");
-      emitcode ("", "%05d$:", (lbl->key + 100));
+      emitcode ("", "!tlabeldef", (lbl->key + 100));
       outBitC (IC_RESULT (ic));
     }
   else
     {
       emitcode ("mov", "c,%s", AOP (IC_RIGHT (ic))->aopu.aop_dir);
       emitcode ("subb", "a,acc");
-      emitcode ("jnb", "%s,%05d$", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
+      emitcode ("jnb", "%s,!tlabel", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
       emitcode ("inc", "a");
-      emitcode ("", "%05d$:", (lbl->key + 100));
+      emitcode ("", "!tlabeldef", (lbl->key + 100));
       aopPut (AOP (IC_RESULT (ic)), "a", 0);
       addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
     }
@@ -3859,11 +4105,11 @@ genMinus (iCode * ic)
 	    if (!size && lit==-1) {
 	      emitcode ("dec", "a");
 	    } else {
-	      emitcode ("add", "a,#0x%02x",
+	      emitcode ("add", "a,#!constbyte",
 			(unsigned int) (lit & 0x0FFL));
 	    }
 	  } else {
-	    emitcode ("addc", "a,#0x%02x",
+	    emitcode ("addc", "a,#!constbyte",
 		      (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
 	  }
 	}
@@ -3913,10 +4159,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);
 }
 
@@ -3927,18 +4175,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);
 
-  if (size<1 || size>2) {
-    // this should never happen
-      fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n", 
-	       AOP_SIZE(result), __FILE__, lineno);
-      exit (1);
-  }
 
   /* (if two literals: the value is computed before) */
   /* if one literal, literal on the right */
@@ -3959,10 +4201,24 @@ 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");
-    aopPut (AOP (result), "a", 0);
-    if (size==2) {
-      aopPut (AOP (result), "b", 1);
-    }
+   
+    _G.accInUse++; _G.bInUse++;
+    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);
+    _G.accInUse--; _G.bInUse--;
+    if (AOP_SIZE(result)==2) 
+    {
+      aopPut (AOP (result), "b", 1);
+    }
     return;
   }
 
@@ -3973,13 +4229,13 @@ genMultOneByte (operand * left,
   MOVA (aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
 
   lbl=newiTempLabel(NULL);
-  emitcode ("jnb", "acc.7,%05d$",  lbl->key+100);
+  emitcode ("jnb", "acc.7,!tlabel",  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");
 
-  emitcode ("", "%05d$:", lbl->key+100);
+  emitcode ("", "!tlabeldef", lbl->key+100);
 
   /* if literal */
   if (AOP_TYPE(right)==AOP_LIT) {
@@ -3987,28 +4243,39 @@ genMultOneByte (operand * left,
     /* AND literal negative */
     if ((int) val < 0) {
       emitcode ("cpl", "F0"); // complement sign flag
-      emitcode ("mov", "b,#0x%02x", -val);
+      emitcode ("mov", "b,#!constbyte", -val);
     } else {
-      emitcode ("mov", "b,#0x%02x", val);
+      emitcode ("mov", "b,#!constbyte", 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);
+    emitcode ("jnb", "acc.7,!tlabel", 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 ("", "!tlabeldef", lbl->key+100);
   }
   emitcode ("mul", "ab");
     
+  _G.accInUse++;_G.bInUse++;
+  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);
+  emitcode ("jnb", "F0,!tlabel", 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");
@@ -4018,13 +4285,174 @@ genMultOneByte (operand * left,
     emitcode ("xch", "a,b");
   }
 
-  emitcode ("", "%05d$:", lbl->key+100);
+  emitcode ("", "!tlabeldef", lbl->key+100);
   aopPut (AOP (result), "a", 0);
-  if (size==2) {
+  _G.accInUse--;_G.bInUse--;
+  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;
+	}
+	/* save EA bit in F1 */
+	lbl = newiTempLabel(NULL);
+	emitcode ("setb","F1");
+	emitcode ("jbc","EA,!tlabel",lbl->key+100);
+	emitcode ("clr","F1");
+	emitcode("","!tlabeldef",lbl->key+100);
+
+	/* 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,#!constbyte",val & 0xff);
+			emitcode ("mov","mb,#!constbyte",(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,!tlabel",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 ("","!tlabeldef",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,!tlabel",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,!tlabel",lbl->key+100);
+		emitcode ("setb","F0");
+		emitcode ("","!tlabeldef",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("","!tlabeldef", lbl->key+100);
+	emitcode("mov","a,mcnt1");
+	emitcode("anl","a,#!constbyte",0x80);
+	emitcode("jnz","!tlabel",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,!tlabel",lbl->key+100);
+		emitcode("cpl","a");
+		emitcode("add","a,#1");
+		emitcode("","!tlabeldef", 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,!tlabel",lbl->key+100);
+		emitcode("cpl","a");
+		emitcode("addc","a,#0");
+		emitcode("","!tlabeldef", lbl->key+100);
+		aopPut(AOP(result),"a",1);
+		emitcode("pop","acc");
+		if (AOP_SIZE(result) >= 3) {
+			lbl = newiTempLabel(NULL); 	
+			emitcode("jnb","F0,!tlabel",lbl->key+100);
+			emitcode("cpl","a");
+			emitcode("addc","a,#0");			
+			emitcode("","!tlabeldef", lbl->key+100);
+			aopPut(AOP(result),"a",2);
+		}
+		emitcode("pop","acc");
+		if (AOP_SIZE(result) >= 4) {
+			lbl = newiTempLabel(NULL); 	
+			emitcode("jnb","F0,!tlabel",lbl->key+100);
+			emitcode("cpl","a");
+			emitcode("addc","a,#0");			
+			emitcode("","!tlabeldef", 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);
+
+	/* restore EA bit in F1 */
+	lbl = newiTempLabel(NULL);
+	emitcode ("jnb","F1,!tlabel",lbl->key+100);
+	emitcode ("setb","EA");
+	emitcode("","!tlabeldef",lbl->key+100);
+	return ;
+}
+
 /*-----------------------------------------------------------------*/
 /* genMult - generates code for multiplication                     */
 /*-----------------------------------------------------------------*/
@@ -4038,14 +4466,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;
     }
 
@@ -4053,12 +4481,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));
@@ -4072,7 +4505,8 @@ release:
 static void
 genDivbits (operand * left,
 	    operand * right,
-	    operand * result)
+	    operand * result,
+	    iCode   * ic)
 {
 
   char *l;
@@ -4081,6 +4515,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);
 }
 
@@ -4090,24 +4526,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;
     }
 
@@ -4123,10 +4568,10 @@ genDivOneByte (operand * left,
   l = aopGet (AOP (right), 0, FALSE, FALSE, TRUE);
   MOVA (l);
   lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
   emitcode ("cpl", "a");
   emitcode ("inc", "a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
+  emitcode ("", "!tlabeldef", (lbl->key + 100));
   emitcode ("mov", "b,a");
 
   /* sign adjust left side */
@@ -4134,10 +4579,10 @@ genDivOneByte (operand * left,
   MOVA (l);
 
   lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
   emitcode ("cpl", "a");
   emitcode ("inc", "a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
+  emitcode ("", "!tlabeldef", (lbl->key + 100));
 
   /* now the division */
   emitcode ("nop", "; workaround for DS80C390 div bug.");
@@ -4149,24 +4594,150 @@ genDivOneByte (operand * left,
   emitcode ("pop", "acc");
   /* if there was an over flow we don't
      adjust the sign of the result */
-  emitcode ("jb", "ov,%05d$", (lbl->key + 100));
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+  emitcode ("jb", "ov,!tlabel", (lbl->key + 100));
+  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
   CLRC;
   emitcode ("clr", "a");
   emitcode ("subb", "a,b");
   emitcode ("mov", "b,a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
+  emitcode ("", "!tlabeldef", (lbl->key + 100));
 
   /* now we are done */
-  aopPut (AOP (result), "b", 0);
-  if (size > 0)
+  _G.accInUse++;     _G.bInUse++;
+    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--;     _G.bInUse--;
+
+}
+
+/*-----------------------------------------------------------------*/
+/* 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;
+
+	/* save EA bit in F1 */
+	lbl = newiTempLabel(NULL);
+	emitcode ("setb","F1");
+	emitcode ("jbc","EA,!tlabel",lbl->key+100);
+	emitcode ("clr","F1");
+	emitcode("","!tlabeldef",lbl->key+100);
+
+	/* 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,!tlabel",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 ("","!tlabeldef",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,!tlabel",lbl->key+100);
+				emitcode("setb","F0");
+				emitcode ("","!tlabeldef",lbl->key+100);
+				val = -val;
+			} 
+			emitcode ("mov","mb,#!constbyte",val & 0xff);		    
+			emitcode ("mov","mb,#!constbyte",(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,!tlabel",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,!tlabel",lbl->key+100);
+			emitcode ("setb","F0");
+			emitcode ("","!tlabeldef",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("","!tlabeldef", lbl->key+100);
+	emitcode("mov","a,mcnt1");
+	emitcode("anl","a,#!constbyte",0x80);
+	emitcode("jnz","!tlabel",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,!tlabel",lbl->key+100);
+		emitcode("cpl","a");
+		emitcode("add","a,#1");
+		emitcode("","!tlabeldef", lbl->key+100);
+		aopPut(AOP(result),"a",0);
+		emitcode("pop","acc");
+		lbl = newiTempLabel(NULL); 	
+		emitcode("jnb","F0,!tlabel",lbl->key+100);
+		emitcode("cpl","a");
+		emitcode("addc","a,#0");
+		emitcode("","!tlabeldef", lbl->key+100);
+		aopPut(AOP(result),"a",1);
+	}
+	freeAsmop (result, NULL, ic, TRUE);
+	/* restore EA bit in F1 */
+	lbl = newiTempLabel(NULL);
+	emitcode ("jnb","F1,!tlabel",lbl->key+100);
+	emitcode ("setb","EA");
+	emitcode("","!tlabeldef",lbl->key+100);
+	return ;
 }
 
 /*-----------------------------------------------------------------*/
@@ -4179,18 +4750,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;
     }
 
@@ -4198,12 +4768,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));
@@ -4216,7 +4791,8 @@ release:
 static void
 genModbits (operand * left,
 	    operand * right,
-	    operand * result)
+	    operand * result,
+	    iCode   * ic)
 {
 
   char *l;
@@ -4226,6 +4802,7 @@ genModbits (operand * left,
   emitcode ("div", "ab");
   emitcode ("mov", "a,b");
   emitcode ("rrc", "a");
+  aopOp(result, ic, TRUE, FALSE);
   aopPut (AOP (result), "c", 0);
 }
 
@@ -4235,7 +4812,8 @@ genModbits (operand * left,
 static void
 genModOneByte (operand * left,
 	       operand * right,
-	       operand * result)
+	       operand * result,
+	       iCode   * ic)
 {
   sym_link *opetype = operandType (result);
   char *l;
@@ -4247,6 +4825,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;
     }
@@ -4265,10 +4844,10 @@ genModOneByte (operand * left,
   MOVA (l);
 
   lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
   emitcode ("cpl", "a");
   emitcode ("inc", "a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
+  emitcode ("", "!tlabeldef", (lbl->key + 100));
   emitcode ("mov", "b,a");
 
   /* sign adjust left side */
@@ -4276,10 +4855,10 @@ genModOneByte (operand * left,
   MOVA (l);
 
   lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
   emitcode ("cpl", "a");
   emitcode ("inc", "a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
+  emitcode ("", "!tlabeldef", (lbl->key + 100));
 
   /* now the multiplication */
   emitcode ("nop", "; workaround for DS80C390 div bug.");
@@ -4290,17 +4869,110 @@ genModOneByte (operand * left,
   emitcode ("pop", "acc");
   /* if there was an over flow we don't
      adjust the sign of the result */
-  emitcode ("jb", "ov,%05d$", (lbl->key + 100));
-  emitcode ("jnb", "acc.7,%05d$", (lbl->key + 100));
+  emitcode ("jb", "ov,!tlabel", (lbl->key + 100));
+  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
   CLRC;
   emitcode ("clr", "a");
   emitcode ("subb", "a,b");
   emitcode ("mov", "b,a");
-  emitcode ("", "%05d$:", (lbl->key + 100));
-
+  emitcode ("", "!tlabeldef", (lbl->key + 100));
+  
+  _G.bInUse++;
   /* now we are done */
+  aopOp(result, ic, TRUE, FALSE);    
   aopPut (AOP (result), "b", 0);
+  _G.bInUse--;
+
+}
+
+/*-----------------------------------------------------------------*/
+/* 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 */
+	/* save EA bit in F1 */
+	lbl = newiTempLabel(NULL);
+	emitcode ("setb","F1");
+	emitcode ("jbc","EA,!tlabel",lbl->key+100);
+	emitcode ("clr","F1");
+	emitcode("","!tlabeldef",lbl->key+100);
+
+	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,!tlabel",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 ("","!tlabeldef",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,#!constbyte",val & 0xff);
+			emitcode ("mov","mb,#!constbyte",(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,!tlabel",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 ("","!tlabeldef",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("","!tlabeldef", lbl->key+100);
+	emitcode("mov","a,mcnt1");
+	emitcode("anl","a,#!constbyte",0x80);
+	emitcode("jnz","!tlabel",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);
+
+	/* restore EA bit in F1 */
+	lbl = newiTempLabel(NULL);
+	emitcode ("jnb","F1,!tlabel",lbl->key+100);
+	emitcode ("setb","EA");
+	emitcode("","!tlabeldef",lbl->key+100);
+	return ;
 }
 
 /*-----------------------------------------------------------------*/
@@ -4313,18 +4985,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;
     }
 
@@ -4332,12 +5003,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));
@@ -4374,11 +5051,11 @@ genIfxJump (iCode * ic, char *jval)
 	       (strcmp (jval, "c") == 0 ? "jc" : "jb")));
     }
   if (strcmp (inst, "jb") == 0 || strcmp (inst, "jnb") == 0)
-    emitcode (inst, "%s,%05d$", jval, (tlbl->key + 100));
+    emitcode (inst, "%s,!tlabel", jval, (tlbl->key + 100));
   else
-    emitcode (inst, "%05d$", tlbl->key + 100);
-  emitcode ("ljmp", "%05d$", jlbl->key + 100);
-  emitcode ("", "%05d$:", tlbl->key + 100);
+    emitcode (inst, "!tlabel", tlbl->key + 100);
+  emitcode ("ljmp", "!tlabel", jlbl->key + 100);
+  emitcode ("", "!tlabeldef", tlbl->key + 100);
 
   /* mark the icode as generated */
   ic->generated = 1;
@@ -4416,14 +5093,14 @@ genCmp (operand * left, operand * right,
 
       /* if unsigned char cmp with lit, do cjne left,#right,zz */
       if ((size == 1) && !sign &&
-	  (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR))
+	  (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR && AOP_TYPE (left) != AOP_STR))
 	{
 	  symbol *lbl = newiTempLabel (NULL);
-	  emitcode ("cjne", "%s,%s,%05d$",
+	  emitcode ("cjne", "%s,%s,!tlabel",
 		    aopGet (AOP (left), offset, FALSE, FALSE, FALSE),
 		    aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
 		    lbl->key + 100);
-	  emitcode ("", "%05d$:", lbl->key + 100);
+	  emitcode ("", "!tlabeldef", lbl->key + 100);
 	}
       else
 	{
@@ -4464,31 +5141,31 @@ genCmp (operand * left, operand * right,
 	  CLRC;
 	  while (size--)
 	    {
-	      emitcode (";", "genCmp #1: %d/%d/%d", size, sign, offset);
+	      //emitcode (";", "genCmp #1: %d/%d/%d", size, sign, offset);
 	      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
-	      emitcode (";", "genCmp #2");
+	      //emitcode (";", "genCmp #2");
 	      if (sign && (size == 0))
 		{
-		  emitcode (";", "genCmp #3");
-		  emitcode ("xrl", "a,#0x80");
+		    //emitcode (";", "genCmp #3");
+		  emitcode ("xrl", "a,#!constbyte",0x80);
 		  if (AOP_TYPE (right) == AOP_LIT)
 		    {
 		      unsigned long lit = (unsigned long)
 		      floatFromVal (AOP (right)->aopu.aop_lit);
-		      emitcode (";", "genCmp #3.1");
-		      emitcode ("subb", "a,#0x%02x",
+		      //emitcode (";", "genCmp #3.1");
+		      emitcode ("subb", "a,#!constbyte",
 				0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
 		    }
 		  else
 		    {
-		      emitcode (";", "genCmp #3.2");
+		      //emitcode (";", "genCmp #3.2");
 		      if (AOP_NEEDSACC (right))
 			{
 			  emitcode ("push", "acc");
 			}
 		      emitcode ("mov", "b,%s", aopGet (AOP (right), offset++,
 						       FALSE, FALSE, FALSE));
-		      emitcode ("xrl", "b,#0x80");
+		      emitcode ("xrl", "b,#!constbyte",0x80);
 		      if (AOP_NEEDSACC (right))
 			{
 			  emitcode ("pop", "acc");
@@ -4500,11 +5177,11 @@ genCmp (operand * left, operand * right,
 		{
 		  const char *s;
 
-		  emitcode (";", "genCmp #4");
+		  //emitcode (";", "genCmp #4");
 		  if (AOP_NEEDSACC (right))
 		    {
 		      /* Yuck!! */
-		      emitcode (";", "genCmp #4.1");
+		      //emitcode (";", "genCmp #4.1");
 		      emitcode ("xch", "a, b");
 		      MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, TRUE));
 		      emitcode ("xch", "a, b");
@@ -4512,7 +5189,7 @@ genCmp (operand * left, operand * right,
 		    }
 		  else
 		    {
-		      emitcode (";", "genCmp #4.2");
+		      //emitcode (";", "genCmp #4.2");
 		      s = aopGet (AOP (right), offset++, FALSE, FALSE, FALSE);
 		    }
 
@@ -4650,7 +5327,7 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
 	{
 	  char *l = aopGet (AOP (left), offset, FALSE, FALSE, TRUE);
 	  MOVA (l);
-	  emitcode ("cjne", "a,%s,%05d$",
+	  emitcode ("cjne", "a,%s,!tlabel",
 		    aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
 		    lbl->key + 100);
 	  offset++;
@@ -4669,9 +5346,9 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
 	  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
 	  if ((AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) &&
 	      ((unsigned int) ((lit >> (offset * 8)) & 0x0FFL) == 0))
-	    emitcode ("jnz", "%05d$", lbl->key + 100);
+	    emitcode ("jnz", "!tlabel", lbl->key + 100);
 	  else
-	    emitcode ("cjne", "a,%s,%05d$",
+	    emitcode ("cjne", "a,%s,!tlabel",
 		      aopGet (AOP (right), offset, FALSE, TRUE, FALSE),
 		      lbl->key + 100);
 	  offset++;
@@ -4686,7 +5363,7 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
 	  if (strcmp (l, "b"))
 	    emitcode ("mov", "b,%s", l);
 	  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-	  emitcode ("cjne", "a,b,%05d$", lbl->key + 100);
+	  emitcode ("cjne", "a,b,!tlabel", lbl->key + 100);
 	  offset++;
 	}
     }
@@ -4706,10 +5383,10 @@ gencjne (operand * left, operand * right, symbol * lbl)
   gencjneshort (left, right, lbl);
 
   emitcode ("mov", "a,%s", one);
-  emitcode ("sjmp", "%05d$", tlbl->key + 100);
-  emitcode ("", "%05d$:", lbl->key + 100);
+  emitcode ("sjmp", "!tlabel", tlbl->key + 100);
+  emitcode ("", "!tlabeldef", lbl->key + 100);
   emitcode ("clr", "a");
-  emitcode ("", "%05d$:", tlbl->key + 100);
+  emitcode ("", "!tlabeldef", tlbl->key + 100);
 }
 
 /*-----------------------------------------------------------------*/
@@ -4768,24 +5445,24 @@ genCmpEq (iCode * ic, iCode * ifx)
 	    {
 	      symbol *lbl = newiTempLabel (NULL);
 	      emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-	      emitcode ("jb", "%s,%05d$", AOP (right)->aopu.aop_dir, (lbl->key + 100));
+	      emitcode ("jb", "%s,!tlabel", AOP (right)->aopu.aop_dir, (lbl->key + 100));
 	      emitcode ("cpl", "c");
-	      emitcode ("", "%05d$:", (lbl->key + 100));
+	      emitcode ("", "!tlabeldef", (lbl->key + 100));
 	    }
 	  /* if true label then we jump if condition
 	     supplied is true */
 	  tlbl = newiTempLabel (NULL);
 	  if (IC_TRUE (ifx))
 	    {
-	      emitcode ("jnc", "%05d$", tlbl->key + 100);
-	      emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
+	      emitcode ("jnc", "!tlabel", tlbl->key + 100);
+	      emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
 	    }
 	  else
 	    {
-	      emitcode ("jc", "%05d$", tlbl->key + 100);
-	      emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100);
+	      emitcode ("jc", "!tlabel", tlbl->key + 100);
+	      emitcode ("ljmp", "!tlabel", IC_FALSE (ifx)->key + 100);
 	    }
-	  emitcode ("", "%05d$:", tlbl->key + 100);
+	  emitcode ("", "!tlabeldef", tlbl->key + 100);
 	}
       else
 	{
@@ -4793,16 +5470,16 @@ genCmpEq (iCode * ic, iCode * ifx)
 	  gencjneshort (left, right, tlbl);
 	  if (IC_TRUE (ifx))
 	    {
-	      emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
-	      emitcode ("", "%05d$:", tlbl->key + 100);
+	      emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
+	      emitcode ("", "!tlabeldef", tlbl->key + 100);
 	    }
 	  else
 	    {
 	      symbol *lbl = newiTempLabel (NULL);
-	      emitcode ("sjmp", "%05d$", lbl->key + 100);
-	      emitcode ("", "%05d$:", tlbl->key + 100);
-	      emitcode ("ljmp", "%05d$", IC_FALSE (ifx)->key + 100);
-	      emitcode ("", "%05d$:", lbl->key + 100);
+	      emitcode ("sjmp", "!tlabel", lbl->key + 100);
+	      emitcode ("", "!tlabeldef", tlbl->key + 100);
+	      emitcode ("ljmp", "!tlabel", IC_FALSE (ifx)->key + 100);
+	      emitcode ("", "!tlabeldef", lbl->key + 100);
 	    }
 	}
       /* mark the icode as generated */
@@ -4839,9 +5516,9 @@ genCmpEq (iCode * ic, iCode * ifx)
 	{
 	  symbol *lbl = newiTempLabel (NULL);
 	  emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-	  emitcode ("jb", "%s,%05d$", AOP (right)->aopu.aop_dir, (lbl->key + 100));
+	  emitcode ("jb", "%s,!tlabel", AOP (right)->aopu.aop_dir, (lbl->key + 100));
 	  emitcode ("cpl", "c");
-	  emitcode ("", "%05d$:", (lbl->key + 100));
+	  emitcode ("", "!tlabeldef", (lbl->key + 100));
 	}
 
       freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
@@ -4915,6 +5592,43 @@ ifxForOp (operand * op, iCode * ic)
 
   return NULL;
 }
+/*-----------------------------------------------------------------*/
+/* hasInc - operand is incremented before any other use            */
+/*-----------------------------------------------------------------*/
+static iCode *
+hasInc (operand *op, iCode *ic, int osize)
+{
+  sym_link *type = operandType(op);
+  sym_link *retype = getSpec (type);
+  iCode *lic = ic->next;
+  int isize ;
+  
+  /* this could from a cast, e.g.: "(char xdata *) 0x7654;" */
+  if (!IS_SYMOP(op)) return NULL;
+
+  if (IS_BITVAR(retype)||!IS_PTR(type)) return NULL;
+  if (IS_AGGREGATE(type->next)) return NULL;
+  if (osize != (isize = getSize(type->next))) return NULL;
+
+  while (lic) {
+      /* if operand of the form op = op + <sizeof *op> */
+      if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) &&
+	  isOperandEqual(IC_RESULT(lic),op) && 
+	  isOperandLiteral(IC_RIGHT(lic)) &&
+	  operandLitValue(IC_RIGHT(lic)) == isize) {
+	  return lic;
+      }
+      /* if the operand used or deffed */
+      if (bitVectBitValue(OP_USES(op),lic->key) || (unsigned) lic->defKey == op->key) {
+	  return NULL;
+      }
+      /* if GOTO or IFX */
+      if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break;
+      lic = lic->next;
+  }
+  return NULL;
+}
+
 /*-----------------------------------------------------------------*/
 /* genAndOp - for && operation                                     */
 /*-----------------------------------------------------------------*/
@@ -4948,9 +5662,9 @@ genAndOp (iCode * ic)
     {
       tlbl = newiTempLabel (NULL);
       toBoolean (left);
-      emitcode ("jz", "%05d$", tlbl->key + 100);
+      emitcode ("jz", "!tlabel", tlbl->key + 100);
       toBoolean (right);
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
       freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   
@@ -4995,9 +5709,9 @@ genOrOp (iCode * ic)
     {
       tlbl = newiTempLabel (NULL);
       toBoolean (left);
-      emitcode ("jnz", "%05d$", tlbl->key + 100);
+      emitcode ("jnz", "!tlabel", tlbl->key + 100);
       toBoolean (right);
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
       freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
   
@@ -5038,7 +5752,7 @@ static void
 continueIfTrue (iCode * ic)
 {
   if (IC_TRUE (ic))
-    emitcode ("ljmp", "%05d$", IC_TRUE (ic)->key + 100);
+    emitcode ("ljmp", "!tlabel", IC_TRUE (ic)->key + 100);
   ic->generated = 1;
 }
 
@@ -5049,7 +5763,7 @@ static void
 jumpIfTrue (iCode * ic)
 {
   if (!IC_TRUE (ic))
-    emitcode ("ljmp", "%05d$", IC_FALSE (ic)->key + 100);
+    emitcode ("ljmp", "!tlabel", IC_FALSE (ic)->key + 100);
   ic->generated = 1;
 }
 
@@ -5063,15 +5777,15 @@ jmpTrueOrFalse (iCode * ic, symbol * tlbl)
   if (IC_TRUE (ic))
     {
       symbol *nlbl = newiTempLabel (NULL);
-      emitcode ("sjmp", "%05d$", nlbl->key + 100);
-      emitcode ("", "%05d$:", tlbl->key + 100);
-      emitcode ("ljmp", "%05d$", IC_TRUE (ic)->key + 100);
-      emitcode ("", "%05d$:", nlbl->key + 100);
+      emitcode ("sjmp", "!tlabel", nlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
+      emitcode ("ljmp", "!tlabel", IC_TRUE (ic)->key + 100);
+      emitcode ("", "!tlabeldef", nlbl->key + 100);
     }
   else
     {
-      emitcode ("ljmp", "%05d$", IC_FALSE (ic)->key + 100);
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("ljmp", "!tlabel", IC_FALSE (ic)->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
     }
   ic->generated = 1;
 }
@@ -5157,8 +5871,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;
@@ -5282,13 +5999,13 @@ genAnd (iCode * ic, iCode * ifx)
 		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
 		  // byte ==  2^n ?
 		  if ((posbit = isLiteralBit (bytelit)) != 0)
-		    emitcode ("jb", "acc.%d,%05d$", (posbit - 1) & 0x07, tlbl->key + 100);
+		    emitcode ("jb", "acc.%d,!tlabel", (posbit - 1) & 0x07, tlbl->key + 100);
 		  else
 		    {
 		      if (bytelit != 0x0FFL)
 			emitcode ("anl", "a,%s",
 			  aopGet (AOP (right), offset, FALSE, TRUE, FALSE));
-		      emitcode ("jnz", "%05d$", tlbl->key + 100);
+		      emitcode ("jnz", "!tlabel", tlbl->key + 100);
 		    }
 		}
 	      offset++;
@@ -5297,7 +6014,7 @@ genAnd (iCode * ic, iCode * ifx)
 	  if (size)
 	    {
 	      emitcode ("clr", "c");
-	      emitcode ("", "%05d$:", tlbl->key + 100);
+	      emitcode ("", "!tlabeldef", tlbl->key + 100);
 	    }
 	  // if(left & literal)
 	  else
@@ -5381,13 +6098,13 @@ genAnd (iCode * ic, iCode * ifx)
 			    aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
 		}
 	      }
-	      emitcode ("jnz", "%05d$", tlbl->key + 100);
+	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
 	      offset++;
 	    }
 	  if (size)
 	    {
 	      CLRC;
-	      emitcode ("", "%05d$:", tlbl->key + 100);
+	      emitcode ("", "!tlabeldef", tlbl->key + 100);
 	      outBitC (result);
 	    }
 	  else if (ifx)
@@ -5413,8 +6130,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));
@@ -5431,10 +6147,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);
 	    }
@@ -5481,8 +6203,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;
@@ -5552,10 +6277,10 @@ genOr (iCode * ic, iCode * ifx)
 	      symbol *tlbl = newiTempLabel (NULL);
 	      if (!((AOP_TYPE (result) == AOP_CRY) && ifx))
 		emitcode ("setb", "c");
-	      emitcode ("jb", "%s,%05d$",
+	      emitcode ("jb", "%s,!tlabel",
 			AOP (left)->aopu.aop_dir, tlbl->key + 100);
 	      toBoolean (right);
-	      emitcode ("jnz", "%05d$", tlbl->key + 100);
+	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
 	      if ((AOP_TYPE (result) == AOP_CRY) && ifx)
 		{
 		  jmpTrueOrFalse (ifx, tlbl);
@@ -5564,7 +6289,7 @@ genOr (iCode * ic, iCode * ifx)
 	      else
 		{
 		  CLRC;
-		  emitcode ("", "%05d$:", tlbl->key + 100);
+		  emitcode ("", "!tlabeldef", tlbl->key + 100);
 		}
 	    }
 	}
@@ -5602,9 +6327,9 @@ genOr (iCode * ic, iCode * ifx)
 	  if (size)
 	    {
 	      symbol *tlbl = newiTempLabel (NULL);
-	      emitcode ("jnz", "%05d$", tlbl->key + 100);
+	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
 	      CLRC;
-	      emitcode ("", "%05d$:", tlbl->key + 100);
+	      emitcode ("", "!tlabeldef", tlbl->key + 100);
 	    }
 	  else
 	    {
@@ -5688,13 +6413,13 @@ genOr (iCode * ic, iCode * ifx)
 		emitcode ("orl", "a,%s",
 			  aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
 	      }
-	      emitcode ("jnz", "%05d$", tlbl->key + 100);
+	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
 	      offset++;
 	    }
 	  if (size)
 	    {
 	      CLRC;
-	      emitcode ("", "%05d$:", tlbl->key + 100);
+	      emitcode ("", "!tlabeldef", tlbl->key + 100);
 	      outBitC (result);
 	    }
 	  else if (ifx)
@@ -5702,6 +6427,7 @@ genOr (iCode * ic, iCode * ifx)
 	}
       else
 	{
+	    _startLazyDPSEvaluation();
 	  for (; (size--); offset++)
 	    {
 	      // normal case
@@ -5715,8 +6441,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));
@@ -5733,13 +6458,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();
 	}
     }
 
@@ -5782,8 +6515,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;
@@ -5878,16 +6614,16 @@ genXor (iCode * ic, iCode * ifx)
 		  MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE, TRUE));
 		  if (sizer == 1)
 		    // test the msb of the lsb
-		    emitcode ("anl", "a,#0xfe");
-		  emitcode ("jnz", "%05d$", tlbl->key + 100);
+		    emitcode ("anl", "a,#!constbyte",0xfe);
+		  emitcode ("jnz", "!tlabel", tlbl->key + 100);
 		  sizer--;
 		}
 	      // val = (0,1)
 	      emitcode ("rrc", "a");
 	    }
-	  emitcode ("jnb", "%s,%05d$", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
+	  emitcode ("jnb", "%s,!tlabel", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
 	  emitcode ("cpl", "c");
-	  emitcode ("", "%05d$:", (tlbl->key + 100));
+	  emitcode ("", "!tlabeldef", (tlbl->key + 100));
 	}
       // bit = c
       // val = c
@@ -5948,6 +6684,7 @@ genXor (iCode * ic, iCode * ifx)
 	  // if(!size && ifx), conditional oper: if(left ^ right)
 	  symbol *tlbl = newiTempLabel (NULL);
 	  int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
+	          
 	  if (size)
 	    emitcode ("setb", "c");
 	  while (sizer--)
@@ -5963,24 +6700,31 @@ genXor (iCode * ic, iCode * ifx)
 		    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));
+		      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);		      
 		  }
 		}
-	      emitcode ("jnz", "%05d$", tlbl->key + 100);
+	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
 	      offset++;
 	    }
 	  if (size)
 	    {
 	      CLRC;
-	      emitcode ("", "%05d$:", tlbl->key + 100);
+	      emitcode ("", "!tlabeldef", tlbl->key + 100);
 	      outBitC (result);
 	    }
 	  else if (ifx)
 	    jmpTrueOrFalse (ifx, tlbl);
 	}
       else
+	{
 	for (; (size--); offset++)
 	  {
 	    // normal case
@@ -5994,8 +6738,7 @@ genXor (iCode * ic, iCode * ifx)
 			    offset);
 		    continue;
 		  }
-		D (emitcode (";", "better literal XOR.");
-		  );
+		D (emitcode (";", "better literal XOR."););
 		MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
 		emitcode ("xrl", "a, %s", aopGet (AOP (right), offset,
 						  FALSE, FALSE, FALSE));
@@ -6011,13 +6754,21 @@ 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);
 	  }
+	}
+	
     }
 
 release:
@@ -6200,7 +6951,7 @@ genGetHbit (iCode * ic)
   else
     {
       emitcode ("rl", "a");
-      emitcode ("anl", "a,#0x01");
+      emitcode ("anl", "a,#1");
       outAcc (result);
     }
 
@@ -6269,7 +7020,7 @@ AccLsh (int shCount)
 	  /* rotate left accumulator */
 	  AccRol (shCount);
 	  /* and kill the lower order bits */
-	  emitcode ("anl", "a,#0x%02x", SLMask[shCount]);
+	  emitcode ("anl", "a,#!constbyte", SLMask[shCount]);
 	}
     }
 }
@@ -6292,7 +7043,7 @@ AccRsh (int shCount)
 	  /* rotate right accumulator */
 	  AccRol (8 - shCount);
 	  /* and kill the higher order bits */
-	  emitcode ("anl", "a,#0x%02x", SRMask[shCount]);
+	  emitcode ("anl", "a,#!constbyte", SRMask[shCount]);
 	}
     }
 }
@@ -6325,11 +7076,11 @@ AccSRsh (int shCount)
 	  /* rotate right accumulator */
 	  AccRol (8 - shCount);
 	  /* and kill the higher order bits */
-	  emitcode ("anl", "a,#0x%02x", SRMask[shCount]);
-	  emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
-	  emitcode ("orl", "a,#0x%02x",
+	  emitcode ("anl", "a,#!constbyte", SRMask[shCount]);
+	  emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+	  emitcode ("orl", "a,#!constbyte",
 		    (unsigned char) ~SRMask[shCount]);
-	  emitcode ("", "%05d$:", tlbl->key + 100);
+	  emitcode ("", "!tlabeldef", tlbl->key + 100);
 	}
     }
 }
@@ -6474,7 +7225,7 @@ AccAXLsh (char *x, int shCount)
 
       AccRol (shCount);		// BBBAAAAA:CCCCCDDD
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SLMask[shCount]);	// BBB00000:CCCCCDDD
 
       emitcode ("xch", "a,%s", x);	// CCCCCDDD:BBB00000
@@ -6487,7 +7238,7 @@ AccAXLsh (char *x, int shCount)
 
       emitcode ("xch", "a,%s", x);	// DDDCCCCC:(BBB^DDD)CCCCC
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SLMask[shCount]);	// DDD00000:(BBB^DDD)CCCCC
 
       emitcode ("xch", "a,%s", x);	// (BBB^DDD)CCCCC:DDD00000
@@ -6496,7 +7247,7 @@ AccAXLsh (char *x, int shCount)
 
       break;
     case 6:			// AAAAAABB:CCCCCCDD
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 000000BB:CCCCCCDD
       emitcode ("mov", "c,acc.0");	// c = B
       emitcode ("xch", "a,%s", x);	// CCCCCCDD:000000BB
@@ -6518,7 +7269,7 @@ AccAXLsh (char *x, int shCount)
       break;
     case 7:			// a:x <<= 7
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 0000000B:CCCCCCCD
 
       emitcode ("mov", "c,acc.0");	// c = B
@@ -6569,14 +7320,14 @@ AccAXRsh (char *x, int shCount)
 
       AccRol (8 - shCount);	// DDDCCCCC:BBBAAAAA
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 000CCCCC:BBBAAAAA
 
       emitcode ("xrl", "a,%s", x);	// BBB(CCCCC^AAAAA):BBBAAAAA
 
       emitcode ("xch", "a,%s", x);	// BBBAAAAA:BBB(CCCCC^AAAAA)
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 000AAAAA:BBB(CCCCC^AAAAA)
 
       emitcode ("xch", "a,%s", x);	// BBB(CCCCC^AAAAA):000AAAAA
@@ -6595,7 +7346,7 @@ AccAXRsh (char *x, int shCount)
 
       emitcode ("xch", "a,%s", x);	// DDDDDDAA:BBBBBBCC
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 000000AA:BBBBBBCC
 
       break;
@@ -6607,7 +7358,7 @@ AccAXRsh (char *x, int shCount)
 
       emitcode ("xch", "a,%s", x);	// DDDDDDDA:BBBBBBCC
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 0000000A:BBBBBBBC
 
       break;
@@ -6653,14 +7404,14 @@ AccAXRshS (char *x, int shCount)
 
       AccRol (8 - shCount);	// DDDCCCCC:BBBAAAAA
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 000CCCCC:BBBAAAAA
 
       emitcode ("xrl", "a,%s", x);	// BBB(CCCCC^AAAAA):BBBAAAAA
 
       emitcode ("xch", "a,%s", x);	// BBBAAAAA:BBB(CCCCC^AAAAA)
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 000AAAAA:BBB(CCCCC^AAAAA)
 
       emitcode ("xch", "a,%s", x);	// BBB(CCCCC^AAAAA):000AAAAA
@@ -6669,11 +7420,11 @@ AccAXRshS (char *x, int shCount)
 
       emitcode ("xch", "a,%s", x);	// 000SAAAA:BBBCCCCC
 
-      emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
-      emitcode ("orl", "a,#0x%02x",
+      emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+      emitcode ("orl", "a,#!constbyte",
 		(unsigned char) ~SRMask[shCount]);	// 111AAAAA:BBBCCCCC
 
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       break;			// SSSSAAAA:BBBCCCCC
 
     case 6:			// AABBBBBB:CCDDDDDD
@@ -6686,14 +7437,14 @@ AccAXRshS (char *x, int shCount)
 
       emitcode ("xch", "a,%s", x);	// DDDDDDAA:BBBBBBCC
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 000000AA:BBBBBBCC
 
-      emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
-      emitcode ("orl", "a,#0x%02x",
+      emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+      emitcode ("orl", "a,#!constbyte",
 		(unsigned char) ~SRMask[shCount]);	// 111111AA:BBBBBBCC
 
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       break;
     case 7:			// ABBBBBBB:CDDDDDDD
 
@@ -6704,14 +7455,14 @@ AccAXRshS (char *x, int shCount)
 
       emitcode ("xch", "a,%s", x);	// DDDDDDDA:BBBBBBCC
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		SRMask[shCount]);	// 0000000A:BBBBBBBC
 
-      emitcode ("jnb", "acc.%d,%05d$", 7 - shCount, tlbl->key + 100);
-      emitcode ("orl", "a,#0x%02x",
+      emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+      emitcode ("orl", "a,#!constbyte",
 		(unsigned char) ~SRMask[shCount]);	// 1111111A:BBBBBBBC
 
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       break;
     default:
       break;
@@ -7161,7 +7912,7 @@ genLeftShiftLiteral (operand * left,
   aopOp(left, ic, FALSE, FALSE);
   aopOp(result, ic, FALSE, (AOP_TYPE(left) == AOP_DPTR));
 
-#if 1 // debug spew
+#if 0 // debug spew
   if (IS_SYMOP(left) && OP_SYMBOL(left)->aop)
   {
   	emitcode(";", "left (%s) is %d", OP_SYMBOL(left)->rname, AOP_TYPE(left));
@@ -7275,7 +8026,7 @@ genLeftShift (iCode * ic)
        * but since I'm too lazy to fix that today, at least we can make
        * some small improvement.
        */
-       emitcode("mov", "b,#0x%02x",
+       emitcode("mov", "b,#!constbyte",
        	        ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
   }
   else
@@ -7324,19 +8075,19 @@ genLeftShift (iCode * ic)
 
       l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
       MOVA (l);
-      emitcode ("sjmp", "%05d$", tlbl1->key + 100);
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       emitcode ("add", "a,acc");
-      emitcode ("", "%05d$:", tlbl1->key + 100);
-      emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl1->key + 100);
+      emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
       aopPut (AOP (result), "a", 0);
       goto release;
     }
 
   reAdjustPreg (AOP (result));
 
-  emitcode ("sjmp", "%05d$", tlbl1->key + 100);
-  emitcode ("", "%05d$:", tlbl->key + 100);
+  emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+  emitcode ("", "!tlabeldef", tlbl->key + 100);
   l = aopGet (AOP (result), offset, FALSE, FALSE, TRUE);
   MOVA (l);
   emitcode ("add", "a,acc");
@@ -7352,8 +8103,8 @@ genLeftShift (iCode * ic)
   _endLazyDPSEvaluation ();
   reAdjustPreg (AOP (result));
 
-  emitcode ("", "%05d$:", tlbl1->key + 100);
-  emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+  emitcode ("", "!tlabeldef", tlbl1->key + 100);
+  emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
 release:
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
@@ -7675,7 +8426,7 @@ genSignedRightShift (iCode * ic)
        * but since I'm too lazy to fix that today, at least we can make
        * some small improvement.
        */
-       emitcode("mov", "b,#0x%02x",
+       emitcode("mov", "b,#!constbyte",
        	        ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
   }
   else
@@ -7726,19 +8477,19 @@ genSignedRightShift (iCode * ic)
     {
       l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
       MOVA (l);
-      emitcode ("sjmp", "%05d$", tlbl1->key + 100);
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       emitcode ("mov", "c,ov");
       emitcode ("rrc", "a");
-      emitcode ("", "%05d$:", tlbl1->key + 100);
-      emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl1->key + 100);
+      emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
       aopPut (AOP (result), "a", 0);
       goto release;
     }
 
   reAdjustPreg (AOP (result));
-  emitcode ("sjmp", "%05d$", tlbl1->key + 100);
-  emitcode ("", "%05d$:", tlbl->key + 100);
+  emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+  emitcode ("", "!tlabeldef", tlbl->key + 100);
   emitcode ("mov", "c,ov");
   _startLazyDPSEvaluation ();
   while (size--)
@@ -7750,8 +8501,8 @@ genSignedRightShift (iCode * ic)
     }
   _endLazyDPSEvaluation ();
   reAdjustPreg (AOP (result));
-  emitcode ("", "%05d$:", tlbl1->key + 100);
-  emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+  emitcode ("", "!tlabeldef", tlbl1->key + 100);
+  emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
 
 release:
   freeAsmop (left, NULL, ic, TRUE);
@@ -7819,7 +8570,7 @@ genRightShift (iCode * ic)
        * but since I'm too lazy to fix that today, at least we can make
        * some small improvement.
        */
-       emitcode("mov", "b,#0x%02x",
+       emitcode("mov", "b,#!constbyte",
        	        ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
   }
   else
@@ -7866,19 +8617,19 @@ genRightShift (iCode * ic)
     {
       l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
       MOVA (l);
-      emitcode ("sjmp", "%05d$", tlbl1->key + 100);
-      emitcode ("", "%05d$:", tlbl->key + 100);
+      emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+      emitcode ("", "!tlabeldef", tlbl->key + 100);
       CLRC;
       emitcode ("rrc", "a");
-      emitcode ("", "%05d$:", tlbl1->key + 100);
-      emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+      emitcode ("", "!tlabeldef", tlbl1->key + 100);
+      emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
       aopPut (AOP (result), "a", 0);
       goto release;
     }
 
   reAdjustPreg (AOP (result));
-  emitcode ("sjmp", "%05d$", tlbl1->key + 100);
-  emitcode ("", "%05d$:", tlbl->key + 100);
+  emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
+  emitcode ("", "!tlabeldef", tlbl->key + 100);
   CLRC;
   _startLazyDPSEvaluation ();
   while (size--)
@@ -7891,8 +8642,8 @@ genRightShift (iCode * ic)
   _endLazyDPSEvaluation ();
   reAdjustPreg (AOP (result));
 
-  emitcode ("", "%05d$:", tlbl1->key + 100);
-  emitcode ("djnz", "b,%05d$", tlbl->key + 100);
+  emitcode ("", "!tlabeldef", tlbl1->key + 100);
+  emitcode ("djnz", "b,!tlabel", tlbl->key + 100);
 
 release:
   freeAsmop (left, NULL, ic, TRUE);
@@ -7952,7 +8703,7 @@ genUnpackBits (operand * result, char *rname, int ptype)
       /* shift right acc */
       AccRsh (shCnt);
 
-      emitcode ("anl", "a,#0x%02x",
+      emitcode ("anl", "a,#!constbyte",
 		((unsigned char) -1) >> (8 - SPEC_BLEN (etype)));
       aopPut (AOP (result), "a", offset);
       return;
@@ -8006,7 +8757,7 @@ genUnpackBits (operand * result, char *rname, int ptype)
 
   if (rlen)
     {
-      emitcode ("anl", "a,#0x%02x", ((unsigned char) -1) >> (rlen));
+      emitcode ("anl", "a,#!constbyte", ((unsigned char) -1) >> (rlen));
       aopPut (AOP (result), "a", offset);
     }
 
@@ -8051,7 +8802,8 @@ genDataPointerGet (operand * left,
 static void
 genNearPointerGet (operand * left,
 		   operand * result,
-		   iCode * ic)
+		   iCode * ic,
+		   iCode *pi)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -8120,7 +8872,7 @@ genNearPointerGet (operand * left,
 	      aopPut (AOP (result), buffer, offset);
 	    }
 	  offset++;
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "%s", rname);
 	}
     }
@@ -8129,6 +8881,9 @@ genNearPointerGet (operand * left,
   if (aop)
     {
       /* we had to allocate for this iCode */
+      if (pi) { /* post increment present */
+	aopPut(AOP ( left ),rname,0);
+      }
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -8141,7 +8896,8 @@ genNearPointerGet (operand * left,
       if (AOP_SIZE (result) > 1 &&
 	  !OP_SYMBOL (left)->remat &&
 	  (OP_SYMBOL (left)->liveTo > ic->seq ||
-	   ic->depth))
+	   ic->depth) &&
+	  !pi)
 	{
 	  int size = AOP_SIZE (result) - 1;
 	  while (size--)
@@ -8151,7 +8907,7 @@ genNearPointerGet (operand * left,
 
   /* done */
   freeAsmop (result, NULL, ic, TRUE);
-
+  if (pi) pi->generated = 1;
 }
 
 /*-----------------------------------------------------------------*/
@@ -8160,7 +8916,8 @@ genNearPointerGet (operand * left,
 static void
 genPagedPointerGet (operand * left,
 		    operand * result,
-		    iCode * ic)
+		    iCode * ic,
+		    iCode * pi)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -8207,7 +8964,7 @@ genPagedPointerGet (operand * left,
 
 	  offset++;
 
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "%s", rname);
 	}
     }
@@ -8216,6 +8973,7 @@ genPagedPointerGet (operand * left,
   if (aop)
     {
       /* we had to allocate for this iCode */
+      if (pi) aopPut ( AOP (left), rname, 0);
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -8228,7 +8986,8 @@ genPagedPointerGet (operand * left,
       if (AOP_SIZE (result) > 1 &&
 	  !OP_SYMBOL (left)->remat &&
 	  (OP_SYMBOL (left)->liveTo > ic->seq ||
-	   ic->depth))
+	   ic->depth) &&
+	  !pi)
 	{
 	  int size = AOP_SIZE (result) - 1;
 	  while (size--)
@@ -8238,8 +8997,7 @@ genPagedPointerGet (operand * left,
 
   /* done */
   freeAsmop (result, NULL, ic, TRUE);
-
-
+  if (pi) pi->generated = 1;
 }
 
 /*-----------------------------------------------------------------*/
@@ -8247,9 +9005,9 @@ genPagedPointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genFarPointerGet (operand * left,
-		  operand * result, iCode * ic)
+		  operand * result, iCode * ic, iCode *pi)
 {
-  int size, offset;
+    int size, offset, dopi=1;
   sym_link *retype = getSpec (operandType (result));
   sym_link *letype = getSpec (operandType (left));
   D (emitcode (";", "genFarPointerGet");
@@ -8288,12 +9046,12 @@ genFarPointerGet (operand * left,
 		emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
+	      dopi =0;
 	    }
 	  _endLazyDPSEvaluation ();
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE, TRUE);
 
   /* if bit then unpack */
@@ -8312,14 +9070,27 @@ genFarPointerGet (operand * left,
 	  _flushLazyDPS ();
 
 	  emitcode ("movx", "a,@dptr");
-	  if (size)
+	  if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
 	    emitcode ("inc", "dptr");
 
 	  aopPut (AOP (result), "a", offset++);
 	}
       _endLazyDPSEvaluation ();
     }
+  if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) {
+    aopPut ( AOP (left), "dpl", 0);
+    aopPut ( AOP (left), "dph", 1);
+    if (options.model == MODEL_FLAT24)
+	    aopPut ( AOP (left), "dpx", 2);
+    pi->generated = 1;
+  } else if (OP_SYMBOL(left)->ruonly && AOP_SIZE(result) > 1 &&
+	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+      
+      size = AOP_SIZE (result) - 1;
+      while (size--) emitcode ("lcall","__decdptr");
+  }
 
+  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -8328,9 +9099,9 @@ genFarPointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 emitcodePointerGet (operand * left,
-		    operand * result, iCode * ic)
+		    operand * result, iCode * ic, iCode *pi)
 {
-  int size, offset;
+  int size, offset, dopi=1;
   sym_link *retype = getSpec (operandType (result));
 
   aopOp (left, ic, FALSE, FALSE);
@@ -8365,12 +9136,12 @@ emitcodePointerGet (operand * left,
 	        emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
+	      dopi=0;
 	    }
 	  _endLazyDPSEvaluation ();
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE, TRUE);
 
   /* if bit then unpack */
@@ -8389,13 +9160,26 @@ emitcodePointerGet (operand * left,
 
 	  emitcode ("clr", "a");
 	  emitcode ("movc", "a,@a+dptr");
-	  if (size)
+	  if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
 	    emitcode ("inc", "dptr");
 	  aopPut (AOP (result), "a", offset++);
 	}
       _endLazyDPSEvaluation ();
     }
-
+  if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) {
+      aopPut ( AOP (left), "dpl", 0);
+      aopPut ( AOP (left), "dph", 1);
+      if (options.model == MODEL_FLAT24)
+	  aopPut ( AOP (left), "dpx", 2);
+      pi->generated = 1;
+  } else if (OP_SYMBOL(left)->ruonly && AOP_SIZE(result) > 1 &&
+	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+      
+      size = AOP_SIZE (result) - 1;
+      while (size--) emitcode ("lcall","__decdptr");
+  }
+  
+  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -8404,7 +9188,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));
@@ -8412,7 +9196,7 @@ genGenPointerGet (operand * left,
 
   D (emitcode (";", "genGenPointerGet "); );
 
-  aopOp (left, ic, FALSE, TRUE);
+  aopOp (left, ic, FALSE, (OP_SYMBOL(left)->ruonly ? FALSE : TRUE));
 
   /* if the operand is already in dptr
      then we do nothing else we move the value to dptr */
@@ -8422,7 +9206,10 @@ genGenPointerGet (operand * left,
       if (AOP_TYPE (left) == AOP_IMMD)
 	{
 	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, FALSE));
-	  emitcode ("mov", "b,#%d", pointerCode (retype));
+	  if (AOP(left)->aopu.aop_immd.from_cast_remat) 
+		  emitcode ("mov", "b,%s",aopGet(AOP (left), AOP_SIZE(left)-1, FALSE, FALSE, FALSE));
+	  else
+		  emitcode ("mov", "b,#%d", pointerCode (retype));
 	}
       else
 	{			/* we need to get it byte by byte */
@@ -8460,7 +9247,6 @@ genGenPointerGet (operand * left,
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE, TRUE);
 
   /* if bit then unpack */
@@ -8475,11 +9261,27 @@ genGenPointerGet (operand * left,
 	{
 	  emitcode ("lcall", "__gptrget");
 	  aopPut (AOP (result), "a", offset++);
-	  if (size)
+	  if (size || (pi && AOP_TYPE (left) != AOP_IMMD))
 	    emitcode ("inc", "dptr");
 	}
     }
 
+  if (pi && AOP_TYPE (left) != AOP_IMMD) {
+    aopPut ( AOP (left), "dpl", 0);
+    aopPut ( AOP (left), "dph", 1);
+    if (options.model == MODEL_FLAT24) {
+	aopPut ( AOP (left), "dpx", 2);
+	aopPut ( AOP (left), "b", 3);	
+    } else  aopPut ( AOP (left), "b", 2);	
+    pi->generated = 1;
+  } else if (OP_SYMBOL(left)->ruonly && AOP_SIZE(result) > 1 &&
+	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+      
+      size = AOP_SIZE (result) - 1;
+      while (size--) emitcode ("lcall","__decdptr");
+  }
+
+  freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
 
@@ -8487,7 +9289,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;
@@ -8511,7 +9313,13 @@ genPointerGet (iCode * ic)
       /* we have to go by the storage class */
       p_type = PTR_TYPE (SPEC_OCLS (etype));
     }
-
+  /* special case when cast remat */
+  if (p_type == GPOINTER && OP_SYMBOL(left)->remat &&
+      IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) {
+	  left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
+	  type =   type = operandType (left);
+	  p_type = DCL_TYPE (type);
+  }
   /* now that we have the pointer type we assign
      the pointer values */
   switch (p_type)
@@ -8519,23 +9327,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);
+      emitcodePointerGet (left, result, ic, pi);
       break;
 
     case GPOINTER:
-      genGenPointerGet (left, result, ic);
+      genGenPointerGet (left, result, ic, pi);
       break;
     }
 
@@ -8594,7 +9402,7 @@ genPackBits (sym_link * etype,
 	      break;
 	    }
 
-	  emitcode ("anl", "a,#0x%02x", (unsigned char)
+	  emitcode ("anl", "a,#!constbyte", (unsigned char)
 		    ((unsigned char) (0xFF << (blen + bstr)) |
 		     (unsigned char) (0xFF >> (8 - bstr))));
 	  emitcode ("orl", "a,b");
@@ -8686,7 +9494,7 @@ genPackBits (sym_link * etype,
 	  break;
 	}
 
-      emitcode ("anl", "a,#0x%02x", ((unsigned char) -1 << rLen));
+      emitcode ("anl", "a,#!constbyte", ((unsigned char) -1 << rLen));
       emitcode ("orl", "a,b");
     }
 
@@ -8744,7 +9552,8 @@ genDataPointerSet (operand * right,
 static void
 genNearPointerSet (operand * right,
 		   operand * result,
-		   iCode * ic)
+		   iCode * ic,
+		   iCode * pi)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -8783,7 +9592,6 @@ genNearPointerSet (operand * right,
   else
     rname = aopGet (AOP (result), 0, FALSE, FALSE, FALSE);
 
-  freeAsmop (result, NULL, ic, TRUE);
   aopOp (right, ic, FALSE, FALSE);
 
   /* if bitfield then unpack the bits */
@@ -8805,7 +9613,7 @@ genNearPointerSet (operand * right,
 	    }
 	  else
 	    emitcode ("mov", "@%s,%s", rname, l);
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "%s", rname);
 	  offset++;
 	}
@@ -8815,6 +9623,7 @@ genNearPointerSet (operand * right,
   if (aop)
     {
       /* we had to allocate for this iCode */
+      if (pi) aopPut (AOP (result),rname,0);
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
@@ -8827,7 +9636,8 @@ genNearPointerSet (operand * right,
       if (AOP_SIZE (right) > 1 &&
 	  !OP_SYMBOL (result)->remat &&
 	  (OP_SYMBOL (result)->liveTo > ic->seq ||
-	   ic->depth))
+	   ic->depth) &&
+	  !pi)
 	{
 	  int size = AOP_SIZE (right) - 1;
 	  while (size--)
@@ -8836,6 +9646,8 @@ genNearPointerSet (operand * right,
     }
 
   /* done */
+  if (pi) pi->generated = 1;
+  freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 
 
@@ -8847,7 +9659,8 @@ genNearPointerSet (operand * right,
 static void
 genPagedPointerSet (operand * right,
 		    operand * result,
-		    iCode * ic)
+		    iCode * ic,
+		    iCode *pi)
 {
   asmop *aop = NULL;
   regs *preg = NULL;
@@ -8874,7 +9687,6 @@ genPagedPointerSet (operand * right,
   else
     rname = aopGet (AOP (result), 0, FALSE, FALSE, FALSE);
 
-  freeAsmop (result, NULL, ic, TRUE);
   aopOp (right, ic, FALSE, FALSE);
 
   /* if bitfield then unpack the bits */
@@ -8893,7 +9705,7 @@ genPagedPointerSet (operand * right,
 	  MOVA (l);
 	  emitcode ("movx", "@%s,a", rname);
 
-	  if (size)
+	  if (size || pi)
 	    emitcode ("inc", "%s", rname);
 
 	  offset++;
@@ -8903,6 +9715,7 @@ genPagedPointerSet (operand * right,
   /* now some housekeeping stuff */
   if (aop)
     {
+      if (pi) aopPut (AOP (result),rname,0);
       /* we had to allocate for this iCode */
       freeAsmop (NULL, aop, ic, TRUE);
     }
@@ -8916,7 +9729,8 @@ genPagedPointerSet (operand * right,
       if (AOP_SIZE (right) > 1 &&
 	  !OP_SYMBOL (result)->remat &&
 	  (OP_SYMBOL (result)->liveTo > ic->seq ||
-	   ic->depth))
+	   ic->depth) &&
+	  !pi)
 	{
 	  int size = AOP_SIZE (right) - 1;
 	  while (size--)
@@ -8925,6 +9739,8 @@ genPagedPointerSet (operand * right,
     }
 
   /* done */
+  if (pi) pi->generated = 1;
+  freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 
 
@@ -8935,9 +9751,9 @@ genPagedPointerSet (operand * right,
 /*-----------------------------------------------------------------*/
 static void
 genFarPointerSet (operand * right,
-		  operand * result, iCode * ic)
+		  operand * result, iCode * ic, iCode *pi)
 {
-  int size, offset;
+  int size, offset, dopi=1;
   sym_link *retype = getSpec (operandType (right));
   sym_link *letype = getSpec (operandType (result));
 
@@ -8972,12 +9788,12 @@ genFarPointerSet (operand * right,
 	        emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
+	      dopi=0;
 	    }
 	  _endLazyDPSEvaluation ();
 	}
     }
   /* so dptr know contains the address */
-  freeAsmop (result, NULL, ic, TRUE);
   aopOp (right, ic, FALSE, TRUE);
 
   /* if bit then unpack */
@@ -8998,12 +9814,25 @@ genFarPointerSet (operand * right,
 	  _flushLazyDPS ();
 
 	  emitcode ("movx", "@dptr,a");
-	  if (size)
+	  if (size || (dopi && pi && AOP_TYPE (result) != AOP_IMMD))
 	    emitcode ("inc", "dptr");
 	}
       _endLazyDPSEvaluation ();
     }
 
+  if (dopi && pi && AOP_TYPE (result) != AOP_IMMD) {
+      aopPut (AOP(result),"dpl",0);
+      aopPut (AOP(result),"dph",1);
+      if (options.model == MODEL_FLAT24)
+	  aopPut (AOP(result),"dpx",2);
+      pi->generated=1;
+  } else if (OP_SYMBOL(result)->ruonly && AOP_SIZE(right) > 1 &&
+	     (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
+      
+      size = AOP_SIZE (right) - 1;
+      while (size--) emitcode ("lcall","__decdptr");
+  }
+  freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 }
 
@@ -9012,13 +9841,13 @@ 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));
   sym_link *letype = getSpec (operandType (result));
 
-  aopOp (result, ic, FALSE, TRUE);
+  aopOp (result, ic, FALSE, OP_SYMBOL(result)->ruonly ? FALSE : TRUE);
 
   /* if the operand is already in dptr
      then we do nothing else we move the value to dptr */
@@ -9029,7 +9858,10 @@ genGenPointerSet (operand * right,
       if (AOP_TYPE (result) == AOP_IMMD)
 	{
 	  emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
-	  emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
+	  if (AOP(result)->aopu.aop_immd.from_cast_remat) 
+		  emitcode ("mov", "b,%s",aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE, FALSE));
+	  else
+		  emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
 	}
       else
 	{			/* we need to get it byte by byte */
@@ -9045,7 +9877,6 @@ genGenPointerSet (operand * right,
       _endLazyDPSEvaluation ();
     }
   /* so dptr know contains the address */
-  freeAsmop (result, NULL, ic, TRUE);
   aopOp (right, ic, FALSE, TRUE);
 
   /* if bit then unpack */
@@ -9066,12 +9897,29 @@ genGenPointerSet (operand * right,
 	  _flushLazyDPS ();
 
 	  emitcode ("lcall", "__gptrput");
-	  if (size)
+	  if (size || (pi && AOP_TYPE (result) != AOP_IMMD))
 	    emitcode ("inc", "dptr");
 	}
       _endLazyDPSEvaluation ();
     }
 
+  if (pi && AOP_TYPE (result) != AOP_IMMD) {
+      aopPut (AOP(result),"dpl",0);
+      aopPut (AOP(result),"dph",1);
+      if (options.model == MODEL_FLAT24) {
+	  aopPut (AOP(result),"dpx",2);
+	  aopPut (AOP(result),"b",3);
+      } else {
+	  aopPut (AOP(result),"b",2);
+      }
+      pi->generated=1;
+  } else if (OP_SYMBOL(result)->ruonly && AOP_SIZE(right) > 1 &&
+	     (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
+      
+      size = AOP_SIZE (right) - 1;
+      while (size--) emitcode ("lcall","__decdptr");
+  }
+  freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 }
 
@@ -9079,7 +9927,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;
@@ -9105,6 +9953,13 @@ genPointerSet (iCode * ic)
       /* we have to go by the storage class */
       p_type = PTR_TYPE (SPEC_OCLS (etype));
     }
+  /* special case when cast remat */
+  if (p_type == GPOINTER && OP_SYMBOL(result)->remat &&
+      IS_CAST_ICODE(OP_SYMBOL(result)->rematiCode)) {
+	  result = IC_RIGHT(OP_SYMBOL(result)->rematiCode);
+	  type =   type = operandType (result);
+	  p_type = DCL_TYPE (type);
+  }
 
   /* now that we have the pointer type we assign
      the pointer values */
@@ -9113,19 +9968,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;
     }
 
@@ -9185,47 +10040,66 @@ genAddrOf (iCode * ic)
   /* if the operand is on the stack then we
      need to get the stack offset of this
      variable */
-  if (sym->onStack)
-    {
-      /* if it has an offset then we need to compute
-         it */
-      if (sym->stack)
-	{
-	  emitcode ("mov", "a,_bp");
-	  emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
-	  aopPut (AOP (IC_RESULT (ic)), "a", 0);
-	}
-      else
-	{
-	  /* we can just move _bp */
-	  aopPut (AOP (IC_RESULT (ic)), "_bp", 0);
-	}
-      /* 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");
-	}
+  if (sym->onStack) {
+      
+      /* if 10 bit stack */
+      if (options.stack10bit) {
+	  char buff[10];
+	  tsprintf(buff,"#!constbyte",(options.stack_loc >> 16) & 0xff);
+	  /* if it has an offset then we need to compute it */
+	  emitcode ("subb", "a,#!constbyte",
+		    -((sym->stack < 0) ?
+		      ((short) (sym->stack - _G.nRegsSaved)) :
+		      ((short) sym->stack)) & 0xff);
+	  emitcode ("mov","b,a");
+	  emitcode ("mov","a,#!constbyte",(-((sym->stack < 0) ?
+					 ((short) (sym->stack - _G.nRegsSaved)) :
+					 ((short) sym->stack)) >> 8) & 0xff);
+	  if (sym->stack) {
+	      emitcode ("mov", "a,_bpx");
+	      emitcode ("add", "a,#!constbyte", ((sym->stack < 0) ? 
+					     ((char) (sym->stack - _G.nRegsSaved)) :
+					     ((char) sym->stack )) & 0xff);
+	      emitcode ("mov", "b,a");
+	      emitcode ("mov", "a,_bpx+1");
+	      emitcode ("addc","a,#!constbyte", (((sym->stack < 0) ? 
+					      ((short) (sym->stack - _G.nRegsSaved)) :
+					      ((short) sym->stack )) >> 8) & 0xff);
+	      aopPut (AOP (IC_RESULT (ic)), "b", 0);
+	      aopPut (AOP (IC_RESULT (ic)), "a", 1);
+	      aopPut (AOP (IC_RESULT (ic)), buff, 2);
+	  } else {
+	      /* we can just move _bp */
+	      aopPut (AOP (IC_RESULT (ic)), "_bpx", 0);
+	      aopPut (AOP (IC_RESULT (ic)), "_bpx+1", 1);
+	      aopPut (AOP (IC_RESULT (ic)), buff, 2);
+	  }	  
+      } else {
+	  /* if it has an offset then we need to compute it */
+	  if (sym->stack) {
+	      emitcode ("mov", "a,_bp");
+	      emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff));
+	      aopPut (AOP (IC_RESULT (ic)), "a", 0);
+	  } else {
+	      /* we can just move _bp */
+	      aopPut (AOP (IC_RESULT (ic)), "_bp", 0);
+	  }
+	  /* 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
-	    {
+	  offset = 1;
+	  while (size--) {
 	      aopPut (AOP (IC_RESULT (ic)), zero, offset++);
-	    }
-	}
-
+	  }      
+      }
       goto release;
-    }
+  }
 
   /* object not on stack then we need the name */
   size = AOP_SIZE (IC_RESULT (ic));
@@ -9234,12 +10108,24 @@ genAddrOf (iCode * ic)
   while (size--)
     {
       char s[SDCC_NAME_MAX];
-      if (offset)
-	sprintf (s, "#(%s >> %d)",
-		 sym->rname,
-		 offset * 8);
-      else
-	sprintf (s, "#%s", sym->rname);
+      if (offset) {
+	  switch (offset) {
+	  case 1:
+	      tsprintf(s,"!his",sym->rname);
+	      break;
+	  case 2:
+	      tsprintf(s,"!hihis",sym->rname);
+	      break;
+	  case 3:
+	      tsprintf(s,"!hihihis",sym->rname);
+	      break;
+	  default: /* should not need this (just in case) */
+	      sprintf (s, "#(%s >> %d)",
+		       sym->rname,
+		       offset * 8);
+	  }
+      } else
+	  sprintf (s, "#%s", sym->rname);
       aopPut (AOP (IC_RESULT (ic)), s, offset++);
     }
 
@@ -9259,6 +10145,7 @@ genArrayInit (iCode * ic)
     int         elementSize = 0, eIndex;
     unsigned    val, lastVal;
     sym_link    *type;
+    operand     *left=IC_LEFT(ic);
     
     D (emitcode (";", "genArrayInit "););
 
@@ -9272,9 +10159,17 @@ genArrayInit (iCode * ic)
     }
     else if (AOP_TYPE(IC_LEFT(ic)) != AOP_DPTR)
     {
-	werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-		"Unexpected operand to genArrayInit.\n");
-	exit(1);
+#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));
@@ -9313,10 +10208,10 @@ genArrayInit (iCode * ic)
 		tlbl = newiTempLabel (NULL);
 		if (firstpass || (count & 0xff))
 		{
-		    emitcode("mov", "b, #0x%x", count & 0xff);
+		    emitcode("mov", "b, #!constbyte", count & 0xff);
 		}
 		
-		emitcode ("", "%05d$:", tlbl->key + 100);
+		emitcode ("", "!tlabeldef", tlbl->key + 100);
 	    }
 	    
 	    firstpass = FALSE;
@@ -9326,7 +10221,7 @@ genArrayInit (iCode * ic)
 		val = (((int)iLoop->literalValue) >> (eIndex * 8)) & 0xff;
 		if (val != lastVal)
 		{
-		    emitcode("mov", "a, #0x%x", val);
+		    emitcode("mov", "a, #!constbyte", val);
 		    lastVal = val;
 		}
 		
@@ -9336,7 +10231,7 @@ genArrayInit (iCode * ic)
 	    
 	    if (count > 1)
 	    {
-		emitcode("djnz", "b, %05d$", tlbl->key + 100);
+		emitcode("djnz", "b, !tlabel", tlbl->key + 100);
 	    }
 	    
 	    ix -= count;
@@ -9391,7 +10286,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)"););
-      emitcode("mov", "dps, #0x21"); 	/* Select DPTR2 & auto-toggle. */
+      emitcode("mov", "dps,#!constbyte",0x21); 	/* Select DPTR2 & auto-toggle. */
       emitcode ("mov", "dptr,#%s", rSym->rname); 
       /* DP2 = result, DP1 = right, DP1 is current. */
       while (size)
@@ -9404,13 +10299,13 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
                emitcode("inc", "dptr");
           }
       }
-      emitcode("mov", "dps, #0");
+      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", "dps,#1"); 	/* Select DPTR2. */
         emitcode ("mov", "dptr,#%s", rSym->rname); 
         /* DP2 = result, DP1 = right, DP1 is current. */
         while (size)
@@ -9425,7 +10320,7 @@ no time to test now, so later well put in...kpb
             emitcode("inc", "dptr");
           emitcode("inc", "dps");
         }
-        emitcode("mov", "dps, #0");
+        emitcode("mov", "dps,#0");
         freeAsmop (right, NULL, ic, FALSE);
 #endif
   }
@@ -9590,13 +10485,13 @@ genJumpTab (iCode * ic)
   freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
 
   jtab = newiTempLabel (NULL);
-  emitcode ("mov", "dptr,#%05d$", jtab->key + 100);
+  emitcode ("mov", "dptr,#!tlabel", jtab->key + 100);
   emitcode ("jmp", "@a+dptr");
-  emitcode ("", "%05d$:", jtab->key + 100);
+  emitcode ("", "!tlabeldef", jtab->key + 100);
   /* now generate the jump labels */
   for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab;
        jtab = setNextItem (IC_JTLABELS (ic)))
-    emitcode ("ljmp", "%05d$", jtab->key + 100);
+    emitcode ("ljmp", "!tlabel", jtab->key + 100);
 
 }
 
@@ -9894,24 +10789,24 @@ genDjnz (iCode * ic, iCode * ifx)
       }
       emitcode ("dec", "%s", rByte);
       aopPut(AOP(IC_RESULT(ic)), rByte, 0);
-      emitcode ("jnz", "%05d$", lbl->key + 100);
+      emitcode ("jnz", "!tlabel", lbl->key + 100);
   }
   else if (IS_AOP_PREG (IC_RESULT (ic)))
     {
       emitcode ("dec", "%s",
 		aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, FALSE));
       emitcode ("mov", "a,%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, FALSE));
-      emitcode ("jnz", "%05d$", lbl->key + 100);
+      emitcode ("jnz", "!tlabel", lbl->key + 100);
     }
   else
     {
-      emitcode ("djnz", "%s,%05d$", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, TRUE, FALSE),
+      emitcode ("djnz", "%s,!tlabel", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, TRUE, FALSE),
 		lbl->key + 100);
     }
-  emitcode ("sjmp", "%05d$", lbl1->key + 100);
-  emitcode ("", "%05d$:", lbl->key + 100);
-  emitcode ("ljmp", "%05d$", IC_TRUE (ifx)->key + 100);
-  emitcode ("", "%05d$:", lbl1->key + 100);
+  emitcode ("sjmp", "!tlabel", lbl1->key + 100);
+  emitcode ("", "!tlabeldef", lbl->key + 100);
+  emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
+  emitcode ("", "!tlabeldef", lbl1->key + 100);
 
   freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
   ifx->generated = 1;
@@ -9961,6 +10856,919 @@ genReceive (iCode * ic)
   freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
 }
 
+/*-----------------------------------------------------------------*/
+/* genMemcpyX2X - gen code for memcpy xdata to xdata               */
+/*-----------------------------------------------------------------*/
+static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
+{
+    operand *from , *to , *count;
+    symbol *lbl;
+    bitVect *rsave;
+    int i;
+
+    /* we know it has to be 3 parameters */
+    assert (nparms == 3);
+    
+    rsave = newBitVect(16);
+    /* save DPTR if it needs to be saved */
+    for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	    if (bitVectBitValue(ic->rMask,i))
+		    rsave = bitVectSetBit(rsave,i);
+    }
+    rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+						  ds390_rUmaskForOp (IC_RESULT(ic))));
+    savermask(rsave);
+    
+    to = parms[0];
+    from = parms[1];
+    count = parms[2];
+
+    aopOp (from, ic->next, FALSE, FALSE);
+
+    /* get from into DPTR1 */
+    emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, TRUE));
+    emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, TRUE));
+    if (options.model == MODEL_FLAT24) {
+	emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, TRUE));
+    }
+
+    freeAsmop (from, NULL, ic, FALSE);
+    aopOp (to, ic, FALSE, FALSE);
+    /* get "to" into DPTR */
+    /* if the operand is already in dptr
+       then we do nothing else we move the value to dptr */
+    if (AOP_TYPE (to) != AOP_STR) {
+	/* if already in DPTR then we need to push */
+	if (AOP_TYPE(to) == AOP_DPTR) {
+	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
+	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+	    if (options.model == MODEL_FLAT24)
+		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+	    emitcode ("pop", "dph");
+	    emitcode ("pop", "dpl");	    
+	} else {
+	    _startLazyDPSEvaluation ();
+	    /* if this is remateriazable */
+	    if (AOP_TYPE (to) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+	    } else {			/* we need to get it byte by byte */
+		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
+		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+		if (options.model == MODEL_FLAT24) {
+		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+		}
+	    }
+	    _endLazyDPSEvaluation ();
+	}
+    }
+    freeAsmop (to, NULL, ic, FALSE);
+
+    aopOp (count, ic->next->next, FALSE,FALSE);
+    lbl =newiTempLabel(NULL);
+
+    /* now for the actual copy */
+    if (AOP_TYPE(count) == AOP_LIT && 
+	(int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+	emitcode (";","OH  JOY auto increment with djnz (very fast)");
+	emitcode ("mov", "dps,#!constbyte",0x21); 	/* Select DPTR2 & auto-toggle. */
+	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
+	emitcode ("","!tlabeldef",lbl->key+100);
+	if (fromc) {
+	    emitcode ("clr","a");
+	    emitcode ("movc", "a,@a+dptr");
+	} else 
+	    emitcode ("movx", "a,@dptr");
+	emitcode ("movx", "@dptr,a");
+	emitcode ("inc", "dptr");
+	emitcode ("inc", "dptr");
+	emitcode ("djnz","b,!tlabel",lbl->key+100);
+    } else {
+	symbol *lbl1 = newiTempLabel(NULL);
+	
+	emitcode (";"," Auto increment but no djnz");
+	emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
+	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
+	emitcode ("mov", "dps,#!constbyte",0x21); 	/* Select DPTR2 & auto-toggle. */
+	emitcode ("","!tlabeldef",lbl->key+100);
+	if (fromc) {
+	    emitcode ("clr","a");
+	    emitcode ("movc", "a,@a+dptr");
+	} else 
+	    emitcode ("movx", "a,@dptr");
+	emitcode ("movx", "@dptr,a");
+	emitcode ("inc", "dptr");
+	emitcode ("inc", "dptr");
+	emitcode ("mov","a,b");
+	emitcode ("orl","a,_ap");
+	emitcode ("jz","!tlabel",lbl1->key+100);
+	emitcode ("mov","a,_ap");
+	emitcode ("add","a,#!constbyte",0xFF);
+	emitcode ("mov","_ap,a");
+	emitcode ("mov","a,b");
+	emitcode ("addc","a,#!constbyte",0xFF);
+	emitcode ("mov","b,a");
+	emitcode ("sjmp","!tlabel",lbl->key+100);
+	emitcode ("","!tlabeldef",lbl1->key+100);
+    }
+    emitcode ("mov", "dps,#0"); 
+    freeAsmop (count, NULL, ic, FALSE);
+    unsavermask(rsave);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genMemsetX - gencode for memSetX data                           */
+/*-----------------------------------------------------------------*/
+static void genMemsetX(iCode *ic, int nparms, operand **parms)
+{
+    operand *to , *val , *count;
+    symbol *lbl;
+    char *l;
+    int i;
+    bitVect *rsave = NULL;
+
+    /* we know it has to be 3 parameters */
+    assert (nparms == 3);
+    
+    to = parms[0];
+    val = parms[1];
+    count = parms[2];
+        
+    /* save DPTR if it needs to be saved */
+    rsave = newBitVect(16);
+    for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	    if (bitVectBitValue(ic->rMask,i))
+		    rsave = bitVectSetBit(rsave,i);
+    }
+    rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+						  ds390_rUmaskForOp (IC_RESULT(ic))));
+    savermask(rsave);
+
+    aopOp (to, ic, FALSE, FALSE);
+    /* get "to" into DPTR */
+    /* if the operand is already in dptr
+       then we do nothing else we move the value to dptr */
+    if (AOP_TYPE (to) != AOP_STR) {
+	/* if already in DPTR then we need to push */
+	if (AOP_TYPE(to) == AOP_DPTR) {
+	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
+	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+	    if (options.model == MODEL_FLAT24)
+		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+	    emitcode ("pop", "dph");
+	    emitcode ("pop", "dpl");	    
+	} else {
+	    _startLazyDPSEvaluation ();
+	    /* if this is remateriazable */
+	    if (AOP_TYPE (to) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+	    } else {			/* we need to get it byte by byte */
+		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
+		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+		if (options.model == MODEL_FLAT24) {
+		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+		}
+	    }
+	    _endLazyDPSEvaluation ();
+	}
+    }
+    freeAsmop (to, NULL, ic, FALSE);
+
+    aopOp (val, ic->next->next, FALSE,FALSE);
+    aopOp (count, ic->next->next, FALSE,FALSE);    
+    lbl =newiTempLabel(NULL);
+    /* now for the actual copy */
+    if (AOP_TYPE(count) == AOP_LIT && 
+	(int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+	l = aopGet(AOP (val), 0, FALSE, FALSE, TRUE);
+	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
+	MOVA(l);
+	emitcode ("","!tlabeldef",lbl->key+100);
+	emitcode ("movx", "@dptr,a");
+	emitcode ("inc", "dptr");
+	emitcode ("djnz","b,!tlabel",lbl->key+100);
+    } else {
+	symbol *lbl1 = newiTempLabel(NULL);
+	
+	emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
+	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
+	emitcode ("","!tlabeldef",lbl->key+100);
+	l = aopGet(AOP (val), 0, FALSE, FALSE, TRUE);
+	MOVA(l);
+	emitcode ("movx", "a,@dptr");
+	emitcode ("inc", "dptr");
+	emitcode ("mov","a,b");
+	emitcode ("orl","a,_ap");
+	emitcode ("jz","!tlabel",lbl1->key+100);
+	emitcode ("mov","a,_ap");
+	emitcode ("add","a,#!constbyte",0xFF);
+	emitcode ("mov","_ap,a");
+	emitcode ("mov","a,b");
+	emitcode ("addc","a,#!constbyte",0xFF);
+	emitcode ("mov","b,a");
+	emitcode ("sjmp","!tlabel",lbl->key+100);
+	emitcode ("","!tlabeldef",lbl1->key+100);
+    }
+    freeAsmop (count, NULL, ic, FALSE);
+    unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibLoadPrimitive - calls TINI api function to load primitive */
+/*-----------------------------------------------------------------*/
+static void genNatLibLoadPrimitive(iCode *ic, int nparms, operand **parms,int size)
+{
+	bitVect *rsave ;
+	operand *pnum, *result;
+	int i;
+    
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+    
+	pnum = parms[0]; 
+	aopOp (pnum, ic, FALSE, FALSE);
+	emitcode ("mov","a,%s",aopGet(AOP(pnum),0,FALSE,FALSE,FALSE));
+	freeAsmop (pnum, NULL, ic, FALSE);
+	emitcode ("lcall","NatLib_LoadPrimitive");
+	aopOp (result=IC_RESULT(ic), ic, FALSE, FALSE);
+	if (aopHasRegs(AOP(result),R0_IDX,R1_IDX) || 
+	    aopHasRegs(AOP(result),R2_IDX,R3_IDX) ) {
+		for (i = (size-1) ; i >= 0 ; i-- ) {
+			emitcode ("push","a%s",javaRet[i]);
+		}
+		for (i=0; i < size ; i++ ) {
+			emitcode ("pop","a%s",aopGet(AOP(result),i,FALSE,FALSE,FALSE));
+		}
+	} else {
+		for (i = 0 ; i < size ; i++ ) {
+			aopPut(AOP(result),javaRet[i],i);
+		}
+	}    
+	freeAsmop (result, NULL, ic, FALSE);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibLoadPointer - calls TINI api function to load pointer  */
+/*-----------------------------------------------------------------*/
+static void genNatLibLoadPointer(iCode *ic, int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *pnum, *result;
+	int size = 3;
+	int i;
+    
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+    
+	pnum = parms[0]; 
+	aopOp (pnum, ic, FALSE, FALSE);
+	emitcode ("mov","a,%s",aopGet(AOP(pnum),0,FALSE,FALSE,FALSE));
+	freeAsmop (pnum, NULL, ic, FALSE);
+	emitcode ("lcall","NatLib_LoadPointer");
+	aopOp (result=IC_RESULT(ic), ic, FALSE, FALSE);
+	if (AOP_TYPE(result)!=AOP_STR) {
+		for (i = 0 ; i < size ; i++ ) {
+			aopPut(AOP(result),fReturn[i],i);
+		}
+	}    
+	freeAsmop (result, NULL, ic, FALSE);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibInstallStateBlock - 				   */
+/*-----------------------------------------------------------------*/
+static void genNatLibInstallStateBlock(iCode *ic, int nparms, 
+				       operand **parms, const char *name)
+{
+	bitVect *rsave ;
+	operand *psb, *handle;
+	assert (nparms==2);
+
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+	psb = parms[0];
+	handle = parms[1];
+
+	/* put pointer to state block into DPTR1 */
+	aopOp (psb, ic, FALSE, FALSE);
+	if (AOP_TYPE (psb) == AOP_IMMD) {
+		emitcode ("mov","dps,#1");
+		emitcode ("mov", "dptr,%s", aopGet (AOP (psb), 0, TRUE, FALSE, FALSE));
+		emitcode ("mov","dps,#0");
+	} else {
+		emitcode ("mov","dpl1,%s",aopGet(AOP(psb),0,FALSE,FALSE,FALSE));
+		emitcode ("mov","dph1,%s",aopGet(AOP(psb),1,FALSE,FALSE,FALSE));
+		emitcode ("mov","dpx1,%s",aopGet(AOP(psb),2,FALSE,FALSE,FALSE));
+	}
+	freeAsmop (psb, NULL, ic, FALSE);
+
+	/* put libraryID into DPTR */
+	emitcode ("mov","dptr,#LibraryID");
+
+	/* put handle into r3:r2 */
+	aopOp (handle, ic, FALSE, FALSE);
+	if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+		emitcode ("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));	
+		emitcode ("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+		emitcode ("pop","ar3");
+		emitcode ("pop","ar2");
+	} else {	
+		emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));	
+		emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+	}
+	freeAsmop (psb, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","NatLib_Install%sStateBlock",name);
+
+	/* put return value into place*/
+	_G.accInUse++;
+	aopOp (IC_RESULT(ic), ic, FALSE, FALSE);
+	_G.accInUse--;
+	aopPut(AOP(IC_RESULT(ic)),"a",0);
+	freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibRemoveStateBlock -                                     */
+/*-----------------------------------------------------------------*/
+static void genNatLibRemoveStateBlock(iCode *ic,int nparms,const char *name)
+{
+	bitVect *rsave ;
+
+	assert(nparms==0);
+
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+
+	/* put libraryID into DPTR */
+	emitcode ("mov","dptr,#LibraryID");
+	/* make the call */
+	emitcode ("lcall","NatLib_Remove%sStateBlock",name);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibGetStateBlock -                                        */
+/*-----------------------------------------------------------------*/
+static void genNatLibGetStateBlock(iCode *ic,int nparms,
+				   operand **parms,const char *name)
+{
+	bitVect *rsave ;
+	symbol *lbl = newiTempLabel(NULL);
+	
+	assert(nparms==0);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+
+	/* put libraryID into DPTR */
+	emitcode ("mov","dptr,#LibraryID");
+	/* make the call */
+	emitcode ("lcall","NatLib_Remove%sStateBlock",name);
+	emitcode ("jnz","!tlabel",lbl->key+100);
+
+	/* put return value into place */
+	aopOp(IC_RESULT(ic),ic,FALSE,FALSE);
+	if (aopHasRegs(AOP(IC_RESULT(ic)),R2_IDX,R3_IDX)) {
+		emitcode ("push","ar3");
+		emitcode ("push","ar2");
+		emitcode ("pop","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,TRUE,FALSE));
+		emitcode ("pop","%s",aopGet(AOP(IC_RESULT(ic)),1,FALSE,TRUE,FALSE));
+	} else {
+		aopPut(AOP(IC_RESULT(ic)),"r2",0);
+		aopPut(AOP(IC_RESULT(ic)),"r3",1);
+	}
+	freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	emitcode ("","!tlabeldef",lbl->key+100);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMMalloc -                                                   */
+/*-----------------------------------------------------------------*/
+static void genMMMalloc (iCode *ic,int nparms, operand **parms,
+			 int size, const char *name)
+{
+	bitVect *rsave ;
+	operand *bsize;
+	symbol *rsym;
+	symbol *lbl = newiTempLabel(NULL);
+
+	assert (nparms == 1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	bsize=parms[0];
+	aopOp (bsize,ic,FALSE,FALSE);
+
+	/* put the size in R4-R2 */
+	if (aopHasRegs(AOP(bsize),R2_IDX, (size==3 ? R4_IDX: R3_IDX))) {
+		emitcode("push","%s",aopGet(AOP(bsize),0,FALSE,TRUE,FALSE));
+		emitcode("push","%s",aopGet(AOP(bsize),1,FALSE,TRUE,FALSE));
+		if (size==3) {
+			emitcode("push","%s",aopGet(AOP(bsize),2,FALSE,TRUE,FALSE));
+			emitcode("pop","ar4");
+		}
+		emitcode("pop","ar3");
+		emitcode("pop","ar2");		
+	} else {
+		emitcode ("mov","r2,%s",aopGet(AOP(bsize),0,FALSE,TRUE,FALSE));
+		emitcode ("mov","r3,%s",aopGet(AOP(bsize),1,FALSE,TRUE,FALSE));
+		if (size==3) {
+			emitcode("mov","r4,%s",aopGet(AOP(bsize),2,FALSE,TRUE,FALSE));
+		}
+	}
+	freeAsmop (bsize, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","MM_%s",name);
+	emitcode ("jz","!tlabel",lbl->key+100);
+	emitcode ("mov","r2,#!constbyte",0xff);
+	emitcode ("mov","r3,#!constbyte",0xff);
+	emitcode ("","!tlabeldef",lbl->key+100);
+	/* we don't care about the pointer : we just save the handle */
+	rsym = OP_SYMBOL(IC_RESULT(ic));
+	if (rsym->liveFrom != rsym->liveTo) {
+		aopOp(IC_RESULT(ic),ic,FALSE,FALSE);
+		if (aopHasRegs(AOP(IC_RESULT(ic)),R2_IDX,R3_IDX)) {
+			emitcode ("push","ar3");
+			emitcode ("push","ar2");
+			emitcode ("pop","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,TRUE,FALSE));
+			emitcode ("pop","%s",aopGet(AOP(IC_RESULT(ic)),1,FALSE,TRUE,FALSE));
+		} else {
+			aopPut(AOP(IC_RESULT(ic)),"r2",0);
+			aopPut(AOP(IC_RESULT(ic)),"r3",1);
+		}
+		freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	}
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMDeref -                                                    */
+/*-----------------------------------------------------------------*/
+static void genMMDeref (iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *handle;
+
+	assert (nparms == 1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	handle=parms[0];
+	aopOp (handle,ic,FALSE,FALSE);
+
+	/* put the size in R4-R2 */
+	if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+		emitcode("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+		emitcode("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+		emitcode("pop","ar3");
+		emitcode("pop","ar2");		
+	} else {
+		emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+		emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+	}
+	freeAsmop (handle, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","MM_Deref");
+	
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {			
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			if (AOP_TYPE(IC_RESULT(ic)) != AOP_STR) {
+				aopPut(AOP(IC_RESULT(ic)),"dpl",0);
+				aopPut(AOP(IC_RESULT(ic)),"dph",1);
+				aopPut(AOP(IC_RESULT(ic)),"dpx",2);
+			}
+		}
+	}
+	freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMUnrestrictedPersist -                                      */
+/*-----------------------------------------------------------------*/
+static void genMMUnrestrictedPersist(iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *handle;
+
+	assert (nparms == 1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	handle=parms[0];
+	aopOp (handle,ic,FALSE,FALSE);
+
+	/* put the size in R3-R2 */
+	if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+		emitcode("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+		emitcode("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+		emitcode("pop","ar3");
+		emitcode("pop","ar2");		
+	} else {
+		emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+		emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+	}
+	freeAsmop (handle, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","MM_UnrestrictedPersist");
+
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemExecJavaProcess -                                      */
+/*-----------------------------------------------------------------*/
+static void genSystemExecJavaProcess(iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *handle, *pp;
+
+	assert (nparms==2);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	pp = parms[0];
+	handle = parms[1];
+	
+	/* put the handle in R3-R2 */
+	aopOp (handle,ic,FALSE,FALSE);
+	if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+		emitcode("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+		emitcode("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+		emitcode("pop","ar3");
+		emitcode("pop","ar2");		
+	} else {
+		emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,FALSE));
+		emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,FALSE));
+	}
+	freeAsmop (handle, NULL, ic, FALSE);
+	
+	/* put pointer in DPTR */
+	aopOp (pp,ic,FALSE,FALSE);
+	if (AOP_TYPE(pp) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s", aopGet (AOP (pp), 0, TRUE, FALSE, FALSE));		
+	} else if (AOP_TYPE(pp) != AOP_STR) { /* not already in dptr */
+		emitcode ("mov","dpl,%s",aopGet(AOP(pp),0,FALSE,FALSE,FALSE));
+		emitcode ("mov","dph,%s",aopGet(AOP(pp),1,FALSE,FALSE,FALSE));
+		emitcode ("mov","dpx,%s",aopGet(AOP(pp),2,FALSE,FALSE,FALSE));
+	}
+	freeAsmop (handle, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","System_ExecJavaProcess");
+	
+	/* put result in place */
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+	
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemRTCRegisters -                                         */
+/*-----------------------------------------------------------------*/
+static void genSystemRTCRegisters(iCode *ic,int nparms, operand **parms,
+				  char *name)
+{
+	bitVect *rsave ;
+	operand *pp;
+
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	pp=parms[0];
+	/* put pointer in DPTR */
+	aopOp (pp,ic,FALSE,FALSE);
+	if (AOP_TYPE (pp) == AOP_IMMD) {
+		emitcode ("mov","dps,#1");
+		emitcode ("mov", "dptr,%s", aopGet (AOP (pp), 0, TRUE, FALSE, FALSE));
+		emitcode ("mov","dps,#0");
+	} else {
+		emitcode ("mov","dpl1,%s",aopGet(AOP(pp),0,FALSE,FALSE,FALSE));
+		emitcode ("mov","dph1,%s",aopGet(AOP(pp),1,FALSE,FALSE,FALSE));
+		emitcode ("mov","dpx1,%s",aopGet(AOP(pp),2,FALSE,FALSE,FALSE));
+	}
+	freeAsmop (pp, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","System_%sRTCRegisters",name);
+
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemThreadSleep -                                          */
+/*-----------------------------------------------------------------*/
+static void genSystemThreadSleep(iCode *ic,int nparms, operand **parms, char *name)
+{
+	bitVect *rsave ;
+	operand *to, *s;
+
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+
+	to = parms[0];
+	aopOp(to,ic,FALSE,FALSE);
+	if (aopHasRegs(AOP(to),R2_IDX,R3_IDX) ||
+	    aopHasRegs(AOP(to),R0_IDX,R1_IDX) ) {
+		emitcode ("push","%s",aopGet(AOP(to),0,FALSE,TRUE,FALSE));
+		emitcode ("push","%s",aopGet(AOP(to),1,FALSE,TRUE,FALSE));
+		emitcode ("push","%s",aopGet(AOP(to),2,FALSE,TRUE,FALSE));
+		emitcode ("push","%s",aopGet(AOP(to),3,FALSE,TRUE,FALSE));
+		emitcode ("pop","ar3");
+		emitcode ("pop","ar2");
+		emitcode ("pop","ar1");
+		emitcode ("pop","ar0");
+	} else {
+		emitcode ("mov","r0,%s",aopGet(AOP(to),0,FALSE,TRUE,FALSE));
+		emitcode ("mov","r1,%s",aopGet(AOP(to),1,FALSE,TRUE,FALSE));
+		emitcode ("mov","r2,%s",aopGet(AOP(to),2,FALSE,TRUE,FALSE));
+		emitcode ("mov","r3,%s",aopGet(AOP(to),3,FALSE,TRUE,FALSE));
+	}
+	freeAsmop (to, NULL, ic, FALSE);
+
+	/* suspend in acc */
+	s = parms[1];
+	aopOp(s,ic,FALSE,FALSE);
+	emitcode ("mov","a,%s",aopGet(AOP(s),0,FALSE,TRUE,FALSE));
+	freeAsmop (s, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","System_%s",name);
+
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemThreadResume -                                         */
+/*-----------------------------------------------------------------*/
+static void genSystemThreadResume(iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *tid,*pid;
+
+	assert (nparms==2);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+	
+	tid = parms[0];
+	pid = parms[1];
+	
+	/* PID in R0 */
+	aopOp(pid,ic,FALSE,FALSE);
+	emitcode ("mov","r0,%s",aopGet(AOP(pid),0,FALSE,TRUE,FALSE));
+	freeAsmop (pid, NULL, ic, FALSE);
+	
+	/* tid into ACC */
+	aopOp(tid,ic,FALSE,FALSE);
+	emitcode ("mov","a,%s",aopGet(AOP(tid),0,FALSE,TRUE,FALSE));
+	freeAsmop (tid, NULL, ic, FALSE);
+	
+	emitcode ("lcall","System_ThreadResume");
+
+	/* put result into place */
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemProcessResume -                                        */
+/*-----------------------------------------------------------------*/
+static void genSystemProcessResume(iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *pid;
+
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+	
+	pid = parms[0];
+	
+	/* pid into ACC */
+	aopOp(pid,ic,FALSE,FALSE);
+	emitcode ("mov","a,%s",aopGet(AOP(pid),0,FALSE,TRUE,FALSE));
+	freeAsmop (pid, NULL, ic, FALSE);
+	
+	emitcode ("lcall","System_ProcessResume");
+
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystem -                                                     */
+/*-----------------------------------------------------------------*/
+static void genSystem (iCode *ic,int nparms,char *name)
+{
+	assert(nparms == 0);
+
+	emitcode ("lcall","System_%s",name);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemPoll -                                                  */
+/*-----------------------------------------------------------------*/
+static void genSystemPoll(iCode *ic,int nparms, operand **parms,char *name)
+{
+	bitVect *rsave ;
+	operand *fp;
+
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+
+	fp = parms[0];
+	aopOp (fp,ic,FALSE,FALSE);
+	if (AOP_TYPE (fp) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s", aopGet (AOP (fp), 0, TRUE, FALSE, FALSE));
+	} else if (AOP_TYPE(fp) != AOP_STR) { /* not already in dptr */
+		emitcode ("mov","dpl,%s",aopGet(AOP(fp),0,FALSE,FALSE,FALSE));
+		emitcode ("mov","dph,%s",aopGet(AOP(fp),1,FALSE,FALSE,FALSE));
+		emitcode ("mov","dpx,%s",aopGet(AOP(fp),2,FALSE,FALSE,FALSE));
+	}
+	freeAsmop (fp, NULL, ic, FALSE);
+
+	emitcode ("lcall","System_%sPoll",name);
+
+	/* put result into place */
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemGetCurrentID -                                         */
+/*-----------------------------------------------------------------*/
+static void genSystemGetCurrentID(iCode *ic,int nparms, operand **parms,char *name)
+{
+	assert (nparms==0);
+
+	emitcode ("lcall","System_GetCurrent%sId",name);
+	/* put result into place */
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+}
+
+/*-----------------------------------------------------------------*/
+/* genBuiltIn - calls the appropriate function to  generating code */
+/* for a built in function 					   */
+/*-----------------------------------------------------------------*/
+static void genBuiltIn (iCode *ic)
+{
+	operand *bi_parms[MAX_BUILTIN_ARGS];
+	int nbi_parms;
+	iCode *bi_iCode;
+	symbol *bif;
+
+	/* get all the arguments for a built in function */
+	bi_iCode = getBuiltinParms(ic,&nbi_parms,bi_parms);
+
+	/* which function is it */
+	bif = OP_SYMBOL(IC_LEFT(bi_iCode));
+	if (strcmp(bif->name,"__builtin_memcpy_x2x")==0) {
+		genMemcpyX2X(bi_iCode,nbi_parms,bi_parms,0);
+	} else if (strcmp(bif->name,"__builtin_memcpy_c2x")==0) {
+		genMemcpyX2X(bi_iCode,nbi_parms,bi_parms,1);
+	} else if (strcmp(bif->name,"__builtin_memset_x")==0) {
+		genMemsetX(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"NatLib_LoadByte")==0) {
+		genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,1);
+	} else if (strcmp(bif->name,"NatLib_LoadShort")==0) {
+		genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,2);
+	} else if (strcmp(bif->name,"NatLib_LoadInt")==0) {
+		genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,4);
+	} else if (strcmp(bif->name,"NatLib_LoadPointer")==0) {
+		genNatLibLoadPointer(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"NatLib_InstallImmutableStateBlock")==0) {
+		genNatLibInstallStateBlock(bi_iCode,nbi_parms,bi_parms,"Immutable");
+	} else if (strcmp(bif->name,"NatLib_InstallEphemeralStateBlock")==0) {
+		genNatLibInstallStateBlock(bi_iCode,nbi_parms,bi_parms,"Ephemeral");
+	} else if (strcmp(bif->name,"NatLib_RemoveImmutableStateBlock")==0) {
+		genNatLibRemoveStateBlock(bi_iCode,nbi_parms,"Immutable");
+	} else if (strcmp(bif->name,"NatLib_RemoveEphemeralStateBlock")==0) {
+		genNatLibRemoveStateBlock(bi_iCode,nbi_parms,"Ephemeral");
+	} else if (strcmp(bif->name,"NatLib_GetImmutableStateBlock")==0) {
+		genNatLibGetStateBlock(bi_iCode,nbi_parms,bi_parms,"Immutable");
+	} else if (strcmp(bif->name,"NatLib_GetEphemeralStateBlock")==0) {
+		genNatLibGetStateBlock(bi_iCode,nbi_parms,bi_parms,"Ephemeral");
+	} else if (strcmp(bif->name,"MM_XMalloc")==0) {
+		genMMMalloc(bi_iCode,nbi_parms,bi_parms,3,"XMalloc");
+	} else if (strcmp(bif->name,"MM_Malloc")==0) {
+		genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"Malloc");
+	} else if (strcmp(bif->name,"MM_ApplicationMalloc")==0) {
+		genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"ApplicationMalloc");
+	} else if (strcmp(bif->name,"MM_Free")==0) {
+		genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"Free");
+	} else if (strcmp(bif->name,"MM_Deref")==0) {
+		genMMDeref(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"MM_UnrestrictedPersist")==0) {
+		genMMUnrestrictedPersist(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_ExecJavaProcess")==0) {
+		genSystemExecJavaProcess(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_GetRTCRegisters")==0) {
+		genSystemRTCRegisters(bi_iCode,nbi_parms,bi_parms,"Get");
+	} else if (strcmp(bif->name,"System_SetRTCRegisters")==0) {
+		genSystemRTCRegisters(bi_iCode,nbi_parms,bi_parms,"Set");
+	} else if (strcmp(bif->name,"System_ThreadSleep")==0) {
+		genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ThreadSleep");
+	} else if (strcmp(bif->name,"System_ThreadSleep_ExitCriticalSection")==0) {
+		genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ThreadSleep_ExitCriticalSection");
+	} else if (strcmp(bif->name,"System_ProcessSleep")==0) {
+		genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ProcessSleep");
+	} else if (strcmp(bif->name,"System_ProcessSleep_ExitCriticalSection")==0) {
+		genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ProcessSleep_ExitCriticalSection");
+	} else if (strcmp(bif->name,"System_ThreadResume")==0) {
+		genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_SaveThread")==0) {
+		genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_ThreadResume")==0) {
+		genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_ProcessResume")==0) {
+		genSystemProcessResume(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_SaveJavaThreadState")==0) {
+		genSystem(bi_iCode,nbi_parms,"SaveJavaThreadState");
+	} else if (strcmp(bif->name,"System_RestoreJavaThreadState")==0) {
+		genSystem(bi_iCode,nbi_parms,"RestoreJavaThreadState");
+	} else if (strcmp(bif->name,"System_ProcessYield")==0) {
+		genSystem(bi_iCode,nbi_parms,"ProcessYield");
+	} else if (strcmp(bif->name,"System_ProcessSuspend")==0) {
+		genSystem(bi_iCode,nbi_parms,"ProcessSuspend");
+	} else if (strcmp(bif->name,"System_RegisterPoll")==0) {
+		genSystemPoll(bi_iCode,nbi_parms,bi_parms,"Register");
+	} else if (strcmp(bif->name,"System_RemovePoll")==0) {
+		genSystemPoll(bi_iCode,nbi_parms,bi_parms,"Remove");
+	} else if (strcmp(bif->name,"System_GetCurrentThreadId")==0) {
+		genSystemGetCurrentID(bi_iCode,nbi_parms,bi_parms,"Thread");
+	} else if (strcmp(bif->name,"System_GetCurrentProcessId")==0) {
+		genSystemGetCurrentID(bi_iCode,nbi_parms,bi_parms,"Process");
+	} else {
+		werror(E_INTERNAL_ERROR,__FILE__,__LINE__,"unknown builtin function encountered\n");
+		return ;
+	}
+	return ;    
+}
+
 /*-----------------------------------------------------------------*/
 /* gen390Code - generate code for Dallas 390 based controllers     */
 /*-----------------------------------------------------------------*/
@@ -9980,8 +11788,7 @@ gen390Code (iCode * lic)
     fReturn = fReturn16;
     options.stack10bit=0;
   }
-#if 0
-  //REMOVE ME!!!
+#if 1
   /* print the allocation information */
   if (allocInfo)
     printAllocInfo (currFunc, codeOutFile);
@@ -10007,7 +11814,7 @@ gen390Code (iCode * lic)
   for (ic = lic; ic; ic = ic->next)
     {
 
-      if (cln != ic->lineno)
+      if (ic->lineno && cln != ic->lineno)
 	{
 	  if (options.debug)
 	    {
@@ -10017,7 +11824,8 @@ gen390Code (iCode * lic)
 			ic->level, ic->block);
 	      _G.debugLine = 0;
 	    }
-	  emitcode (";", "%s %d", ic->filename, ic->lineno);
+	  emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno, 
+		    printCLine(ic->filename, ic->lineno));
 	  cln = ic->lineno;
 	}
       /* if the result is marked as
@@ -10177,12 +11985,12 @@ gen390Code (iCode * lic)
 	  break;
 
 	case GET_VALUE_AT_ADDRESS:
-	  genPointerGet (ic);
+	  genPointerGet (ic,hasInc(IC_LEFT(ic),ic, getSize(operandType(IC_LEFT(ic)))));
 	  break;
 
 	case '=':
 	  if (POINTER_SET (ic))
-	    genPointerSet (ic);
+	    genPointerSet (ic,hasInc(IC_RESULT(ic),ic,getSize(operandType(IC_RIGHT(ic)))));
 	  else
 	    genAssign (ic);
 	  break;
@@ -10208,7 +12016,8 @@ gen390Code (iCode * lic)
 	  break;
 
 	case SEND:
-	  addSet (&_G.sendSet, ic);
+	  if (ic->builtinSEND) genBuiltIn(ic);
+	  else addSet (&_G.sendSet, ic);
 	  break;
 
 	case ARRAYINIT: